@alexkroman1/aai 1.7.0 → 1.8.0

package/host/transports/openai-realtime-transport.test.ts

@@ -0,0 +1,371 @@
+// Copyright 2026 the AAI authors. MIT license.
+import { describe, expect, test, vi } from "vitest";
+import { silentLogger } from "../_test-utils.ts";
+import {
+  createOpenaiRealtimeTransport,
+  type OpenaiRealtimeWebSocket,
+} from "./openai-realtime-transport.ts";
+import type { TransportCallbacks } from "./types.ts";
+
+function noopCallbacks(): TransportCallbacks {
+  return {
+    onReplyStarted: vi.fn(),
+    onReplyDone: vi.fn(),
+    onCancelled: vi.fn(),
+    onAudioChunk: vi.fn(),
+    onAudioDone: vi.fn(),
+    onUserTranscript: vi.fn(),
+    onAgentTranscript: vi.fn(),
+    onToolCall: vi.fn(),
+    onError: vi.fn(),
+    onSpeechStarted: vi.fn(),
+    onSpeechStopped: vi.fn(),
+  };
+}
+
+type Listener = (ev: unknown) => void;
+
+function makeFakeWs() {
+  const listeners: Record<string, Listener[]> = {
+    open: [],
+    message: [],
+    close: [],
+    error: [],
+  };
+  const sent: string[] = [];
+  const ws: OpenaiRealtimeWebSocket = {
+    readyState: 1,
+    send(data: string) {
+      sent.push(data);
+    },
+    close() {
+      for (const fn of listeners.close ?? []) fn({ code: 1000, reason: "" });
+    },
+    addEventListener(type: string, fn: Listener) {
+      (listeners[type] ?? []).push(fn);
+    },
+  } as OpenaiRealtimeWebSocket;
+  return Object.assign(ws, {
+    fire(type: "open" | "message" | "close" | "error", ev?: unknown) {
+      for (const fn of listeners[type] ?? []) fn(ev);
+    },
+    sent,
+  });
+}
+
+function startedTransport() {
+  const fake = makeFakeWs();
+  const cbs = noopCallbacks();
+  const transport = createOpenaiRealtimeTransport({
+    apiKey: "sk",
+    options: {},
+    sessionConfig: { systemPrompt: "" },
+    toolSchemas: [],
+    toolChoice: "auto",
+    callbacks: cbs,
+    sid: "s",
+    agent: "a",
+    createWebSocket: () => fake,
+    logger: silentLogger,
+  });
+  const ready = transport.start();
+  fake.fire("open");
+  return { fake, cbs, transport, ready };
+}
+
+describe("openai-realtime-transport: connect and session.update", () => {
+  test("opens WS with auth headers and sends session.update on open", async () => {
+    const fake = makeFakeWs();
+    const createWs = vi.fn(() => fake);
+
+    const transport = createOpenaiRealtimeTransport({
+      apiKey: "sk-test",
+      options: { model: "gpt-realtime", voice: "cedar" },
+      sessionConfig: {
+        systemPrompt: "Be terse.",
+        greeting: "Hi.",
+        tools: [],
+      },
+      toolSchemas: [
+        {
+          type: "function",
+          name: "lookup",
+          description: "look up something",
+          parameters: { type: "object", properties: {} },
+        },
+      ],
+      toolChoice: "auto",
+      callbacks: noopCallbacks(),
+      sid: "sid-1",
+      agent: "test-agent",
+      createWebSocket: createWs,
+      logger: silentLogger,
+    });
+
+    const startP = transport.start();
+    fake.fire("open");
+    await startP;
+
+    expect(createWs).toHaveBeenCalledWith(
+      "wss://api.openai.com/v1/realtime?model=gpt-realtime",
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "Bearer sk-test",
+          "OpenAI-Beta": "realtime=v1",
+        }),
+      }),
+    );
+
+    expect(fake.sent.length).toBe(1);
+    const first = fake.sent[0];
+    if (first === undefined) throw new Error("expected one send");
+    const msg = JSON.parse(first);
+    expect(msg.type).toBe("session.update");
+    expect(msg.session.voice).toBe("cedar");
+    expect(msg.session.instructions).toBe("Be terse.");
+    expect(msg.session.input_audio_format).toBe("pcm16");
+    expect(msg.session.output_audio_format).toBe("pcm16");
+    expect(msg.session.modalities).toEqual(["audio", "text"]);
+    expect(msg.session.input_audio_transcription).toEqual({ model: "whisper-1" });
+    expect(msg.session.turn_detection.type).toBe("server_vad");
+    expect(msg.session.tools).toEqual([
+      expect.objectContaining({ type: "function", name: "lookup" }),
+    ]);
+    expect(msg.session.tool_choice).toBe("auto");
+  });
+});
+
+describe("audio in/out", () => {
+  test("sendUserAudio sends input_audio_buffer.append with base64 payload", async () => {
+    const { fake, transport, ready } = startedTransport();
+    await ready;
+    fake.sent.length = 0;
+    transport.sendUserAudio(new Uint8Array([1, 2, 3, 4]));
+    expect(fake.sent.length).toBe(1);
+    const first = fake.sent[0];
+    if (first === undefined) throw new Error("expected one send");
+    const msg = JSON.parse(first);
+    expect(msg.type).toBe("input_audio_buffer.append");
+    expect(typeof msg.audio).toBe("string");
+    expect(Buffer.from(msg.audio, "base64")).toEqual(Buffer.from([1, 2, 3, 4]));
+  });
+
+  test("response.audio.delta calls onAudioChunk with decoded bytes", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    const audio = Buffer.from([5, 6, 7, 8]).toString("base64");
+    fake.fire("message", {
+      data: JSON.stringify({ type: "response.audio.delta", delta: audio }),
+    });
+    expect(cbs.onAudioChunk).toHaveBeenCalledTimes(1);
+    expect(cbs.onAudioChunk).toHaveBeenCalledWith(new Uint8Array([5, 6, 7, 8]));
+  });
+
+  test("response.audio.done calls onAudioDone", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("message", { data: JSON.stringify({ type: "response.audio.done" }) });
+    expect(cbs.onAudioDone).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("VAD, user transcript, reply lifecycle, agent transcript", () => {
+  test("speech_started/stopped routed to callbacks", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("message", {
+      data: JSON.stringify({ type: "input_audio_buffer.speech_started" }),
+    });
+    fake.fire("message", {
+      data: JSON.stringify({ type: "input_audio_buffer.speech_stopped" }),
+    });
+    expect(cbs.onSpeechStarted).toHaveBeenCalledTimes(1);
+    expect(cbs.onSpeechStopped).toHaveBeenCalledTimes(1);
+  });
+
+  test("user transcription completed routes to onUserTranscript", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "conversation.item.input_audio_transcription.completed",
+        transcript: "hello world",
+      }),
+    });
+    expect(cbs.onUserTranscript).toHaveBeenCalledWith("hello world");
+  });
+
+  test("response.created → onReplyStarted; response.done → onReplyDone", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("message", {
+      data: JSON.stringify({ type: "response.created", response: { id: "resp_1" } }),
+    });
+    expect(cbs.onReplyStarted).toHaveBeenCalledWith("resp_1");
+    fake.fire("message", { data: JSON.stringify({ type: "response.done" }) });
+    expect(cbs.onReplyDone).toHaveBeenCalledTimes(1);
+  });
+
+  test("agent transcript: deltas accumulated, emitted on done", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    const item_id = "item_x";
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.audio_transcript.delta",
+        item_id,
+        delta: "Hi ",
+      }),
+    });
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.audio_transcript.delta",
+        item_id,
+        delta: "there.",
+      }),
+    });
+    expect(cbs.onAgentTranscript).not.toHaveBeenCalled();
+    fake.fire("message", {
+      data: JSON.stringify({ type: "response.audio_transcript.done", item_id }),
+    });
+    expect(cbs.onAgentTranscript).toHaveBeenCalledWith("Hi there.", false);
+  });
+
+  test("agent transcript: done with no buffered deltas does not emit", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.audio_transcript.done",
+        item_id: "empty",
+      }),
+    });
+    expect(cbs.onAgentTranscript).not.toHaveBeenCalled();
+  });
+});
+
+describe("tool calls", () => {
+  test("function_call_arguments deltas accumulate; .done emits onToolCall", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    const item_id = "item_t";
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.output_item.added",
+        item: { id: item_id, type: "function_call", name: "lookup", call_id: "call_1" },
+      }),
+    });
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.function_call_arguments.delta",
+        item_id,
+        delta: '{"q":',
+      }),
+    });
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.function_call_arguments.delta",
+        item_id,
+        delta: '"hi"}',
+      }),
+    });
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.function_call_arguments.done",
+        item_id,
+        call_id: "call_1",
+        name: "lookup",
+        arguments: '{"q":"hi"}',
+      }),
+    });
+    expect(cbs.onToolCall).toHaveBeenCalledWith("call_1", "lookup", { q: "hi" });
+  });
+
+  test("done with empty/invalid args still calls onToolCall with {}", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    const item_id = "item_e";
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.output_item.added",
+        item: { id: item_id, type: "function_call", name: "noop", call_id: "call_e" },
+      }),
+    });
+    fake.fire("message", {
+      data: JSON.stringify({
+        type: "response.function_call_arguments.done",
+        item_id,
+        call_id: "call_e",
+        name: "noop",
+        arguments: "",
+      }),
+    });
+    expect(cbs.onToolCall).toHaveBeenCalledWith("call_e", "noop", {});
+  });
+
+  test("sendToolResult sends conversation.item.create + response.create", async () => {
+    const { fake, transport, ready } = startedTransport();
+    await ready;
+    fake.sent.length = 0; // drop session.update
+    transport.sendToolResult("call_1", '{"ok":true}');
+    expect(fake.sent.length).toBe(2);
+    const m1 = JSON.parse(fake.sent[0] ?? "{}");
+    expect(m1.type).toBe("conversation.item.create");
+    expect(m1.item.type).toBe("function_call_output");
+    expect(m1.item.call_id).toBe("call_1");
+    expect(m1.item.output).toBe('{"ok":true}');
+    const m2 = JSON.parse(fake.sent[1] ?? "{}");
+    expect(m2.type).toBe("response.create");
+  });
+});
+
+describe("cancel, error, close", () => {
+  test("cancelReply sends response.cancel only when a reply is in flight", async () => {
+    const { fake, transport, ready } = startedTransport();
+    await ready;
+    fake.sent.length = 0;
+    // No reply yet — cancel should be a no-op
+    transport.cancelReply();
+    expect(fake.sent.length).toBe(0);
+
+    fake.fire("message", {
+      data: JSON.stringify({ type: "response.created", response: { id: "r1" } }),
+    });
+    transport.cancelReply();
+    expect(fake.sent.length).toBe(1);
+    expect(JSON.parse(fake.sent[0] ?? "{}").type).toBe("response.cancel");
+  });
+
+  test("cancelReply also fires onCancelled", async () => {
+    const { fake, cbs, transport, ready } = startedTransport();
+    await ready;
+    fake.fire("message", {
+      data: JSON.stringify({ type: "response.created", response: { id: "r2" } }),
+    });
+    transport.cancelReply();
+    expect(cbs.onCancelled).toHaveBeenCalledTimes(1);
+  });
+
+  test("error event routes to onError with internal code", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("message", {
+      data: JSON.stringify({ type: "error", error: { message: "boom" } }),
+    });
+    expect(cbs.onError).toHaveBeenCalledWith("internal", "boom");
+  });
+
+  test("error event with missing message uses fallback", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("message", { data: JSON.stringify({ type: "error" }) });
+    expect(cbs.onError).toHaveBeenCalledWith("internal", expect.any(String));
+  });
+
+  test("unexpected close routes to onError with connection code", async () => {
+    const { fake, cbs, ready } = startedTransport();
+    await ready;
+    fake.fire("close", { code: 1006, reason: "" });
+    expect(cbs.onError).toHaveBeenCalledWith("connection", expect.stringMatching(/closed/i));
+  });
+});

package/host/transports/openai-realtime-transport.ts

@@ -0,0 +1,319 @@
+// Copyright 2026 the AAI authors. MIT license.
+// OpenAI Realtime API transport — implements Transport.
+
+import type { JSONSchema7 } from "json-schema";
+import WsWebSocket from "ws";
+import { WS_OPEN } from "../../sdk/constants.ts";
+import type { OpenaiRealtimeOptions } from "../../sdk/providers/s2s/openai-realtime.ts";
+import { base64ToUint8, uint8ToBase64 } from "../_base64.ts";
+import type { Logger } from "../runtime-config.ts";
+import { consoleLogger } from "../runtime-config.ts";
+import type { Transport, TransportCallbacks, TransportSessionConfig } from "./types.ts";
+
+const DEFAULT_MODEL = "gpt-realtime-2";
+const DEFAULT_VOICE = "alloy";
+const DEFAULT_URL = "wss://api.openai.com/v1/realtime";
+
+export type OpenaiRealtimeWebSocket = {
+  readonly readyState: number;
+  send(data: string): void;
+  close(): void;
+  addEventListener(type: "open", fn: () => void): void;
+  addEventListener(type: "message", fn: (ev: { data: unknown }) => void): void;
+  addEventListener(type: "close", fn: (ev: { code?: number; reason?: string }) => void): void;
+  addEventListener(type: "error", fn: (ev: { message?: string }) => void): void;
+};
+
+export type CreateOpenaiRealtimeWebSocket = (
+  url: string,
+  opts: { headers: Record<string, string> },
+) => OpenaiRealtimeWebSocket;
+
+// Node's native WebSocket doesn't support custom headers; the `ws` package does.
+export const defaultCreateOpenaiRealtimeWebSocket: CreateOpenaiRealtimeWebSocket = (url, opts) =>
+  new WsWebSocket(url, { headers: opts.headers }) as unknown as OpenaiRealtimeWebSocket;
+
+export type OpenaiRealtimeToolSchema = {
+  type: "function";
+  name: string;
+  description: string;
+  parameters: JSONSchema7;
+};
+
+export type OpenaiRealtimeTransportOptions = {
+  apiKey: string;
+  options: OpenaiRealtimeOptions;
+  sessionConfig: TransportSessionConfig;
+  toolSchemas: OpenaiRealtimeToolSchema[];
+  toolChoice: "auto" | "required";
+  callbacks: TransportCallbacks;
+  sid: string;
+  agent: string;
+  createWebSocket?: CreateOpenaiRealtimeWebSocket;
+  logger?: Logger;
+};
+
+export function createOpenaiRealtimeTransport(opts: OpenaiRealtimeTransportOptions): Transport {
+  const log = opts.logger ?? consoleLogger;
+  const createWs = opts.createWebSocket ?? defaultCreateOpenaiRealtimeWebSocket;
+  const model = opts.options.model ?? DEFAULT_MODEL;
+  const voice = opts.options.voice ?? DEFAULT_VOICE;
+  const baseUrl = opts.options.url ?? DEFAULT_URL;
+
+  let ws: OpenaiRealtimeWebSocket | null = null;
+  let closing = false;
+  const agentTranscriptBuffers = new Map<string, string>();
+  type ToolBuffer = { callId: string; name: string; argsBuffer: string };
+  const toolBuffers = new Map<string, ToolBuffer>();
+  let currentResponseId: string | null = null;
+
+  function send(payload: Record<string, unknown>): void {
+    if (!ws || ws.readyState !== WS_OPEN) {
+      log.debug("OpenAI Realtime send dropped: socket not open", { type: payload.type });
+      return;
+    }
+    ws.send(JSON.stringify(payload));
+  }
+
+  function sendSessionUpdate(): void {
+    send({
+      type: "session.update",
+      session: {
+        modalities: ["audio", "text"],
+        voice,
+        instructions: opts.sessionConfig.systemPrompt,
+        input_audio_format: "pcm16",
+        output_audio_format: "pcm16",
+        input_audio_transcription: { model: "whisper-1" },
+        turn_detection: { type: "server_vad" },
+        tools: opts.toolSchemas,
+        tool_choice: opts.toolChoice,
+      },
+    });
+  }
+
+  async function start(): Promise<void> {
+    const url = `${baseUrl}?model=${encodeURIComponent(model)}`;
+    log.info("OpenAI Realtime connecting", { url });
+    return new Promise((resolve, reject) => {
+      const sock = createWs(url, {
+        headers: {
+          Authorization: `Bearer ${opts.apiKey}`,
+          "OpenAI-Beta": "realtime=v1",
+        },
+      });
+      ws = sock;
+      let opened = false;
+
+      sock.addEventListener("open", () => {
+        opened = true;
+        sendSessionUpdate();
+        resolve();
+      });
+      sock.addEventListener("message", (ev) => handleMessage(ev.data));
+      sock.addEventListener("close", (ev) => handleClose(ev.code ?? 0, ev.reason ?? ""));
+      sock.addEventListener("error", (ev) => {
+        const msg = typeof ev.message === "string" ? ev.message : "WebSocket error";
+        if (!opened) {
+          reject(new Error(msg));
+          return;
+        }
+        if (closing) {
+          log.info("OpenAI Realtime error during close", { error: msg });
+          return;
+        }
+        opts.callbacks.onError("internal", msg);
+      });
+    });
+  }
+
+  function asString(v: unknown): string {
+    return typeof v === "string" ? v : "";
+  }
+
+  function handleAudioDelta(obj: Record<string, unknown>): void {
+    if (typeof obj.delta === "string") {
+      opts.callbacks.onAudioChunk(base64ToUint8(obj.delta));
+    }
+  }
+
+  function handleUserTranscript(obj: Record<string, unknown>): void {
+    if (typeof obj.transcript === "string") {
+      opts.callbacks.onUserTranscript(obj.transcript);
+    }
+  }
+
+  function handleResponseCreated(obj: Record<string, unknown>): void {
+    const resp = obj.response as { id?: unknown } | undefined;
+    const id = asString(resp?.id);
+    currentResponseId = id;
+    opts.callbacks.onReplyStarted(id);
+  }
+
+  function handleAgentTranscriptDelta(obj: Record<string, unknown>): void {
+    const id = asString(obj.item_id);
+    const delta = asString(obj.delta);
+    agentTranscriptBuffers.set(id, (agentTranscriptBuffers.get(id) ?? "") + delta);
+  }
+
+  function handleAgentTranscriptDone(obj: Record<string, unknown>): void {
+    const id = asString(obj.item_id);
+    const text = agentTranscriptBuffers.get(id) ?? "";
+    agentTranscriptBuffers.delete(id);
+    if (text) opts.callbacks.onAgentTranscript(text, false);
+  }
+
+  function clearTurnBuffers(): void {
+    agentTranscriptBuffers.clear();
+    toolBuffers.clear();
+  }
+
+  function handleResponseDone(): void {
+    currentResponseId = null;
+    clearTurnBuffers();
+    opts.callbacks.onReplyDone();
+  }
+
+  function handleErrorEvent(obj: Record<string, unknown>): void {
+    const err = obj.error as { message?: unknown } | undefined;
+    const message = typeof err?.message === "string" ? err.message : "OpenAI Realtime error";
+    clearTurnBuffers();
+    opts.callbacks.onError("internal", message);
+  }
+
+  function handleOutputItemAdded(obj: Record<string, unknown>): void {
+    const item = obj.item as
+      | { id?: string; type?: string; name?: string; call_id?: string }
+      | undefined;
+    if (item?.type !== "function_call" || !item.id) return;
+    toolBuffers.set(item.id, {
+      callId: item.call_id ?? "",
+      name: item.name ?? "",
+      argsBuffer: "",
+    });
+  }
+
+  function handleFunctionCallArgsDelta(obj: Record<string, unknown>): void {
+    const id = asString(obj.item_id);
+    const delta = asString(obj.delta);
+    const buf = toolBuffers.get(id);
+    if (buf) buf.argsBuffer += delta;
+  }
+
+  function parseToolArgs(argsStr: string, name: string, callId: string): Record<string, unknown> {
+    if (!argsStr) return {};
+    try {
+      const parsed = JSON.parse(argsStr);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch {
+      log.warn("OpenAI Realtime: invalid tool args JSON", { name, callId });
+    }
+    return {};
+  }
+
+  function handleFunctionCallArgsDone(obj: Record<string, unknown>): void {
+    const id = asString(obj.item_id);
+    const buf = toolBuffers.get(id);
+    toolBuffers.delete(id);
+    const callId = asString(obj.call_id) || (buf?.callId ?? "");
+    const name = asString(obj.name) || (buf?.name ?? "");
+    const argsStr = asString(obj.arguments) || (buf?.argsBuffer ?? "");
+    const args = parseToolArgs(argsStr, name, callId);
+    opts.callbacks.onToolCall(callId, name, args);
+  }
+
+  function handleMessage(data: unknown): void {
+    let raw: unknown;
+    try {
+      raw = JSON.parse(String(data));
+    } catch {
+      log.warn("OpenAI Realtime: invalid JSON");
+      return;
+    }
+    if (typeof raw !== "object" || raw === null) return;
+    const obj = raw as Record<string, unknown>;
+    switch (obj.type) {
+      case "response.audio.delta":
+        handleAudioDelta(obj);
+        return;
+      case "response.audio.done":
+        opts.callbacks.onAudioDone();
+        return;
+      case "input_audio_buffer.speech_started":
+        opts.callbacks.onSpeechStarted();
+        return;
+      case "input_audio_buffer.speech_stopped":
+        opts.callbacks.onSpeechStopped();
+        return;
+      case "conversation.item.input_audio_transcription.completed":
+        handleUserTranscript(obj);
+        return;
+      case "response.created":
+        handleResponseCreated(obj);
+        return;
+      case "response.audio_transcript.delta":
+        handleAgentTranscriptDelta(obj);
+        return;
+      case "response.audio_transcript.done":
+        handleAgentTranscriptDone(obj);
+        return;
+      case "response.done":
+        handleResponseDone();
+        return;
+      case "response.output_item.added":
+        handleOutputItemAdded(obj);
+        return;
+      case "response.function_call_arguments.delta":
+        handleFunctionCallArgsDelta(obj);
+        return;
+      case "response.function_call_arguments.done":
+        handleFunctionCallArgsDone(obj);
+        return;
+      case "error":
+        handleErrorEvent(obj);
+        return;
+      default:
+        return;
+    }
+  }
+
+  function handleClose(code: number, reason: string): void {
+    if (closing) {
+      log.info("OpenAI Realtime closed", { code, reason });
+      return;
+    }
+    log.warn("OpenAI Realtime closed unexpectedly", { code, reason });
+    opts.callbacks.onError("connection", `OpenAI Realtime closed (code=${code})`);
+  }
+
+  async function stop(): Promise<void> {
+    closing = true;
+    ws?.close();
+    ws = null;
+  }
+
+  return {
+    start,
+    stop,
+    sendUserAudio(bytes) {
+      if (!ws || ws.readyState !== WS_OPEN) return;
+      ws.send(`{"type":"input_audio_buffer.append","audio":"${uint8ToBase64(bytes)}"}`);
+    },
+    sendToolResult(callId, result) {
+      send({
+        type: "conversation.item.create",
+        item: { type: "function_call_output", call_id: callId, output: result },
+      });
+      send({ type: "response.create" });
+    },
+    cancelReply() {
+      if (currentResponseId === null) return;
+      send({ type: "response.cancel" });
+      currentResponseId = null;
+      clearTurnBuffers();
+      opts.callbacks.onCancelled();
+    },
+  };
+}