@kuralle-syrinx/core 2.1.0

package/src/packets.ts

@@ -0,0 +1,553 @@
+// SPDX-License-Identifier: MIT
+//
+// Syrinx Kernel v2 — Packet Type Definitions
+//
+// Every packet flowing through the PipelineBus uses these types.
+// Naming convention:
+//   Commands (verb-first):  InterruptTts, DenoiseAudio, ExecuteLlm
+//   Events  (past-tense):   VadSpeechStarted, SttResult, LlmResponseDelta
+//   Errors:                 SttError, TtsError, LlmError
+//   Lifecycle:              InitStepCompleted, InitFailed, InitCompleted
+
+// =============================================================================
+// Base Types
+// =============================================================================
+
+/** Every packet flowing through the bus has these fields. */
+export interface VoicePacket {
+  /** Discriminator. Examples: "stt.result", "vad.speech_started", "init.failed" */
+  readonly kind: string;
+  /** Turn or session identifier. Empty string for session-scoped packets. */
+  readonly contextId: string;
+  /** Wall-clock creation time in ms since epoch. */
+  readonly timestampMs: number;
+}
+
+/** Marker: this packet's handler runs fire-and-forget (not awaited). */
+export interface AsyncPacket extends VoicePacket {
+  readonly isAsync: true;
+}
+
+// =============================================================================
+// Error Types
+// =============================================================================
+
+/** Categorized error types across all external-service components. */
+export enum ErrorCategory {
+  RateLimit = "rate_limit",           // HTTP 429 / quota exceeded — recoverable
+  NetworkTimeout = "network_timeout", // connection timeout / ECONNRESET — recoverable
+  Authentication = "authentication",  // HTTP 401/403 — fatal
+  InvalidInput = "invalid_input",     // HTTP 400 / invalid audio format — fatal
+  InternalFault = "internal_fault",   // unexpected provider error — fatal
+  ResourceExhausted = "resource_exhausted", // credits depleted — fatal
+}
+
+export interface VoiceErrorPacket extends VoicePacket {
+  /** Which component emitted the error. */
+  readonly component: "stt" | "tts" | "vad" | "eos" | "denoiser" | "llm" | "bridge" | "pipeline";
+  /** Machine-readable error category. */
+  readonly category: ErrorCategory;
+  /** Original error. May contain provider-specific details. */
+  readonly cause: Error;
+  /** Whether the session manager should retry (true) or terminate (false). */
+  readonly isRecoverable: boolean;
+}
+
+// =============================================================================
+// Lifecycle Types
+// =============================================================================
+
+export enum SessionState {
+  Uninitialized = "uninitialized",
+  Initializing = "initializing",
+  Ready = "ready",
+  Finalizing = "finalizing",
+  Closed = "closed",
+  Failed = "failed",
+}
+
+export enum InitStage {
+  Assistant = "assistant",
+  Conversation = "conversation",
+  Recorder = "recorder",
+  Normalizer = "normalizer",
+  Auth = "auth",
+  STT = "stt",
+  TTS = "tts",
+  VAD = "vad",
+  EOS = "eos",
+  Denoiser = "denoiser",
+  Behavior = "behavior",
+  Telemetry = "telemetry",
+}
+
+export interface InitStepCompletedPacket extends VoicePacket {
+  readonly kind: "init.step_completed";
+  readonly stage: InitStage;
+  readonly component: string;
+  /** Milliseconds taken to initialize this component. */
+  readonly initMs: number;
+}
+
+export interface InitializationFailedPacket extends VoicePacket {
+  readonly kind: "init.failed";
+  readonly stage: InitStage;
+  readonly component: string;
+  readonly category: ErrorCategory;
+  readonly cause: Error;
+  readonly isRecoverable: false;
+}
+
+export interface InitializationCompletedPacket extends VoicePacket {
+  readonly kind: "init.completed";
+}
+
+// =============================================================================
+// Audio format contract
+// =============================================================================
+
+export interface AudioFormat {
+  readonly encoding: "pcm_s16le" | "mulaw" | "opus";
+  readonly sampleRateHz: number;
+  readonly channels: 1;
+  /** Target frame duration for paced output, when known. */
+  readonly frameDurationMs?: number;
+}
+
+// =============================================================================
+// Input Pipeline Packets (user audio → transcript)
+// =============================================================================
+
+export interface UserAudioReceivedPacket extends VoicePacket {
+  readonly kind: "user.audio_received";
+  /** Raw PCM audio (16-bit, mono, 16kHz). */
+  readonly audio: Uint8Array;
+}
+
+export interface UserTextReceivedPacket extends VoicePacket {
+  readonly kind: "user.text_received";
+  readonly text: string;
+}
+
+export interface DenoiseAudioPacket extends VoicePacket {
+  readonly kind: "denoise.audio";
+  readonly audio: Uint8Array;
+}
+
+export interface DenoisedAudioPacket extends VoicePacket {
+  readonly kind: "denoise.result";
+  readonly audio: Uint8Array;
+  readonly noiseReduced: boolean;
+  readonly confidence: number;
+}
+
+export interface VadAudioPacket extends VoicePacket {
+  readonly kind: "vad.audio";
+  readonly audio: Uint8Array;
+}
+
+// Producers: local VAD plugins (silero-vad, pipecat-smart-turn) AND provider STT
+// plugins that surface a native speech-start signal (e.g. Deepgram vad_events
+// SpeechStarted, Deepgram Flux StartOfTurn). Provider-agnostic by design: any STT
+// plugin with an equivalent event should emit this packet so barge-in works on
+// VAD-less deployments. The TurnArbiter treats all producers identically.
+export interface VadSpeechStartedPacket extends VoicePacket {
+  readonly kind: "vad.speech_started";
+  readonly confidence: number;
+}
+
+export interface VadSpeechEndedPacket extends VoicePacket {
+  readonly kind: "vad.speech_ended";
+}
+
+/** Heartbeat emitted on every audio chunk during active speech. EOS uses this to extend its timer. */
+export interface VadSpeechActivityPacket extends VoicePacket, AsyncPacket {
+  readonly kind: "vad.speech_activity";
+  readonly isAsync: true;
+}
+
+export interface SpeechToTextAudioPacket extends VoicePacket {
+  readonly kind: "stt.audio";
+  readonly audio: Uint8Array;
+}
+
+export interface SttInterimPacket extends VoicePacket {
+  readonly kind: "stt.interim";
+  readonly text: string;
+}
+
+export interface SttResultPacket extends VoicePacket {
+  readonly kind: "stt.result";
+  readonly text: string;
+  readonly confidence: number;
+  readonly language?: string;
+  readonly provider?: Record<string, unknown>;
+}
+
+/** Requests that a streaming STT plugin publish its accumulated final transcript. */
+export interface FinalizeSttPacket extends VoicePacket {
+  readonly kind: "stt.finalize";
+}
+
+export interface SttErrorPacket extends VoicePacket, VoiceErrorPacket {
+  readonly kind: "stt.error";
+  readonly component: "stt";
+}
+
+export interface EndOfSpeechAudioPacket extends VoicePacket {
+  readonly kind: "eos.audio";
+  readonly audio: Uint8Array;
+}
+
+export interface EndOfSpeechPacket extends VoicePacket {
+  readonly kind: "eos.turn_complete";
+  readonly text: string;
+  /** All accumulated STT transcripts for this turn. */
+  readonly transcripts: readonly SttResultPacket[];
+}
+
+export interface InterimEndOfSpeechPacket extends VoicePacket {
+  readonly kind: "eos.interim";
+  readonly text: string;
+}
+
+// =============================================================================
+// User Input (processed — feeds LLM)
+// =============================================================================
+
+export interface UserInputPacket extends VoicePacket {
+  readonly kind: "user.input";
+  readonly text: string;
+  readonly language: string;
+}
+
+// =============================================================================
+// Interruption Packets (flow through Critical route)
+// =============================================================================
+
+export type InterruptionSource = "vad" | "word" | "client";
+
+export interface InterruptionDetectedPacket extends VoicePacket {
+  readonly kind: "interrupt.detected";
+  readonly source: InterruptionSource;
+}
+
+export interface InterruptTtsPacket extends VoicePacket {
+  readonly kind: "interrupt.tts";
+}
+
+export interface InterruptLlmPacket extends VoicePacket {
+  readonly kind: "interrupt.llm";
+}
+
+export interface InterruptSttPacket extends VoicePacket {
+  readonly kind: "interrupt.stt";
+}
+
+export interface TurnChangePacket extends VoicePacket {
+  readonly kind: "turn.change";
+  readonly previousContextId: string;
+  readonly reason: string;
+}
+
+export type DtmfDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "*" | "#";
+
+export interface DtmfReceivedPacket extends VoicePacket {
+  readonly kind: "dtmf.received";
+  readonly digit: DtmfDigit;
+  readonly provider: "twilio" | "telnyx" | "smartpbx";
+  /** Raw carrier-reported digit string, for diagnostics. */
+  readonly rawDigit: string;
+}
+
+// =============================================================================
+// LLM Pipeline Packets
+// =============================================================================
+
+export interface LlmDeltaPacket extends VoicePacket {
+  readonly kind: "llm.delta";
+  readonly text: string;
+}
+
+export interface LlmResponseDonePacket extends VoicePacket {
+  readonly kind: "llm.done";
+  readonly text: string;
+}
+
+export interface LlmErrorPacket extends VoicePacket, VoiceErrorPacket {
+  readonly kind: "llm.error";
+  readonly component: "llm" | "bridge";
+}
+
+export interface LlmToolCallPacket extends VoicePacket {
+  readonly kind: "llm.tool_call";
+  readonly toolId: string;
+  readonly toolName: string;
+  readonly toolArgs: Record<string, unknown>;
+}
+
+export interface LlmToolResultPacket extends VoicePacket {
+  readonly kind: "llm.tool_result";
+  readonly toolId: string;
+  readonly toolName: string;
+  readonly result: string;
+}
+
+export interface ReasoningSuspendedPacket extends VoicePacket {
+  readonly kind: "reasoning.suspended";
+  readonly runId: string;
+  readonly prompt?: string;
+  readonly payload: unknown;
+}
+
+export interface ReasoningResumePacket extends VoicePacket {
+  readonly kind: "reasoning.resume";
+  readonly runId: string;
+  readonly data: unknown;
+}
+
+// =============================================================================
+// Output Pipeline Packets (LLM text → TTS audio)
+// =============================================================================
+
+export interface TextToSpeechTextPacket extends VoicePacket {
+  readonly kind: "tts.text";
+  readonly text: string;
+}
+
+export interface TextToSpeechDonePacket extends VoicePacket {
+  readonly kind: "tts.done";
+  readonly text: string;
+}
+
+export interface TextToSpeechAudioPacket extends VoicePacket {
+  readonly kind: "tts.audio";
+  /** PCM audio bytes (16-bit, mono). */
+  readonly audio: Uint8Array;
+  /** Source sample rate for the PCM payload. */
+  readonly sampleRateHz: number;
+  readonly provider?: Record<string, unknown>;
+}
+
+export interface TextToSpeechEndPacket extends VoicePacket {
+  readonly kind: "tts.end";
+}
+
+export interface TtsWordTimestamp {
+  readonly word: string;
+  /** Milliseconds from the start of audio for this TTS context. */
+  readonly startMs: number;
+  /** Milliseconds from the start of audio for this TTS context. */
+  readonly endMs: number;
+}
+
+/**
+ * Word-level timestamps for a TTS audio chunk, emitted by TTS plugins that
+ * support them (Cartesia, ElevenLabs). Enables the bridge to compute the spoken
+ * prefix (G2/G25): the subset of assistant text the user actually heard, used to
+ * rewrite history on barge-in at word granularity instead of text granularity.
+ * Times are cumulative from the start of the context's audio stream.
+ */
+export interface TextToSpeechWordTimestampsPacket extends VoicePacket {
+  readonly kind: "tts.word_timestamps";
+  readonly words: readonly TtsWordTimestamp[];
+}
+
+export interface TtsErrorPacket extends VoicePacket, VoiceErrorPacket {
+  readonly kind: "tts.error";
+  readonly component: "tts";
+}
+
+/**
+ * Realtime playout position for a context, emitted by the output transport's
+ * paced-playout layer as audio actually reaches the wire. This is the
+ * authoritative playout clock; turn-taking and recording consume it instead of
+ * reconstructing timing from generation arrival. Absent when no paced transport
+ * is wired (e.g. headless), in which case consumers fall back to a
+ * sample-duration estimate.
+ */
+/** First paced audio frame reached the wire for a context (unthrottled). */
+export interface TextToSpeechPlayoutStartedPacket extends VoicePacket {
+  readonly kind: "tts.playout_started";
+}
+
+export interface TextToSpeechPlayoutProgressPacket extends VoicePacket {
+  readonly kind: "tts.playout_progress";
+  /** Cumulative realtime audio (ms) paced out to the wire for this context. */
+  readonly playedOutMs: number;
+  /** True on the final progress for the context — all generated audio has played out. */
+  readonly complete: boolean;
+}
+
+// =============================================================================
+// Recording Packets
+// =============================================================================
+
+export interface RecordUserAudioPacket extends VoicePacket {
+  readonly kind: "record.user_audio";
+  readonly audio: Uint8Array;
+}
+
+export interface RecordAssistantAudioDataPacket extends VoicePacket {
+  readonly kind: "record.assistant_audio";
+  readonly audio: Uint8Array;
+  /** Source sample rate for assistant PCM. */
+  readonly sampleRateHz: number;
+  readonly truncate: false;
+}
+
+export interface RecordAssistantAudioTruncatePacket extends VoicePacket {
+  readonly kind: "record.assistant_audio";
+  readonly audio: Uint8Array;
+  readonly truncate: true;
+}
+
+export type RecordAssistantAudioPacket = RecordAssistantAudioDataPacket | RecordAssistantAudioTruncatePacket;
+
+// =============================================================================
+// Behavior Packets
+// =============================================================================
+
+export interface StartIdleTimeoutPacket extends VoicePacket {
+  readonly kind: "behavior.idle_timeout_start";
+}
+
+export interface StopIdleTimeoutPacket extends VoicePacket {
+  readonly kind: "behavior.idle_timeout_stop";
+  readonly resetCount: boolean;
+}
+
+export interface InjectMessagePacket extends VoicePacket {
+  readonly kind: "inject.message";
+  readonly text: string;
+}
+
+export interface DisconnectRequestedPacket extends VoicePacket {
+  readonly kind: "session.disconnect";
+  readonly reason: string;
+}
+
+// =============================================================================
+// Mode Switching Packets
+// =============================================================================
+
+export interface ModeSwitchRequestedPacket extends VoicePacket {
+  readonly kind: "mode.switch_requested";
+  readonly mode: "text" | "audio";
+}
+
+export interface ModeSwitchCompletedPacket extends VoicePacket {
+  readonly kind: "mode.switch_completed";
+  readonly mode: "text" | "audio";
+}
+
+// =============================================================================
+// Persistence Packets
+// =============================================================================
+
+export interface MessageCreatePacket extends VoicePacket {
+  readonly kind: "message.create";
+  readonly role: "user" | "assistant" | "system";
+  readonly text: string;
+}
+
+// =============================================================================
+// Metric / Metadata Packets (Background route)
+// =============================================================================
+
+export interface ConversationMetricPacket extends VoicePacket {
+  readonly kind: "metric.conversation";
+  readonly name: string;
+  readonly value: string;
+}
+
+export type TurnBoundaryKind =
+  | "user_started_speaking"
+  | "user_stopped_speaking"
+  | "agent_thinking"
+  | "agent_started_speaking"
+  | "agent_audio_done"
+  | "interruption";
+
+export interface TurnBoundaryEventPacket extends VoicePacket {
+  readonly kind: "obs.turn_boundary";
+  readonly boundary: TurnBoundaryKind;
+  readonly sessionId: string;
+  readonly speechId: string;
+  readonly requestId?: string;
+  /** Monotonic ms (performance.timeOrigin + performance.now()) — immune to wall-clock jumps. */
+  readonly monotonicMs: number;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly region?: string;
+  readonly cancelled?: boolean;
+}
+
+export interface PipelineErrorPacket extends VoicePacket, VoiceErrorPacket {
+  readonly kind: "pipeline.error";
+  readonly component: "pipeline";
+}
+
+// =============================================================================
+// Convenience union types
+// =============================================================================
+
+/** All input pipeline packets. */
+export type InputPacket =
+  | UserAudioReceivedPacket
+  | UserTextReceivedPacket
+  | DenoiseAudioPacket
+  | DenoisedAudioPacket
+  | VadAudioPacket
+  | VadSpeechStartedPacket
+  | VadSpeechEndedPacket
+  | VadSpeechActivityPacket
+  | SpeechToTextAudioPacket
+  | SttInterimPacket
+  | SttResultPacket
+  | FinalizeSttPacket
+  | SttErrorPacket
+  | EndOfSpeechAudioPacket
+  | EndOfSpeechPacket
+  | InterimEndOfSpeechPacket
+  | UserInputPacket;
+
+/** All interruption packets (Critical route). */
+export type InterruptPacket =
+  | InterruptionDetectedPacket
+  | InterruptTtsPacket
+  | InterruptLlmPacket
+  | InterruptSttPacket
+  | TurnChangePacket;
+
+/** All LLM output packets. */
+export type LlmPacket =
+  | LlmDeltaPacket
+  | LlmResponseDonePacket
+  | LlmErrorPacket
+  | LlmToolCallPacket
+  | LlmToolResultPacket
+  | ReasoningSuspendedPacket
+  | ReasoningResumePacket;
+
+/** All TTS output packets. */
+export type TtsPacket =
+  | TextToSpeechTextPacket
+  | TextToSpeechDonePacket
+  | TextToSpeechAudioPacket
+  | TextToSpeechEndPacket
+  | TextToSpeechPlayoutStartedPacket
+  | TextToSpeechPlayoutProgressPacket
+  | TextToSpeechWordTimestampsPacket
+  | TtsErrorPacket;
+
+/** All error packets (any component). */
+export type AnyErrorPacket =
+  | SttErrorPacket
+  | TtsErrorPacket
+  | LlmErrorPacket
+  | PipelineErrorPacket
+  | InitializationFailedPacket;
+
+/** Observability packets (Background route). */
+export type ObservabilityPacket = ConversationMetricPacket | TurnBoundaryEventPacket;

package/src/pipeline-bus.g10.test.ts

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: MIT
+//
+// G10 repro — bus head-of-line blocking.
+//
+// The drain loop awaits each sync handler before dequeuing the next batch
+// (pipeline-bus.ts: `await this.dispatch(entry.packet)`), and dispatch awaits
+// sync handlers serially. So a long-running sync Main handler (in production: the
+// AI-SDK bridge running a multi-second LLM generation on `eos.turn_complete`)
+// parks the loop — and a Critical `interrupt.detected` pushed during that window
+// is NOT dispatched until the slow handler returns. That delays barge-in (and
+// defers the llm.delta -> tts.text streaming the slow handler itself produces).
+//
+// These tests assert the DESIRED behavior: Critical packets are dispatched
+// promptly even while a slow Main handler is in flight. They are RED against the
+// current bus and turn GREEN once generation no longer parks the drain loop.
+
+import { describe, it, expect } from "vitest";
+import { PipelineBusImpl, Route } from "./pipeline-bus.js";
+import { VoiceAgentSession } from "./voice-agent-session.js";
+import type { PipelineBus } from "./pipeline-bus.js";
+import type { VoicePlugin, PluginConfig } from "./plugin-contract.js";
+import type { VoicePacket } from "./packets.js";
+
+function pkt(kind: string, contextId = "t1"): VoicePacket {
+  return { kind, contextId, timestampMs: Date.now() } as unknown as VoicePacket;
+}
+
+describe("G10 — bus head-of-line blocking", () => {
+  it("dispatches a Critical interrupt while a slow Main handler is still running", async () => {
+    const bus = new PipelineBusImpl();
+    const drain = bus.start();
+
+    let releaseSlow!: () => void;
+    const slowGate = new Promise<void>((resolve) => {
+      releaseSlow = resolve;
+    });
+    const timeline: Array<{ name: string; atMs: number }> = [];
+    const t0 = Date.now();
+    const mark = (name: string): void => {
+      timeline.push({ name, atMs: Date.now() - t0 });
+    };
+
+    // Slow Main handler — stands in for the bridge's long LLM generation. Registered
+    // as a concurrent producer so it does not park the drain loop.
+    bus.on("eos.turn_complete", async () => {
+      mark("slow-start");
+      await slowGate;
+      mark("slow-end");
+    }, { concurrent: true });
+    // Critical interrupt handler — stands in for barge-in handling.
+    bus.on("interrupt.detected", () => {
+      mark("interrupt-dispatched");
+    });
+
+    bus.push(Route.Main, pkt("eos.turn_complete"));
+    await new Promise((r) => setTimeout(r, 20)); // let the slow handler start
+    bus.push(Route.Critical, pkt("interrupt.detected"));
+    await new Promise((r) => setTimeout(r, 80)); // window in which a healthy bus dispatches Critical
+
+    const interruptedWhileSlowRunning = timeline.some((e) => e.name === "interrupt-dispatched");
+
+    releaseSlow();
+    await new Promise((r) => setTimeout(r, 20));
+    bus.stop();
+    await drain;
+
+    // The interrupt must have been dispatched BEFORE the slow handler finished.
+    const interrupt = timeline.find((e) => e.name === "interrupt-dispatched");
+    const slowEnd = timeline.find((e) => e.name === "slow-end");
+    expect(interrupt, `timeline: ${JSON.stringify(timeline)}`).toBeDefined();
+    expect(slowEnd).toBeDefined();
+    expect(interruptedWhileSlowRunning).toBe(true);
+    expect(interrupt!.atMs).toBeLessThan(slowEnd!.atMs);
+  });
+});
+
+// Production simulation: a realistic streaming LLM bridge emits tokens over time on
+// `eos.turn_complete`. The session sentence-buffers them into `tts.text`. With the
+// bus parked on the bridge's (awaited) handler, the deltas it pushes are not
+// dispatched until the handler returns — so the FIRST sentence does not reach TTS
+// until generation completes (streaming is defeated). Desired: the first sentence
+// reaches TTS WHILE generation is still in flight.
+class StreamingBridgePlugin implements VoicePlugin {
+  generationEndAtMs = -1;
+  constructor(private readonly t0Ms: number) {}
+  async initialize(bus: PipelineBus, _config: PluginConfig): Promise<void> {
+    bus.on("eos.turn_complete", async (pkt) => {
+      const contextId = (pkt as { contextId: string }).contextId;
+      // Two complete sentences streamed as tokens, 60 ms apart (~360 ms total).
+      const tokens = ["Hello", " there.", " How", " are", " you?", " done."];
+      for (const token of tokens) {
+        await new Promise((r) => setTimeout(r, 60));
+        bus.push(Route.Main, { kind: "llm.delta", contextId, timestampMs: Date.now(), text: token } as unknown as VoicePacket);
+      }
+      bus.push(Route.Main, { kind: "llm.done", contextId, timestampMs: Date.now(), text: tokens.join("") } as unknown as VoicePacket);
+      this.generationEndAtMs = Date.now() - this.t0Ms;
+    }, { concurrent: true });
+  }
+  async close(): Promise<void> {}
+}
+
+class RecordingTtsPlugin implements VoicePlugin {
+  ttsTextAtMs: number[] = [];
+  constructor(private readonly t0Ms: number) {}
+  async initialize(bus: PipelineBus, _config: PluginConfig): Promise<void> {
+    bus.on("tts.text", () => {
+      this.ttsTextAtMs.push(Date.now() - this.t0Ms);
+    });
+  }
+  async close(): Promise<void> {}
+}
+
+describe("G10 — production simulation: streaming LLM -> TTS not deferred by the bus", () => {
+  it("delivers the first sentence to TTS while generation is still in flight", async () => {
+    const t0 = Date.now();
+    const bridge = new StreamingBridgePlugin(t0);
+    const tts = new RecordingTtsPlugin(t0);
+    const session = new VoiceAgentSession({ plugins: { bridge: {}, tts: {} } });
+    session.registerPlugin("bridge", bridge);
+    session.registerPlugin("tts", tts);
+    await session.start();
+
+    session.bus.push(Route.Main, {
+      kind: "eos.turn_complete",
+      contextId: "turn-1",
+      timestampMs: Date.now(),
+      text: "what time is it",
+      transcripts: [],
+    } as unknown as VoicePacket);
+
+    // Wait past full generation + drain.
+    await new Promise((r) => setTimeout(r, 700));
+    if (session.state !== "closed") await session.close();
+
+    const firstTtsTextAtMs = tts.ttsTextAtMs[0] ?? Number.POSITIVE_INFINITY;
+    // The first sentence ("Hello there.") completes ~120 ms into a ~360 ms generation.
+    // Bug: it is not delivered until generation ends (>= generationEndAtMs).
+    // Desired: delivered while generation is still streaming.
+    expect(tts.ttsTextAtMs.length, "expected at least one tts.text").toBeGreaterThan(0);
+    expect(
+      firstTtsTextAtMs,
+      `firstTtsText=${firstTtsTextAtMs}ms generationEnd=${bridge.generationEndAtMs}ms all=${JSON.stringify(tts.ttsTextAtMs)}`,
+    ).toBeLessThan(bridge.generationEndAtMs);
+  });
+});