Build a Voice Agent on Edge Compute

import { Agent, rpc, type ActorNamespace } from "@telnyx/edge-runtime";
import { mountAgents } from "@telnyx/edge-runtime/mount";
import { voice, createCallControlClient, type VoiceCall } from "@telnyx/edge-runtime/voice";
import type { WebSocket } from "ws";
import type Telnyx from "telnyx";

const MODEL = "meta-llama/Llama-3.3-70B-Instruct";
const SYSTEM =
  "You are a concise, friendly voice assistant reached over a phone call. " +
  "Answer in one or two short sentences of plain spoken English. No markdown, no lists.";

type ChatMessage = Telnyx.AI.OpenAI.Chat.ChatCreateCompletionParams.Message;

export class Support extends voice(Agent<Env>) {
  /** One turn: start the model on `text` now, commit history once confirmed. */
  async *respond(text: string, commit: Promise<string | undefined>, signal?: AbortSignal): AsyncGenerator<string> {
    const history = (await this.messages.toOpenAI()).slice(-12) as ChatMessage[];
    const convo: ChatMessage[] = [{ role: "system", content: SYSTEM }, ...history, { role: "user", content: text }];

    let answer = "";
    for await (const token of completeStream(this.env.TELNYX, convo, signal)) {
      answer += token;
      yield token;
    }

    // Nothing durable is written until the transcript is confirmed. A turn that
    // ran ahead and one that did not write byte-identical history.
    const confirmed = await commit;
    if (confirmed === undefined) return;
    await this.messages.add("user", confirmed);
    await this.messages.add("assistant", answer);
  }

  /** Spoken as soon as the call is answered, before the caller says anything. */
  protected override greeting(): string {
    return "Hi, this is the Telnyx Edge voice agent. Ask me anything.";
  }

  /** The one required hook. Called the moment the recognizer *guesses* the
   *  caller stopped — do NOT await `call.confirmed` here (see the head start). */
  protected override reply(transcript: string, call: VoiceCall): AsyncGenerator<string> {
    return this.respond(transcript, call.confirmed, call.signal);
  }

  /** Required. The media stream arrives here; `answer` hands it to the voice layer.
   *  Per-call knobs live here, e.g. `this.answer(ws, { bargeIn: { minWords: 2 } })`. */
  override webSocket(ws: WebSocket): void {
    this.answer(ws);
  }
}

const calls = createCallControlClient();

async function webhook(req: Request): Promise<Response> {
  const host = req.headers.get("x-forwarded-host") ?? req.headers.get("host") ?? "";

  let event: { data?: { event_type?: string; payload?: Record<string, unknown> } };
  try {
    event = (await req.json()) as typeof event;
  } catch {
    return new Response("bad json", { status: 400 });
  }

  const type = event.data?.event_type;
  const payload = event.data?.payload ?? {};
  const callControlId = String(payload.call_control_id ?? "");
  if (callControlId === "") return new Response("ok");

  if (type === "call.initiated" && payload.direction === "incoming") {
    await calls.command(callControlId, "answer", {});
  } else if (type === "call.answered") {
    await calls.command(callControlId, "streaming_start", {
      // The id goes in whole, percent-encoded; mountAgents decodes it and runs
      // it through the SDK's reversible encoder, so one call maps to exactly
      // one agent instance.
      stream_url: `wss://${host}/agents/support/${encodeURIComponent(callControlId)}`,
      stream_track: "inbound_track",
      stream_bidirectional_mode: "rtp",
      stream_bidirectional_codec: "PCMU",
      stream_bidirectional_target_legs: "self",
      stream_bidirectional_sampling_rate: 8000,
    });
  }

  return new Response("ok");
}

interface Env {
  SUPPORT: ActorNamespace;
  /** The `[telnyx]` binding: a Telnyx client the platform hands you already credentialed. */
  TELNYX: Telnyx;
}

export default {
  fetch: mountAgents<Env>((env) => ({ support: env.SUPPORT }), { fallback: webhook }),
};

async function* completeStream(telnyx: Telnyx, messages: ChatMessage[], signal?: AbortSignal): AsyncGenerator<string> {
  const res = await telnyx.ai.openai.chat
    .createCompletion({ model: MODEL, messages, stream: true, max_tokens: 120 }, { signal })
    .asResponse();
  if (!res.ok || res.body === null) throw new Error(`chat completion ${res.status}`);

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  let buffered = "";
  for (;;) {
    const { value, done } = await reader.read();
    if (done) break;
    buffered += decoder.decode(value, { stream: true });
    let nl: number;
    while ((nl = buffered.indexOf("\n")) >= 0) {
      const line = buffered.slice(0, nl).trim();
      buffered = buffered.slice(nl + 1);
      if (!line.startsWith("data:")) continue;
      const data = line.slice(5).trim();
      if (data === "[DONE]") return;
      try {
        const token = JSON.parse(data)?.choices?.[0]?.delta?.content;
        if (token) yield token;
      } catch {
        /* keep-alive or partial line */
      }
    }
  }
}

name = "voice-minimal"
main = "src/index.ts"
compatibility_date = "2026-09-15"

[[actors]]
binding = "SUPPORT"
type    = "Support"

[telnyx]
binding = "TELNYX"

# Written by `new-func` — keep as generated (do not edit or remove).
[edge_compute]
func_id   = "00000000-0000-0000-0000-000000000000"
func_name = "voice-minimal"