@kuralle-syrinx/realtime 2.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Kuralle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,152 @@
+# @kuralle-syrinx/realtime
+
+The **bi-model** front seam for Syrinx (backlog **B-01**): a `RealtimeBridge` `VoicePlugin` that drives a
+full-duplex **s2s "front" model** (OpenAI `gpt-realtime-2`) as the live conversational surface, and
+delegates the "meat" (RAG / reasoning) to **any existing `Reasoner`** (the seam from
+`@kuralle-syrinx/aisdk` / `mastra`) as a tool. The guardian front owns presence + speech understanding +
+turn-taking; the async back owns the facts. See `docs/rfc-realtime-bridge.md` and
+`bi-model-research/` for the design and the prior art (Fin Voice 2 / MoshiRAG / TML interaction models).
+
+## What it is
+
+- **`fromOpenAIRealtime(opts)` → `RealtimeAdapter`** — owns the `gpt-realtime-2` WebSocket (over
+  `@kuralle-syrinx/ws`'s reconnecting `WebSocketConnection`). Normalizes provider events into a small
+  `RealtimeEvent` union (`audio` / `speech_started` / `transcript` / `tool_call` / `response_started` /
+  `response_done` / `error`). Audio is `audio/pcm` @ **24 kHz**.
+- **`RealtimeBridge`** — a `VoicePlugin`. Consumes `user.audio_received` (resampled 16k→24k → provider),
+  emits `tts.audio` (provider 24k→16k, chunked ≤20 ms) + `tts.end`, mints a **fresh `contextId` per turn**
+  (so barge-in never permanently mutes the agent), surfaces `llm.error`, and — when given a `Reasoner` —
+  runs the delegate loop on the front model's `ask_university`-style tool call and feeds the answer back
+  via `function_call_output` for the front model to voice.
+
+## Two modes (and how the back model plugs in)
+
+The `RealtimeBridge` runs in two modes; the back "meat" model plugs in via the **`Reasoner` seam** — the
+*same* framework adapters the cascade `ReasoningBridge` uses (`@kuralle-syrinx/aisdk`'s
+`fromStreamText`/`fromAiSdkAgent`/`fromStreamFactory`, `@kuralle-syrinx/mastra`'s `fromMastraAgent`). You
+pass the **`Reasoner`**, not the `ReasoningBridge` plugin (the bridge runs it as a delegate tool and feeds
+the result back for the front model to voice — using the `ReasoningBridge` plugin here would double-speak).
+
+```ts
+import { RealtimeBridge, fromOpenAIRealtime } from "@kuralle-syrinx/realtime";
+import { createNodeWsSocket } from "@kuralle-syrinx/ws/node";
+
+const adapter = fromOpenAIRealtime({
+  apiKey: process.env.OPENAI_API_KEY!,
+  socketFactory: createNodeWsSocket,
+  // turnDetection defaults to semantic_vad; server_vad is more deterministic for tests/telephony.
+  // tools: [...]  // domain tools the front model may call — supplied by YOU, never hardcoded here.
+});
+
+// (1) STANDALONE — pure s2s, the realtime model answers from its own knowledge:
+session.registerPlugin("realtime", new RealtimeBridge(adapter));
+
+// (2) BI-MODEL with an AI SDK back (the "meat"):
+import { fromStreamText } from "@kuralle-syrinx/aisdk";
+const aiReasoner = fromStreamText({ model, system, tools: { resolveLateAddRequest } });
+const adapterA = fromOpenAIRealtime({ ...opts, tools: [{ name: "ask_kb", description: "...", parameters: {/*JSON Schema*/} }] });
+session.registerPlugin("realtime", new RealtimeBridge(adapterA, aiReasoner, "ask_kb"));
+
+// (3) BI-MODEL with a Mastra back — identical wiring, just a different Reasoner factory:
+import { fromMastraAgent } from "@kuralle-syrinx/mastra";
+const mastraReasoner = fromMastraAgent(myMastraAgent);
+session.registerPlugin("realtime", new RealtimeBridge(adapterA, mastraReasoner, "ask_kb"));
+```
+
+Run the session with `endpointingOwner:"timer"` — the s2s model owns turn detection, so NO STT/VAD/TTS
+plugins are registered on the live path. The **delegate tool is caller-supplied**: pass the tool def to
+the adapter (`tools`) and its name as the bridge's 3rd arg (`delegateToolName`); the adapter is fully
+domain-neutral (it never hardcodes any tool). The same `Reasoner` backends also power the cascade
+`ReasoningBridge` — only the front (s2s vs STT→TTS) differs.
+
+## Deploy on Cloudflare Workers
+
+`@kuralle-syrinx/realtime` is **edge-clean**: no `Buffer`, `process`, or `node:crypto` in `src/`. The
+adapter is **provider-socket-agnostic** — inject whichever `@kuralle-syrinx/ws` factory your runtime needs.
+On Workers, outbound provider WebSockets that require auth headers use the fetch-upgrade path via
+`createWorkersSocket` (not the global `WebSocket` constructor, which cannot set headers).
+
+Wire secrets through the Worker **`env` binding** (Wrangler secrets / vars), not `process.env`. Pass
+`apiKey` and `debug` as constructor options:
+
+```ts
+import { VoiceAgentSession } from "@kuralle-syrinx/core";
+import { RealtimeBridge, fromOpenAIRealtime } from "@kuralle-syrinx/realtime";
+import { createWorkersSocket } from "@kuralle-syrinx/ws/workers";
+
+/** Bound in wrangler.jsonc / dashboard — e.g. OPENAI_API_KEY secret. */
+export interface Env {
+  readonly OPENAI_API_KEY: string;
+}
+
+export function createRealtimeVoiceSession(env: Env): VoiceAgentSession {
+  const adapter = fromOpenAIRealtime({
+    apiKey: env.OPENAI_API_KEY,
+    socketFactory: createWorkersSocket,
+    debug: false,
+    turnDetection: { type: "semantic_vad" },
+  });
+
+  const session = new VoiceAgentSession({
+    endpointingOwner: "timer",
+    plugins: { realtime: {} },
+  });
+  session.registerPlugin("realtime", new RealtimeBridge(adapter));
+  return session;
+}
+```
+
+**Durable Object session shape** (see `packages/server-workers`): the Worker `fetch` handler routes
+`/ws?sessionId=…` to a `VoiceConversation` Durable Object. The DO accepts the client upgrade via
+`WebSocketPair`, constructs the `VoiceAgentSession` (cascade or bi-model realtime — same env-injection
+pattern), and pumps audio over the accepted socket. Provider outbound legs (OpenAI Realtime, Deepgram,
+Cartesia, …) all dial through `createWorkersSocket` so auth headers ride on the fetch upgrade.
+
+Regression lock: `edge-safety.test.ts` runs the adapter + bridge with `Buffer` and `process` removed from
+`globalThis`.
+
+## Capability model
+
+`RealtimeAdapter.caps` lets the bridge adapt per provider:
+
+| cap | gpt-realtime-2 | meaning |
+|---|---|---|
+| `inputSampleRateHz` / `outputSampleRateHz` | 24000 / 24000 | resample boundaries (engine is 16k) |
+| `supportsConcurrentToolAudio` | `true` | native **async function calling** — the model keeps the turn fluid while the delegate runs; no double-audio observed |
+| `supportsTruncate` | `true` | barge-in sends `conversation.item.truncate(audio_end_ms)` (not just `response.cancel`) |
+
+A `fromGeminiLive` / `fromMoshi` adapter can follow with different caps (Gemini Live tool calls are
+blocking → `supportsConcurrentToolAudio:false`; Moshi-class owned models could use embedding-sum injection).
+
+## Latency (measured, honest)
+
+From the live `gpt-realtime-2` smokes on this branch (one turn, university fixture; `server_vad`):
+
+- **Frame round-trip** (`smoke:realtime-frame`): provider audio → resample 24k→16k → Syrinx envelope
+  codec, `ok` — proves the rate-handling path adds no decode break.
+- **One-turn audio** (`smoke:realtime-oneturn`): ~3.6 s assistant audio delivered through the standard
+  paced `tts.audio` path.
+- **Bi-model turn** (`smoke:realtime-university`): front lead-in onset ≈ first audio; `ask_university`
+  tool call at ≈13.9 s into the run; university `Reasoner` answer back ≈4.2 s later; front voiced the
+  grounded body — **the reasoner latency was hidden under the lead-in** (the keyword-delay-gap thesis).
+
+**Honest characterization (not "~0"):** the bridged topology is `client ↔ Syrinx ↔ gpt-realtime-2` — one
+extra WS hop + input/output resampling + per-frame bus dispatch on top of talking to the provider
+directly. **Not yet measured:** a rigorous *first-audio delta* of direct-gpt-realtime-2 vs
+via-`RealtimeBridge` (the WBS-5 comparison harness). Treat the delta as an open measurement; co-locate
+Syrinx with the provider region to minimize the added leg.
+
+## Status (B-01 build)
+
+| Capability | State |
+|---|---|
+| `fromOpenAIRealtime` adapter + ws realtime socket | ✅ live-verified |
+| `RealtimeBridge` live audio loop (fresh contextId/turn) | ✅ live-verified |
+| Delegate → `Reasoner` (bi-model), `function_call_output` injection | ✅ live-verified (university turn) |
+| Barge-in: `speech_started`→interrupt, `cancel`+`truncate`, abort delegate, cancel-when-idle guard | ✅ logic unit-verified + detection live-confirmed; live "resume-after-barge" smoke is flaky (orchestration) |
+| First-audio direct-vs-bridged latency delta harness | ⏳ open (WBS-5) |
+| `fromGeminiLive` / `fromMoshi` adapters | ⏳ future |
+
+Tests: `pnpm --filter @kuralle-syrinx/realtime test`. Live gates (need `OPENAI_API_KEY`):
+`smoke:realtime-frame` / `:realtime-oneturn` / `:realtime-university` / `:realtime-bargein` in
+`examples/02-hello-voice-headless`.

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@kuralle-syrinx/realtime",
+  "version": "2.1.0",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "dependencies": {
+    "@google/genai": "^2.8.0",
+    "@kuralle-syrinx/core": "2.1.0",
+    "@kuralle-syrinx/ws": "2.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/base64.ts

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+export function bytesToBase64(bytes: Uint8Array): string {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 0x8000) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+  }
+  return globalThis.btoa(binary);
+}
+
+export function base64ToBytes(base64: string): Uint8Array {
+  const raw = globalThis.atob(base64);
+  const bytes = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i += 1) bytes[i] = raw.charCodeAt(i);
+  return bytes;
+}

package/src/edge-safety.test.ts

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: MIT
+//
+// R-14: regression gate — the realtime package must run on workerd without
+// Buffer, process, or node:crypto. Reintroducing any Node-only primitive in
+// src/ should fail this test.
+
+import { readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  PipelineBusImpl,
+  Route,
+  type TextToSpeechAudioPacket,
+  type TurnChangePacket,
+} from "@kuralle-syrinx/core";
+import type { ManagedSocket, SocketData, SocketFactory } from "@kuralle-syrinx/ws";
+
+import { bytesToBase64, fromOpenAIRealtime } from "./from-openai-realtime.js";
+import { RealtimeBridge } from "./realtime-bridge.js";
+
+const srcDir = path.dirname(fileURLToPath(import.meta.url));
+
+interface EdgeMockHarness {
+  readonly factory: SocketFactory;
+  readonly sent: string[];
+  inject(msg: Record<string, unknown>): void;
+}
+
+function createEdgeMockHarness(): EdgeMockHarness {
+  const sent: string[] = [];
+  let messageHandler: ((data: SocketData, isBinary: boolean) => void) | null = null;
+
+  const socket: ManagedSocket = {
+    get isOpen() {
+      return true;
+    },
+    send: (data: SocketData) => {
+      sent.push(typeof data === "string" ? data : "");
+    },
+    keepAlivePing: () => {},
+    verify: async () => true,
+    dispose: () => {},
+    onOpen: (handler) => {
+      queueMicrotask(() => handler());
+    },
+    onMessage: (handler) => {
+      messageHandler = handler;
+    },
+    onClose: () => {},
+    onError: () => {},
+  };
+
+  return {
+    factory: () => socket,
+    sent,
+    inject: (msg) => messageHandler?.(JSON.stringify(msg), false),
+  };
+}
+
+function pcmFromSamples(samples: readonly number[]): Uint8Array {
+  const pcm = Int16Array.from(samples);
+  return new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 2000): Promise<void> {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for condition");
+}
+
+function collectSourceFiles(dir: string): string[] {
+  const out: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...collectSourceFiles(full));
+      continue;
+    }
+    if (entry.name.endsWith(".ts") && !entry.name.endsWith(".test.ts")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+describe("edge safety (R-14)", () => {
+  it("src/ contains no Buffer, process, or node:crypto imports", () => {
+    const forbidden = [
+      /\bfrom\s+["']node:crypto["']/,
+      /\brequire\s*\(\s*["']node:crypto["']\s*\)/,
+      /\bglobalThis\.Buffer\b/,
+      /\bglobalThis\.process\b/,
+      /\bprocess\.env\b/,
+      /\bBuffer\.from\b/,
+      /\bBuffer\.alloc\b/,
+    ];
+    const hits: string[] = [];
+    for (const file of collectSourceFiles(srcDir)) {
+      const text = readFileSync(file, "utf8");
+      for (const pattern of forbidden) {
+        if (pattern.test(text)) {
+          hits.push(`${path.relative(srcDir, file)}: ${pattern.source}`);
+        }
+      }
+    }
+    expect(hits).toEqual([]);
+  });
+
+  // NOTE: we do NOT delete globalThis.Buffer/process here — vitest's own worker needs `process`
+  // (its uncaughtException handler calls process.listeners), so deleting it crashes the runner.
+  // Edge-safety is enforced statically by the source-scan above; this test proves the audio path
+  // actually runs end-to-end using only the runtime-agnostic helpers.
+  it("fromOpenAIRealtime + RealtimeBridge round-trip audio via runtime-agnostic helpers", async () => {
+    const mock = createEdgeMockHarness();
+    const adapter = fromOpenAIRealtime({
+      apiKey: "edge-test-key",
+      socketFactory: mock.factory,
+      url: () => "wss://example.test/realtime?model=gpt-realtime-2",
+    });
+    const bridge = new RealtimeBridge(adapter);
+    const bus = new PipelineBusImpl();
+    const turnChanges: TurnChangePacket[] = [];
+    const ttsAudio: TextToSpeechAudioPacket[] = [];
+    bus.on("turn.change", (pkt) => { turnChanges.push(pkt as TurnChangePacket); });
+    bus.on("tts.audio", (pkt) => { ttsAudio.push(pkt as TextToSpeechAudioPacket); });
+
+    const started = bus.start();
+
+    const initTask = bridge.initialize(bus, {});
+    await waitFor(() => mock.sent.length > 0);
+    mock.inject({ type: "session.updated" });
+    await initTask;
+
+    bus.push(Route.Main, {
+      kind: "user.audio_received",
+      contextId: "transport-turn",
+      timestampMs: Date.now(),
+      audio: pcmFromSamples([100, 200, 300, 400]),
+    });
+
+    await waitFor(() =>
+      mock.sent.some((raw) => (JSON.parse(raw) as { type: string }).type === "input_audio_buffer.append"),
+    );
+
+    const providerPcm = pcmFromSamples(Array.from({ length: 960 }, (_, i) => i));
+    mock.inject({ type: "response.created" });
+    mock.inject({
+      type: "response.output_audio.delta",
+      delta: bytesToBase64(providerPcm),
+    });
+    mock.inject({ type: "response.done" });
+
+    await waitFor(() => ttsAudio.length > 0 && turnChanges.length > 0);
+
+    const contextId = turnChanges[0]!.contextId;
+    expect(contextId).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
+    );
+    expect(ttsAudio[0]!.contextId).toBe(contextId);
+    expect(ttsAudio[0]!.sampleRateHz).toBe(16_000);
+    expect(ttsAudio[0]!.audio.byteLength).toBeGreaterThan(0);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
+});

package/src/from-gemini-live.test.ts

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: MIT
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import type { LiveServerMessage } from "@google/genai";
+
+import type { RealtimeEvent } from "./realtime-adapter.js";
+import { bytesToBase64 } from "./base64.js";
+import { fromGeminiLive } from "./from-gemini-live.js";
+
+const sendRealtimeInput = vi.fn();
+const sendToolResponse = vi.fn();
+const closeSession = vi.fn();
+
+let onopen: (() => void) | null = null;
+let onmessage: ((msg: LiveServerMessage) => void) | null = null;
+
+const liveConnect = vi.fn().mockImplementation(async ({ callbacks }: {
+  callbacks: {
+    onopen?: () => void;
+    onmessage?: (msg: LiveServerMessage) => void;
+  };
+}) => {
+  onopen = callbacks.onopen ?? null;
+  onmessage = callbacks.onmessage ?? null;
+  queueMicrotask(() => callbacks.onopen?.());
+  return {
+    sendRealtimeInput,
+    sendToolResponse,
+    close: closeSession,
+  };
+});
+
+vi.mock("@google/genai", () => ({
+  GoogleGenAI: vi.fn().mockImplementation(() => ({
+    live: { connect: liveConnect },
+  })),
+  Modality: { AUDIO: "AUDIO" },
+}));
+
+afterEach(() => {
+  sendRealtimeInput.mockClear();
+  sendToolResponse.mockClear();
+  closeSession.mockClear();
+  liveConnect.mockClear();
+  onopen = null;
+  onmessage = null;
+});
+
+async function collectEvents(
+  events: AsyncIterable<RealtimeEvent>,
+  max = 12,
+): Promise<RealtimeEvent[]> {
+  const out: RealtimeEvent[] = [];
+  for await (const event of events) {
+    out.push(event);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+
+function inject(msg: Partial<LiveServerMessage> & Record<string, unknown>): void {
+  if (!onmessage) throw new Error("mock session onmessage not wired");
+  onmessage(msg as LiveServerMessage);
+}
+
+describe("fromGeminiLive", () => {
+  it("emits client calls for open, audio, and tool result", async () => {
+    const adapter = fromGeminiLive({
+      apiKey: "test-key",
+      tools: [{
+        name: "consult_knowledge",
+        description: "Answer knowledge questions.",
+        parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+      }],
+    });
+
+    await adapter.open(new AbortController().signal);
+
+    expect(liveConnect).toHaveBeenCalledTimes(1);
+    const connectArg = liveConnect.mock.calls[0]![0] as {
+      model: string;
+      config: Record<string, unknown>;
+    };
+    expect(connectArg.model).toBe("gemini-3.1-flash-live-preview");
+    expect(connectArg.config["tools"]).toEqual([{
+      functionDeclarations: [{
+        name: "consult_knowledge",
+        description: "Answer knowledge questions.",
+        parametersJsonSchema: {
+          type: "object",
+          properties: { query: { type: "string" } },
+          required: ["query"],
+        },
+      }],
+    }]);
+
+    const pcm = new Uint8Array([0, 1, 2, 3]);
+    adapter.sendAudio(pcm);
+    expect(sendRealtimeInput).toHaveBeenCalledWith({
+      audio: {
+        data: bytesToBase64(pcm),
+        mimeType: "audio/pcm;rate=16000",
+      },
+    });
+
+    inject({
+      toolCall: {
+        functionCalls: [{
+          id: "call_abc",
+          name: "consult_knowledge",
+          args: { query: "late add" },
+        }],
+      },
+    });
+    adapter.injectToolResult("call_abc", "Late Add Petition required.");
+    expect(sendToolResponse).toHaveBeenCalledWith({
+      functionResponses: [{
+        id: "call_abc",
+        name: "consult_knowledge",
+        response: { result: "Late Add Petition required." },
+      }],
+    });
+
+    adapter.cancelResponse(420);
+    expect(sendRealtimeInput).toHaveBeenCalledTimes(1);
+  });
+
+  it("normalizes provider server messages into RealtimeEvent", async () => {
+    const adapter = fromGeminiLive({ apiKey: "test-key" });
+    const eventsTask = collectEvents(adapter.events, 7);
+    await adapter.open(new AbortController().signal);
+
+    const audioBytes = new Uint8Array([9, 10, 11, 12]);
+    inject({ setupComplete: {} });
+    inject({
+      serverContent: {
+        modelTurn: {
+          parts: [{
+            inlineData: {
+              data: bytesToBase64(audioBytes),
+              mimeType: "audio/pcm;rate=24000",
+            },
+          }],
+        },
+      },
+    });
+    inject({ serverContent: { interrupted: true } });
+    inject({
+      serverContent: {
+        inputTranscription: { text: "Can I add Biology?", finished: true },
+      },
+    });
+    inject({
+      serverContent: {
+        outputTranscription: { text: "Let me check that.", finished: true },
+      },
+    });
+    inject({
+      toolCall: {
+        functionCalls: [{
+          id: "call_123",
+          name: "consult_knowledge",
+          args: { query: "late add biology" },
+        }],
+      },
+    });
+    inject({ serverContent: { turnComplete: true } });
+
+    const events = await eventsTask;
+    expect(events.slice(0, 7)).toEqual([
+      { type: "response_started" },
+      { type: "audio", pcm16: audioBytes, sampleRateHz: 24000 },
+      { type: "speech_started" },
+      { type: "transcript", role: "user", text: "Can I add Biology?", final: true },
+      { type: "transcript", role: "assistant", text: "Let me check that.", final: true },
+      {
+        type: "tool_call",
+        toolId: "call_123",
+        toolName: "consult_knowledge",
+        args: { query: "late add biology" },
+      },
+      { type: "response_done" },
+    ]);
+  });
+
+  it("exposes Gemini Live capability flags", () => {
+    const adapter = fromGeminiLive({ apiKey: "test-key" });
+    expect(adapter.caps).toEqual({
+      inputSampleRateHz: 16_000,
+      outputSampleRateHz: 24_000,
+      supportsConcurrentToolAudio: false,
+      supportsTruncate: false,
+      emitsServerSpeechStarted: true,
+    });
+  });
+});