@kuralle-syrinx/realtime 4.0.0 → 4.2.0

package/package.json

@@ -1,15 +1,35 @@
 {
   "name": "@kuralle-syrinx/realtime",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "private": false,
-  "type": "module",
+  "description": "Realtime speech-to-speech bridge for Syrinx — OpenAI Realtime, Gemini Live, and openai-compatible adapters; the Responder-Thinker delegate seam",
+  "keywords": [
+    "voice",
+    "voice-agent",
+    "speech",
+    "syrinx",
+    "realtime",
+    "speech-to-speech",
+    "openai-realtime",
+    "gemini-live"
+  ],
   "license": "MIT",
+  "homepage": "https://github.com/kuralle/syrinx#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kuralle/syrinx.git",
+    "directory": "packages/realtime"
+  },
+  "bugs": {
+    "url": "https://github.com/kuralle/syrinx/issues"
+  },
+  "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "dependencies": {
     "@google/genai": "^2.8.0",
-    "@kuralle-syrinx/core": "4.0.0",
-    "@kuralle-syrinx/ws": "4.0.0"
+    "@kuralle-syrinx/core": "4.2.0",
+    "@kuralle-syrinx/ws": "4.2.0"
   },
   "devDependencies": {
     "typescript": "^5.7.0",

package/src/from-openai-realtime.test.ts

@@ -412,6 +412,7 @@ describe("fromOpenAIRealtime", () => {
       supportsConcurrentToolAudio: true,
       supportsTruncate: true,
       emitsServerSpeechStarted: true,
+      supportsTextOnlyModality: false,
     });
   });
 

package/src/from-openai-realtime.ts

@@ -60,6 +60,7 @@ export function fromOpenAIRealtime(opts: OpenAIRealtimeOptions): RealtimeAdapter
       supportsConcurrentToolAudio: true,
       supportsTruncate: true,
       emitsServerSpeechStarted: true,
+      supportsTextOnlyModality: opts.modalities?.length === 1 && opts.modalities[0] === "text",
     },
     buildSessionUpdate: () => {
       const inputAudio: Record<string, unknown> = {

package/src/openai-compatible-realtime.test.ts

@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, it } from "vitest";
+
+import type { ManagedSocket, SocketData, SocketFactory } from "@kuralle-syrinx/ws";
+
+import { createOpenAiCompatibleRealtimeAdapter } from "./openai-compatible-realtime.js";
+import type { RealtimeEvent } from "./realtime-adapter.js";
+
+interface MockSocketHarness {
+  readonly factory: SocketFactory;
+  readonly sent: string[];
+  inject(msg: Record<string, unknown>): void;
+}
+
+function createMockSocketHarness(): MockSocketHarness {
+  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),
+  };
+}
+
+async function collectEvents(
+  events: AsyncIterable<RealtimeEvent>,
+  max = 8,
+): Promise<RealtimeEvent[]> {
+  const out: RealtimeEvent[] = [];
+  for await (const event of events) {
+    out.push(event);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+
+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 createAdapter(mock: MockSocketHarness) {
+  return createOpenAiCompatibleRealtimeAdapter({
+    apiKey: "test-key",
+    socketFactory: mock.factory,
+    defaultModel: "gpt-realtime-2",
+    url: () => "wss://example.test/realtime?model=gpt-realtime-2",
+    caps: {
+      inputSampleRateHz: 24_000,
+      outputSampleRateHz: 24_000,
+      supportsConcurrentToolAudio: true,
+      supportsTruncate: true,
+      emitsServerSpeechStarted: true,
+      supportsTextOnlyModality: true,
+    },
+    buildSessionUpdate: () => ({
+      type: "realtime",
+      model: "gpt-realtime-2",
+      output_modalities: ["text"],
+    }),
+    supportsTruncate: true,
+    defaultErrorMessage: "OpenAI Realtime error",
+  });
+}
+
+describe("createOpenAiCompatibleRealtimeAdapter text-only output", () => {
+  it("surfaces response.output_text.delta as assistant transcript (final=false)", async () => {
+    const mock = createMockSocketHarness();
+    const adapter = createAdapter(mock);
+
+    const eventsTask = collectEvents(adapter.events, 2);
+    const openTask = adapter.open(new AbortController().signal);
+    await waitFor(() => mock.sent.length > 0);
+    mock.inject({ type: "session.updated" });
+    await openTask;
+
+    mock.inject({ type: "response.created" });
+    mock.inject({
+      type: "response.output_text.delta",
+      delta: "Let me ",
+    });
+
+    const events = await eventsTask;
+    expect(events).toEqual([
+      { type: "response_started" },
+      { type: "transcript", role: "assistant", text: "Let me ", final: false },
+    ]);
+  });
+
+  it("surfaces response.output_text.done as final assistant transcript with accumulated text", async () => {
+    const mock = createMockSocketHarness();
+    const adapter = createAdapter(mock);
+
+    const eventsTask = collectEvents(adapter.events, 3);
+    const openTask = adapter.open(new AbortController().signal);
+    await waitFor(() => mock.sent.length > 0);
+    mock.inject({ type: "session.updated" });
+    await openTask;
+
+    mock.inject({ type: "response.created" });
+    mock.inject({
+      type: "response.output_text.delta",
+      delta: "Let me ",
+    });
+    mock.inject({
+      type: "response.output_text.done",
+      text: "Let me check that.",
+    });
+
+    const events = await eventsTask;
+    expect(events).toEqual([
+      { type: "response_started" },
+      { type: "transcript", role: "assistant", text: "Let me ", final: false },
+      { type: "transcript", role: "assistant", text: "Let me check that.", final: true },
+    ]);
+  });
+
+  it("uses assistantTranscript when response.output_text.done omits text", async () => {
+    const mock = createMockSocketHarness();
+    const adapter = createAdapter(mock);
+
+    const eventsTask = collectEvents(adapter.events, 3);
+    const openTask = adapter.open(new AbortController().signal);
+    await waitFor(() => mock.sent.length > 0);
+    mock.inject({ type: "session.updated" });
+    await openTask;
+
+    mock.inject({ type: "response.created" });
+    mock.inject({
+      type: "response.output_text.delta",
+      delta: "Hello",
+    });
+    mock.inject({
+      type: "response.output_text.done",
+    });
+
+    const events = await eventsTask;
+    expect(events).toEqual([
+      { type: "response_started" },
+      { type: "transcript", role: "assistant", text: "Hello", final: false },
+      { type: "transcript", role: "assistant", text: "Hello", final: true },
+    ]);
+  });
+});
+
+describe("createOpenAiCompatibleRealtimeAdapter requestResponse (Syrinx-owned turns)", () => {
+  it("sends input_audio_buffer.commit then response.create", async () => {
+    const mock = createMockSocketHarness();
+    const adapter = createAdapter(mock);
+
+    const openTask = adapter.open(new AbortController().signal);
+    await waitFor(() => mock.sent.length > 0);
+    mock.inject({ type: "session.updated" });
+    await openTask;
+
+    const baseline = mock.sent.length;
+    adapter.requestResponse!();
+
+    expect(JSON.parse(mock.sent[baseline]!)).toEqual({ type: "input_audio_buffer.commit" });
+    expect(JSON.parse(mock.sent[baseline + 1]!)).toEqual({ type: "response.create" });
+  });
+});

package/src/openai-compatible-realtime.ts

@@ -171,6 +171,11 @@ class OpenAiCompatibleRealtimeAdapter implements RealtimeAdapter {
     this.requestResponseCreate();
   }
 
+  requestResponse(): void {
+    this.requireSocket().send({ type: "input_audio_buffer.commit" });
+    this.requestResponseCreate();
+  }
+
   cancelResponse(audioEndMs: number): void {
     if (!this.activeResponse) return;
     const socket = this.requireSocket();
@@ -331,6 +336,30 @@ class OpenAiCompatibleRealtimeAdapter implements RealtimeAdapter {
         this.assistantTranscript = "";
         break;
       }
+      case "response.output_text.delta": {
+        const delta = msg["delta"];
+        if (typeof delta === "string" && delta.length > 0) {
+          this.assistantTranscript += delta;
+          this.stream.push({
+            type: "transcript",
+            role: "assistant",
+            text: delta,
+            final: false,
+          });
+        }
+        break;
+      }
+      case "response.output_text.done": {
+        const t = typeof msg["text"] === "string" ? msg["text"] : this.assistantTranscript;
+        this.stream.push({
+          type: "transcript",
+          role: "assistant",
+          text: t,
+          final: true,
+        });
+        this.assistantTranscript = "";
+        break;
+      }
       case "conversation.item.input_audio_transcription.completed": {
         // User-side transcript (requires input transcription enabled in session config).
         const transcript = typeof msg["transcript"] === "string" ? msg["transcript"] : "";

package/src/realtime-adapter.ts

@@ -14,6 +14,16 @@ export interface RealtimeAdapter {
      * be replayed — that would double-apply history (RFC bimodel-delegate-seam R6).
      */
     readonly supportsNativeResume?: boolean;
+    /** The front model owns full-duplex interaction decisions (turn-taking, barge-in). When true,
+     *  Syrinx's InteractionPolicy runs observe-only and does not drive its own turn/interrupt decisions
+     *  (RFC InteractionPolicy REQ-4). Absent/false → Syrinx drives. No current adapter sets this. */
+    readonly supportsFullDuplex?: boolean;
+    /** The front emits its own backchannels ("mhmm"). When true, Syrinx suppresses its own backchannel
+     *  cues (RFC InteractionPolicy REQ-4). Absent/false → Syrinx may emit. */
+    readonly emitsBackchannel?: boolean;
+    /** Half-cascade: provider can run text-only modality (`modalities:["text"]`) so Syrinx TTS
+     *  drives speech from assistant transcript events. Absent/false → no text-only half-cascade. */
+    readonly supportsTextOnlyModality?: boolean;
   };
 
   open(signal: AbortSignal): Promise<void>;
@@ -23,6 +33,13 @@ export interface RealtimeAdapter {
    * provider cannot accept text input omit it, and the bridge silently ignores typed turns for them.
    */
   sendText?(text: string): void;
+  /**
+   * Commit any buffered user input and request a response. For Syrinx-OWNED turn detection
+   * (provider server VAD disabled via turnDetection:null): the host calls this when its own
+   * endpointing (InteractionPolicy / VAD) signals end-of-turn. Optional — adapters without
+   * manual turn control omit it.
+   */
+  requestResponse?(): void;
   cancelResponse(audioEndMs: number): void;
   injectToolResult(toolId: string, text: string): void;
   /** Close the provider socket and end the event stream. */

package/src/realtime-bridge.test.ts

@@ -75,6 +75,12 @@ class FakeRealtimeAdapter implements RealtimeAdapter {
     this.sentText.push(text);
   }
 
+  requestResponseCalls = 0;
+
+  requestResponse(): void {
+    this.requestResponseCalls += 1;
+  }
+
   readonly cancelCalls: number[] = [];
 
   cancelResponse(audioEndMs: number): void {
@@ -216,6 +222,86 @@ describe("RealtimeBridge", () => {
     await started;
   });
 
+  it("with syrinxTurns, eos.turn_complete calls adapter.requestResponse exactly once", async () => {
+    const adapter = new FakeRealtimeAdapter();
+    const bridge = new RealtimeBridge(adapter, undefined, undefined, { syrinxTurns: true });
+    const bus = new PipelineBusImpl();
+    buses.push(bus);
+
+    const started = bus.start();
+    await bridge.initialize(bus, {});
+
+    bus.push(Route.Main, {
+      kind: "eos.turn_complete",
+      contextId: "user-turn",
+      timestampMs: Date.now(),
+    });
+
+    await waitForCondition(() => adapter.requestResponseCalls >= 1);
+    expect(adapter.requestResponseCalls).toBe(1);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
+
+  it("without syrinxTurns, eos.turn_complete does not call adapter.requestResponse", async () => {
+    const adapter = new FakeRealtimeAdapter();
+    const bridge = new RealtimeBridge(adapter);
+    const bus = new PipelineBusImpl();
+    buses.push(bus);
+
+    const started = bus.start();
+    await bridge.initialize(bus, {});
+
+    bus.push(Route.Main, {
+      kind: "eos.turn_complete",
+      contextId: "user-turn",
+      timestampMs: Date.now(),
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 30));
+    expect(adapter.requestResponseCalls).toBe(0);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
+
+  it("syrinxTurns+textOnly: response_done does not re-trigger requestResponse via eos.turn_complete", async () => {
+    const adapter = new FakeRealtimeAdapter();
+    const bridge = new RealtimeBridge(adapter, undefined, undefined, {
+      textOnly: true,
+      syrinxTurns: true,
+    });
+    const bus = new PipelineBusImpl();
+    buses.push(bus);
+
+    const started = bus.start();
+    await bridge.initialize(bus, {});
+
+    // Endpointing owns the user-turn signal → one requestResponse.
+    bus.push(Route.Main, {
+      kind: "eos.turn_complete",
+      contextId: "user-turn",
+      timestampMs: Date.now(),
+    });
+    await waitForCondition(() => adapter.requestResponseCalls >= 1);
+    expect(adapter.requestResponseCalls).toBe(1);
+
+    // Full provider response cycle must not re-emit eos.turn_complete → requestResponse.
+    adapter.emit({ type: "response_started" });
+    adapter.emit({ type: "transcript", role: "assistant", text: "hi", final: true });
+    adapter.emit({ type: "response_done" });
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(adapter.requestResponseCalls).toBe(1);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
+
   it("mints a fresh contextId for each response_started (R1)", async () => {
     const adapter = new FakeRealtimeAdapter();
     const bridge = new RealtimeBridge(adapter);
@@ -1144,4 +1230,129 @@ describe("RealtimeBridge", () => {
 
     await session.close();
   });
+
+  // ── Half-cascade C1: textOnly routing ────────────────────────────────────
+  // In text-only mode the bridge streams assistant transcript into the cascade
+  // llm.delta → segmenter → tts.text path. The TTS plugin owns tts.end.
+
+  it("textOnly: streams assistant transcript deltas as llm.delta in order as they arrive", async () => {
+    const adapter = new FakeRealtimeAdapter();
+    const bridge = new RealtimeBridge(adapter, undefined, "consult_knowledge", { textOnly: true });
+    const bus = new PipelineBusImpl();
+    buses.push(bus);
+    const deltas: LlmDeltaPacket[] = [];
+    bus.on("llm.delta", (pkt) => { deltas.push(pkt as LlmDeltaPacket); });
+
+    const started = bus.start();
+    await bridge.initialize(bus, {});
+
+    adapter.emit({ type: "response_started" });
+    adapter.emit({ type: "transcript", role: "assistant", text: "The capital", final: false });
+    adapter.emit({ type: "transcript", role: "assistant", text: " of France", final: false });
+    adapter.emit({ type: "transcript", role: "assistant", text: " is Paris.", final: false });
+
+    await waitForCondition(() => deltas.length === 3);
+    expect(deltas.map((d) => d.text)).toEqual(["The capital", " of France", " is Paris."]);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
+
+  it("textOnly: final assistant transcript pushes llm.done and no full-text llm.delta", async () => {
+    const adapter = new FakeRealtimeAdapter();
+    const bridge = new RealtimeBridge(adapter, undefined, "consult_knowledge", { textOnly: true });
+    const bus = new PipelineBusImpl();
+    buses.push(bus);
+    const deltas: LlmDeltaPacket[] = [];
+    const dones: LlmResponseDonePacket[] = [];
+    bus.on("llm.delta", (pkt) => { deltas.push(pkt as LlmDeltaPacket); });
+    bus.on("llm.done", (pkt) => { dones.push(pkt as LlmResponseDonePacket); });
+
+    const started = bus.start();
+    await bridge.initialize(bus, {});
+
+    adapter.emit({ type: "response_started" });
+    adapter.emit({ type: "transcript", role: "assistant", text: "Hello ", final: false });
+    adapter.emit({ type: "transcript", role: "assistant", text: "world.", final: false });
+    // C0 adapter output_text.done carries the FULL accumulated text — must not re-emit as delta.
+    adapter.emit({ type: "transcript", role: "assistant", text: "Hello world.", final: true });
+
+    await waitForCondition(() => dones.length === 1);
+    expect(deltas.map((d) => d.text)).toEqual(["Hello ", "world."]);
+    expect(dones).toHaveLength(1);
+    expect(dones[0]!.text).toBe("Hello world.");
+    // No extra full-text llm.delta for the final event.
+    expect(deltas.some((d) => d.text === "Hello world.")).toBe(false);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
+
+  it("textOnly: provider audio events push no tts.audio", async () => {
+    const adapter = new FakeRealtimeAdapter();
+    const bridge = new RealtimeBridge(adapter, undefined, "consult_knowledge", { textOnly: true });
+    const bus = new PipelineBusImpl();
+    buses.push(bus);
+    const audio: TextToSpeechAudioPacket[] = [];
+    bus.on("tts.audio", (pkt) => { audio.push(pkt as TextToSpeechAudioPacket); });
+
+    const started = bus.start();
+    await bridge.initialize(bus, {});
+
+    adapter.emit({ type: "response_started" });
+    adapter.emit({
+      type: "audio",
+      pcm16: frameSizedPcm24k(),
+      sampleRateHz: 24_000,
+    });
+    adapter.emit({ type: "response_done" });
+
+    await waitForCondition(() => true); // allow pump to drain
+    await new Promise((resolve) => setTimeout(resolve, 30));
+    expect(audio).toHaveLength(0);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
+
+  it("textOnly: onResponseDone does not re-emit assistant llm.delta and does not emit tts.end", async () => {
+    const adapter = new FakeRealtimeAdapter();
+    const bridge = new RealtimeBridge(adapter, undefined, "consult_knowledge", { textOnly: true });
+    const bus = new PipelineBusImpl();
+    buses.push(bus);
+    const deltas: LlmDeltaPacket[] = [];
+    const dones: LlmResponseDonePacket[] = [];
+    const ends: TextToSpeechEndPacket[] = [];
+    const turnCompletes: EndOfSpeechPacket[] = [];
+    bus.on("llm.delta", (pkt) => { deltas.push(pkt as LlmDeltaPacket); });
+    bus.on("llm.done", (pkt) => { dones.push(pkt as LlmResponseDonePacket); });
+    bus.on("tts.end", (pkt) => { ends.push(pkt as TextToSpeechEndPacket); });
+    bus.on("eos.turn_complete", (pkt) => { turnCompletes.push(pkt as EndOfSpeechPacket); });
+
+    const started = bus.start();
+    await bridge.initialize(bus, {});
+
+    adapter.emit({ type: "response_started" });
+    adapter.emit({ type: "transcript", role: "assistant", text: "Streamed.", final: false });
+    adapter.emit({ type: "transcript", role: "assistant", text: "Streamed.", final: true });
+    await waitForCondition(() => dones.length === 1);
+    const deltasBeforeDone = deltas.length;
+
+    adapter.emit({ type: "response_done" });
+    await waitForCondition(() => turnCompletes.length === 1);
+
+    // No duplicate display-only llm.delta/llm.done from onResponseDone.
+    expect(deltas).toHaveLength(deltasBeforeDone);
+    expect(dones).toHaveLength(1);
+    // TTS plugin owns tts.end in text-only mode — bridge must not force it.
+    expect(ends).toHaveLength(0);
+    expect(turnCompletes).toHaveLength(1);
+
+    await bridge.close();
+    bus.stop();
+    await started;
+  });
 });

package/src/realtime-bridge.ts

@@ -89,6 +89,22 @@ export interface RealtimeBridgeOptions {
     readonly toolName: string;
     readonly args: Record<string, unknown>;
   }) => string | undefined | Promise<string | undefined>;
+  /**
+   * Half-cascade text-only mode: stream assistant transcript into the cascade
+   * `llm.delta → segmenter → tts.text` path and ignore provider audio.
+   * REQUIRES a TTS plugin registered on the session bus (the bridge does not own the registry).
+   */
+  readonly textOnly?: boolean;
+  /**
+   * Syrinx-owned turn detection (REQ-6): on `eos.turn_complete`, call
+   * `adapter.requestResponse` so Syrinx endpointing/VAD/InteractionPolicy drives
+   * the provider response instead of server VAD.
+   *
+   * MUST be paired with `turnDetection: null` on the adapter — otherwise the
+   * provider's server VAD and Syrinx would BOTH trigger responses (double-turn).
+   * Native mode (`syrinxTurns` absent/false) is unchanged.
+   */
+  readonly syrinxTurns?: boolean;
 }
 
 export class RealtimeBridge implements VoicePlugin {
@@ -138,6 +154,14 @@ export class RealtimeBridge implements VoicePlugin {
       }),
     );
 
+    if (this.opts.syrinxTurns) {
+      this.disposers.push(
+        bus.on("eos.turn_complete", () => {
+          this.adapter.requestResponse?.();
+        }),
+      );
+    }
+
     await this.adapter.open(this.sessionAbort.signal);
     void this.pump();
   }
@@ -176,11 +200,15 @@ export class RealtimeBridge implements VoicePlugin {
         this.onResponseStarted(bus);
         break;
       case "audio":
-        this.onAudio(bus, ev.pcm16, ev.sampleRateHz);
+        // textOnly: provider audio must not be used (REQ-4) — TTS plugin owns playout.
+        if (!this.opts.textOnly) this.onAudio(bus, ev.pcm16, ev.sampleRateHz);
         break;
       case "transcript":
         if (ev.role === "user") {
           if (ev.final) this.onFinalTranscript(bus, ev.text);
+        } else if (this.opts.textOnly) {
+          // Drive cascade TTS path as text arrives; do not buffer for display-only re-emit.
+          this.onTextOnlyAssistantTranscript(bus, ev.text, ev.final);
         } else if (ev.final && ev.text.trim()) {
           this.turnAssistantText = this.turnAssistantText
             ? `${this.turnAssistantText} ${ev.text.trim()}`
@@ -455,10 +483,42 @@ export class RealtimeBridge implements VoicePlugin {
     bus.push(Route.Main, packet);
   }
 
+  /**
+   * textOnly: stream assistant transcript into the cascade LLM→segmenter→TTS path.
+   * Non-final deltas drive `llm.delta` immediately (no buffer). Final emits `llm.done` only —
+   * the C0 adapter's final carries the full accumulated text, so re-emitting as delta would
+   * duplicate every streamed fragment.
+   */
+  private onTextOnlyAssistantTranscript(bus: PipelineBus, text: string, final: boolean): void {
+    if (!this.contextId) return;
+    const timestampMs = Date.now();
+    if (!final && text) {
+      const delta: LlmDeltaPacket = {
+        kind: "llm.delta",
+        contextId: this.contextId,
+        timestampMs,
+        text,
+      };
+      bus.push(Route.Main, delta);
+      return;
+    }
+    if (final && text.trim()) {
+      const done: LlmResponseDonePacket = {
+        kind: "llm.done",
+        contextId: this.contextId,
+        timestampMs,
+        text,
+      };
+      bus.push(Route.Main, done);
+    }
+  }
+
   private onResponseDone(bus: PipelineBus): void {
     if (!this.contextId) return;
-    this.emitCoalescedAudio(bus, true);
-    this.audioRemainder = new Uint8Array(0);
+    if (!this.opts.textOnly) {
+      this.emitCoalescedAudio(bus, true);
+      this.audioRemainder = new Uint8Array(0);
+    }
 
     const timestampMs = Date.now();
     const transcripts: SttResultPacket[] = this.turnUserText
@@ -477,6 +537,16 @@ export class RealtimeBridge implements VoicePlugin {
       text: this.turnUserText,
       transcripts,
     };
+
+    if (this.opts.textOnly) {
+      // Already streamed llm.delta/llm.done above. TTS plugin owns tts.end (REQ-5) — forcing
+      // it here would cut playout / break barge-in heard-prefix timing.
+      // syrinxTurns: endpointing already emitted the user-turn eos.turn_complete that drove
+      // requestResponse; re-emitting here would re-subscribe-fire requestResponse → loop.
+      if (!this.opts.syrinxTurns) bus.push(Route.Main, turnComplete);
+      return;
+    }
+
     const ttsEnd: TextToSpeechEndPacket = {
       kind: "tts.end",
       contextId: this.contextId,