@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/live-voice/__tests__/live-voice-tts-session.test.ts

@@ -109,7 +109,9 @@ async function waitFor(
   message = "Timed out waiting for live voice test condition",
 ): Promise<void> {
   for (let attempt = 0; attempt < 40; attempt += 1) {
-    if (predicate()) return;
+    if (predicate()) {
+      return;
+    }
     await new Promise((resolve) => setTimeout(resolve, 5));
   }
   throw new Error(message);
@@ -164,6 +166,56 @@ function makeMessageComplete(): Parameters<
   };
 }
 
+function b64(text: string): string {
+  return Buffer.from(text).toString("base64");
+}
+
+function ttsAudioPayloads(frames: LiveVoiceServerFrame[]): string[] {
+  return frames.flatMap((frame) =>
+    frame.type === "tts_audio" ? [frame.dataBase64] : [],
+  );
+}
+
+interface ControlledSynthesis {
+  options: LiveVoiceTtsOptions;
+  finish: () => void;
+  fail: (err: Error) => void;
+}
+
+// A TTS streamer whose per-call completion is driven by the test: chunks are
+// injected via `calls[n].options.onAudioChunk` and the provider promise
+// settles on `finish`/`fail`. `events` records call starts and settles so
+// synthesis overlap can be asserted deterministically.
+function createControlledTtsStreamer(): {
+  streamTtsAudio: LiveVoiceTtsStreamer;
+  calls: ControlledSynthesis[];
+  events: string[];
+} {
+  const calls: ControlledSynthesis[] = [];
+  const events: string[] = [];
+  const streamTtsAudio = mock((options: LiveVoiceTtsOptions) => {
+    events.push(`start:${options.text}`);
+    return new Promise<LiveVoiceTtsResult>((resolve, reject) => {
+      calls.push({
+        options,
+        finish: () => {
+          events.push(`end:${options.text}`);
+          resolve(makeTtsResult(options.text));
+        },
+        fail: (err) => {
+          events.push(`fail:${options.text}`);
+          reject(err);
+        },
+      });
+    });
+  });
+  return { streamTtsAudio, calls, events };
+}
+
+const FIRST_SENTENCE = "This is the first spoken sentence.";
+const SECOND_SENTENCE = "Here comes the second spoken sentence.";
+const THIRD_SENTENCE = "And now a third spoken sentence arrives.";
+
 describe("LiveVoiceSession TTS", () => {
   test("starts streaming TTS audio before the assistant message completes at a segment boundary", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
@@ -205,6 +257,52 @@ describe("LiveVoiceSession TTS", () => {
     });
   });
 
+  test("flushes the first segment of a turn eagerly at a clause boundary", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const ttsTexts: string[] = [];
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks = options.callbacks;
+      return { turnId: "bridge-turn-1", abort: mock() };
+    });
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      ttsTexts.push(options.text);
+      options.onAudioChunk(makeTtsChunk(`audio:${options.text}`));
+      return makeTtsResult(options.text);
+    });
+    const { frames, session } = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await startReleasedTurn(session);
+    callbacks?.assistant_text_delta?.(
+      makeTextDelta(
+        "Sure, I can help with that, and here is more text to say.",
+      ),
+    );
+    await waitFor(() => frames.some((frame) => frame.type === "tts_audio"));
+
+    // The opening clause flushes at the comma past the prefix floor instead
+    // of waiting for the sentence; the remainder follows sentence rules.
+    expect(ttsTexts).toEqual([
+      "Sure, I can help with that,",
+      "and here is more text to say.",
+    ]);
+
+    // Subsequent text in the same turn is not eagerly clause-split.
+    callbacks?.assistant_text_delta?.(
+      makeTextDelta(" Later we can dig into the details, if you want more"),
+    );
+    callbacks?.message_complete?.(makeMessageComplete());
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(ttsTexts).toEqual([
+      "Sure, I can help with that,",
+      "and here is more text to say.",
+      "Later we can dig into the details, if you want more",
+    ]);
+  });
+
   test("forwards non-PCM TTS chunk content type unchanged", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
@@ -231,7 +329,7 @@ describe("LiveVoiceSession TTS", () => {
     });
   });
 
-  test("flushes long assistant text as a conservative TTS segment before completion", async () => {
+  test("flushes long unpunctuated assistant text before completion at the eager threshold", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const ttsTexts: string[] = [];
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
@@ -252,9 +350,11 @@ describe("LiveVoiceSession TTS", () => {
     callbacks?.assistant_text_delta?.(makeTextDelta("steady ".repeat(32)));
     await waitFor(() => frames.some((frame) => frame.type === "tts_audio"));
 
+    // The turn's first segment splits at the eager threshold; the rest stays
+    // buffered under sentence rules until more text or completion arrives.
     expect(ttsTexts).toHaveLength(1);
-    expect(ttsTexts[0]?.length).toBeGreaterThan(100);
-    expect(ttsTexts[0]?.length).toBeLessThanOrEqual(181);
+    expect(ttsTexts[0]?.length).toBeGreaterThan(30);
+    expect(ttsTexts[0]?.length).toBeLessThanOrEqual(60);
     expect(frames.some((frame) => frame.type === "tts_done")).toBe(false);
   });
 
@@ -394,4 +494,250 @@ describe("LiveVoiceSession TTS", () => {
     expect(frames.some((frame) => frame.type === "tts_audio")).toBe(false);
     expect(frames.some((frame) => frame.type === "tts_done")).toBe(false);
   });
+
+  test("prefetches the next segment while the current one streams and emits frames strictly in order", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks = options.callbacks;
+      return { turnId: "bridge-turn-1", abort: mock() };
+    });
+    const { streamTtsAudio, calls, events } = createControlledTtsStreamer();
+    const { frames, session } = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await startReleasedTurn(session);
+    callbacks?.assistant_text_delta?.(makeTextDelta(FIRST_SENTENCE));
+    callbacks?.assistant_text_delta?.(makeTextDelta(` ${SECOND_SENTENCE}`));
+
+    // Both provider calls are in flight before either stream settles.
+    expect(events).toEqual([
+      `start:${FIRST_SENTENCE}`,
+      `start:${SECOND_SENTENCE}`,
+    ]);
+
+    // A chunk from the prefetching second segment buffers instead of
+    // jumping ahead of the still-streaming first segment.
+    calls[1]?.options.onAudioChunk(makeTtsChunk("audio:second-1"));
+    await flushAsyncCallbacks();
+    expect(ttsAudioPayloads(frames)).toEqual([]);
+
+    calls[0]?.options.onAudioChunk(makeTtsChunk("audio:first-1"));
+    calls[0]?.options.onAudioChunk(makeTtsChunk("audio:first-2"));
+    calls[0]?.finish();
+    await waitFor(() =>
+      frames.some(
+        (frame) =>
+          frame.type === "tts_audio" &&
+          frame.dataBase64 === b64("audio:second-1"),
+      ),
+    );
+
+    calls[1]?.options.onAudioChunk(makeTtsChunk("audio:second-2"));
+    calls[1]?.finish();
+    callbacks?.message_complete?.(makeMessageComplete());
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(streamTtsAudio).toHaveBeenCalledTimes(2);
+    expect(ttsAudioPayloads(frames)).toEqual([
+      b64("audio:first-1"),
+      b64("audio:first-2"),
+      b64("audio:second-1"),
+      b64("audio:second-2"),
+    ]);
+    expect(frames.at(-1)).toMatchObject({
+      type: "tts_done",
+      turnId: "live-turn-1",
+    });
+  });
+
+  test("holds further segments as text until a slot frees and defers tts_done until every job drains", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks = options.callbacks;
+      return { turnId: "bridge-turn-1", abort: mock() };
+    });
+    const { streamTtsAudio, calls } = createControlledTtsStreamer();
+    const { frames, session } = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await startReleasedTurn(session);
+    callbacks?.assistant_text_delta?.(makeTextDelta(FIRST_SENTENCE));
+    callbacks?.assistant_text_delta?.(makeTextDelta(` ${SECOND_SENTENCE}`));
+    callbacks?.assistant_text_delta?.(makeTextDelta(` ${THIRD_SENTENCE}`));
+    callbacks?.message_complete?.(makeMessageComplete());
+
+    // Two lookahead slots: the third segment stays queued as text.
+    expect(calls).toHaveLength(2);
+
+    calls[0]?.options.onAudioChunk(makeTtsChunk("audio:one"));
+    calls[0]?.finish();
+    await waitFor(() => calls.length === 3);
+    expect(frames.some((frame) => frame.type === "tts_done")).toBe(false);
+
+    calls[1]?.options.onAudioChunk(makeTtsChunk("audio:two"));
+    calls[1]?.finish();
+    await flushAsyncCallbacks();
+    expect(frames.some((frame) => frame.type === "tts_done")).toBe(false);
+
+    calls[2]?.options.onAudioChunk(makeTtsChunk("audio:three"));
+    calls[2]?.finish();
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(ttsAudioPayloads(frames)).toEqual([
+      b64("audio:one"),
+      b64("audio:two"),
+      b64("audio:three"),
+    ]);
+    expect(frames.at(-1)).toMatchObject({
+      type: "tts_done",
+      turnId: "live-turn-1",
+    });
+  });
+
+  test("overlapped synthesis finishes two delayed segments in about one delay, not two", async () => {
+    const synthesisDelayMs = 150;
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks = options.callbacks;
+      return { turnId: "bridge-turn-1", abort: mock() };
+    });
+    const events: string[] = [];
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      events.push(`start:${options.text}`);
+      await new Promise((resolve) => setTimeout(resolve, synthesisDelayMs));
+      options.onAudioChunk(makeTtsChunk(`audio:${options.text}`));
+      events.push(`end:${options.text}`);
+      return makeTtsResult(options.text);
+    });
+    const { frames, session } = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await startReleasedTurn(session);
+    const startedAt = performance.now();
+    callbacks?.assistant_text_delta?.(makeTextDelta(FIRST_SENTENCE));
+    callbacks?.assistant_text_delta?.(makeTextDelta(` ${SECOND_SENTENCE}`));
+    callbacks?.message_complete?.(makeMessageComplete());
+    const deadline = startedAt + synthesisDelayMs * 4;
+    while (
+      !frames.some((frame) => frame.type === "tts_done") &&
+      performance.now() < deadline
+    ) {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    const elapsedMs = performance.now() - startedAt;
+
+    // Both provider calls start before either finishes, so the two
+    // first-chunk delays overlap instead of stacking.
+    expect(events.slice(0, 2)).toEqual([
+      `start:${FIRST_SENTENCE}`,
+      `start:${SECOND_SENTENCE}`,
+    ]);
+    expect(elapsedMs).toBeLessThan(synthesisDelayMs * 2);
+    expect(ttsAudioPayloads(frames)).toEqual([
+      b64(`audio:${FIRST_SENTENCE}`),
+      b64(`audio:${SECOND_SENTENCE}`),
+    ]);
+    expect(frames.at(-1)).toMatchObject({
+      type: "tts_done",
+      turnId: "live-turn-1",
+    });
+  });
+
+  test("drops buffered prefetch audio when the turn is cancelled mid-prefetch", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const abort = mock();
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks = options.callbacks;
+      return { turnId: "bridge-turn-1", abort };
+    });
+    const { streamTtsAudio, calls } = createControlledTtsStreamer();
+    const { frames, session } = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await startReleasedTurn(session);
+    callbacks?.assistant_text_delta?.(makeTextDelta(FIRST_SENTENCE));
+    callbacks?.assistant_text_delta?.(makeTextDelta(` ${SECOND_SENTENCE}`));
+    calls[0]?.options.onAudioChunk(makeTtsChunk("audio:first-1"));
+    calls[1]?.options.onAudioChunk(makeTtsChunk("audio:second-1"));
+    await waitFor(() => frames.some((frame) => frame.type === "tts_audio"));
+
+    // Cancellation runs the same abort path as a VAD barge-in: the shared
+    // turn signal aborts both in-flight provider streams at once.
+    await session.handleClientFrame({ type: "interrupt" });
+    const frameCountAfterInterrupt = frames.length;
+    expect(calls[0]?.options.signal?.aborted).toBe(true);
+    expect(calls[1]?.options.signal?.aborted).toBe(true);
+
+    calls[1]?.options.onAudioChunk(makeTtsChunk("audio:second-2"));
+    calls[0]?.finish();
+    calls[1]?.finish();
+    await flushAsyncCallbacks();
+
+    expect(frames).toHaveLength(frameCountAfterInterrupt);
+    expect(ttsAudioPayloads(frames)).toEqual([b64("audio:first-1")]);
+    expect(frames.some((frame) => frame.type === "tts_done")).toBe(false);
+  });
+
+  test("emits a recoverable error for a failed prefetch and keeps later segments in order", async () => {
+    let callbacks: VoiceTurnCallbacks | undefined;
+    const abort = mock();
+    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
+      callbacks = options.callbacks;
+      return { turnId: "bridge-turn-1", abort };
+    });
+    const { streamTtsAudio, calls } = createControlledTtsStreamer();
+    const { frames, session } = createSessionHarness({
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await startReleasedTurn(session);
+    callbacks?.assistant_text_delta?.(makeTextDelta(FIRST_SENTENCE));
+    callbacks?.assistant_text_delta?.(makeTextDelta(` ${SECOND_SENTENCE}`));
+    callbacks?.assistant_text_delta?.(makeTextDelta(` ${THIRD_SENTENCE}`));
+    callbacks?.message_complete?.(makeMessageComplete());
+
+    // The prefetch fails while the first segment is still streaming.
+    calls[1]?.fail(new Error("prefetch exploded"));
+    calls[0]?.options.onAudioChunk(makeTtsChunk("audio:one"));
+    calls[0]?.finish();
+    await waitFor(() => calls.length === 3);
+    calls[2]?.options.onAudioChunk(makeTtsChunk("audio:three"));
+    calls[2]?.finish();
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(abort).not.toHaveBeenCalled();
+    expect(ttsAudioPayloads(frames)).toEqual([
+      b64("audio:one"),
+      b64("audio:three"),
+    ]);
+    const firstAudioIndex = frames.findIndex(
+      (frame) =>
+        frame.type === "tts_audio" && frame.dataBase64 === b64("audio:one"),
+    );
+    const errorIndex = frames.findIndex((frame) => frame.type === "error");
+    const thirdAudioIndex = frames.findIndex(
+      (frame) =>
+        frame.type === "tts_audio" && frame.dataBase64 === b64("audio:three"),
+    );
+    expect(frames[errorIndex]).toMatchObject({
+      type: "error",
+      message: expect.stringContaining("prefetch exploded"),
+      recoverable: true,
+    });
+    expect(firstAudioIndex).toBeLessThan(errorIndex);
+    expect(errorIndex).toBeLessThan(thirdAudioIndex);
+    expect(frames.at(-1)).toMatchObject({
+      type: "tts_done",
+      turnId: "live-turn-1",
+    });
+  });
 });

package/src/live-voice/__tests__/live-voice-tts.test.ts

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import {
   _resetTtsProviderOverridesForTests,
@@ -17,6 +17,17 @@ import type {
 
 let config = makeConfig();
 
+// Real-catalog tests exercise the actual provider adapters, which read
+// credentials and config through these modules.
+mock.module("../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async () => "test-api-key",
+  getProviderKeyAsync: async () => "test-api-key",
+}));
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => config,
+  loadConfig: () => config,
+}));
+
 const { LiveVoiceTtsError, streamLiveVoiceTtsAudio } =
   await import("../live-voice-tts.js");
 
@@ -67,6 +78,7 @@ describe("streamLiveVoiceTtsAudio", () => {
         voiceId: undefined,
         signal: undefined,
         outputFormat: undefined,
+        sampleRateHz: 24_000,
       },
     ]);
     expect(frames).toEqual([
@@ -152,10 +164,10 @@ describe("streamLiveVoiceTtsAudio", () => {
         onChunk: (chunk: Uint8Array) => void,
       ): Promise<TtsSynthesisResult> {
         requests.push(request);
-        onChunk(Buffer.from("pcm-one"));
-        onChunk(Buffer.from("pcm-two"));
+        onChunk(Buffer.from("pcm-one!"));
+        onChunk(Buffer.from("pcm-two!"));
         return {
-          audio: Buffer.from("pcm-onepcm-two"),
+          audio: Buffer.from("pcm-one!pcm-two!"),
           contentType: "audio/pcm",
         };
       },
@@ -166,33 +178,111 @@ describe("streamLiveVoiceTtsAudio", () => {
       config,
       text: "hello from live voice",
       outputFormat: "pcm",
+      sampleRate: 16_000,
       onAudioChunk: (chunk) => frames.push(chunk),
     });
 
     expect(requests[0]?.outputFormat).toBe("pcm");
+    expect(requests[0]?.sampleRateHz).toBe(16_000);
     expect(frames).toEqual([
       {
         type: "tts_audio",
         contentType: "audio/pcm",
-        sampleRate: 24_000,
-        dataBase64: Buffer.from("pcm-one").toString("base64"),
+        sampleRate: 16_000,
+        dataBase64: Buffer.from("pcm-one!").toString("base64"),
       },
       {
         type: "tts_audio",
         contentType: "audio/pcm",
-        sampleRate: 24_000,
-        dataBase64: Buffer.from("pcm-two").toString("base64"),
+        sampleRate: 16_000,
+        dataBase64: Buffer.from("pcm-two!").toString("base64"),
       },
     ]);
     expect(result).toEqual({
       provider: "elevenlabs",
       contentType: "audio/pcm",
-      sampleRate: 24_000,
+      sampleRate: 16_000,
       chunks: 2,
-      bytes: Buffer.byteLength("pcm-onepcm-two"),
+      bytes: Buffer.byteLength("pcm-one!pcm-two!"),
     });
   });
 
+  test("carries a trailing odd byte into the next PCM chunk to keep frames sample-aligned", async () => {
+    config = makeConfig({ provider: "elevenlabs" });
+    _setTtsProviderForTests({
+      id: "elevenlabs",
+      capabilities: {
+        supportsStreaming: true,
+        supportedFormats: ["mp3", "pcm"],
+      },
+      async synthesize(): Promise<TtsSynthesisResult> {
+        throw new Error("buffered synthesis should not be used");
+      },
+      async synthesizeStream(
+        _request: TtsSynthesisRequest,
+        onChunk: (chunk: Uint8Array) => void,
+      ): Promise<TtsSynthesisResult> {
+        onChunk(Buffer.from([1, 2, 3]));
+        onChunk(Buffer.from([4, 5, 6, 7, 8]));
+        return {
+          audio: Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]),
+          contentType: "audio/pcm",
+        };
+      },
+    });
+
+    const frames: LiveVoiceTtsAudioChunk[] = [];
+    const result = await streamLiveVoiceTtsAudio({
+      config,
+      text: "hello from live voice",
+      outputFormat: "pcm",
+      onAudioChunk: (chunk) => frames.push(chunk),
+    });
+
+    expect(frames.map((frame) => frame.dataBase64)).toEqual([
+      Buffer.from([1, 2]).toString("base64"),
+      Buffer.from([3, 4, 5, 6, 7, 8]).toString("base64"),
+    ]);
+    expect(result).toMatchObject({ chunks: 2, bytes: 8 });
+  });
+
+  test("drops a dangling final odd byte instead of emitting a torn PCM sample", async () => {
+    config = makeConfig({ provider: "elevenlabs" });
+    _setTtsProviderForTests({
+      id: "elevenlabs",
+      capabilities: {
+        supportsStreaming: true,
+        supportedFormats: ["mp3", "pcm"],
+      },
+      async synthesize(): Promise<TtsSynthesisResult> {
+        throw new Error("buffered synthesis should not be used");
+      },
+      async synthesizeStream(
+        _request: TtsSynthesisRequest,
+        onChunk: (chunk: Uint8Array) => void,
+      ): Promise<TtsSynthesisResult> {
+        onChunk(Buffer.from([1, 2, 3]));
+        return {
+          audio: Buffer.from([1, 2, 3]),
+          contentType: "audio/pcm",
+        };
+      },
+    });
+
+    const frames: LiveVoiceTtsAudioChunk[] = [];
+    const result = await streamLiveVoiceTtsAudio({
+      config,
+      text: "hello from live voice",
+      outputFormat: "pcm",
+      onAudioChunk: (chunk) => frames.push(chunk),
+    });
+
+    expect(frames.map((frame) => frame.dataBase64)).toEqual([
+      Buffer.from([1, 2]).toString("base64"),
+    ]);
+    expect(result).toMatchObject({ chunks: 1, bytes: 2 });
+  });
+
   test("skips the buffered non-PCM emit when the signal aborts mid-stream", async () => {
     const controller = new AbortController();
     _setTtsProviderForTests({
@@ -237,6 +327,92 @@ describe("streamLiveVoiceTtsAudio", () => {
     });
   });
 
+  test("labels frames with the provider-reported output rate when the requested rate is not honoured", async () => {
+    config = makeConfig({ provider: "elevenlabs" });
+    _setTtsProviderForTests({
+      id: "elevenlabs",
+      capabilities: {
+        supportsStreaming: true,
+        supportedFormats: ["mp3", "pcm"],
+      },
+      resolveOutputSampleRateHz: () => 16_000,
+      async synthesize(): Promise<TtsSynthesisResult> {
+        throw new Error("buffered synthesis should not be used");
+      },
+      async synthesizeStream(
+        request: TtsSynthesisRequest,
+        onChunk: (chunk: Uint8Array) => void,
+      ): Promise<TtsSynthesisResult> {
+        expect(request.sampleRateHz).toBe(48_000);
+        onChunk(Buffer.from("pcm-one!"));
+        return {
+          audio: Buffer.from("pcm-one!"),
+          contentType: "audio/pcm",
+        };
+      },
+    });
+
+    const frames: LiveVoiceTtsAudioChunk[] = [];
+    const result = await streamLiveVoiceTtsAudio({
+      config,
+      text: "hello from live voice",
+      outputFormat: "pcm",
+      sampleRate: 48_000,
+      onAudioChunk: (chunk) => frames.push(chunk),
+    });
+
+    expect(frames.map((frame) => frame.sampleRate)).toEqual([16_000]);
+    expect(result.sampleRate).toBe(16_000);
+  });
+
+  test("resolves ElevenLabs streaming through the real catalog adapter", async () => {
+    // No _setTtsProviderForTests override: this exercises the real catalog
+    // provider lookup and must not throw LIVE_VOICE_TTS_STREAMING_UNAVAILABLE.
+    config = makeConfig({ provider: "elevenlabs" });
+    const originalFetch = globalThis.fetch;
+    let capturedUrl = "";
+    globalThis.fetch = (async (input: RequestInfo | URL) => {
+      capturedUrl = typeof input === "string" ? input : input.toString();
+      return new Response(
+        new ReadableStream<Uint8Array>({
+          start(controller) {
+            controller.enqueue(new Uint8Array([0x01, 0x02, 0x03, 0x04]));
+            controller.close();
+          },
+        }),
+        { status: 200 },
+      );
+    }) as unknown as typeof globalThis.fetch;
+
+    try {
+      const frames: LiveVoiceTtsAudioChunk[] = [];
+      const result = await streamLiveVoiceTtsAudio({
+        config,
+        text: "hello from live voice",
+        outputFormat: "pcm",
+        sampleRate: 24_000,
+        onAudioChunk: (chunk) => frames.push(chunk),
+      });
+
+      expect(capturedUrl).toContain("/stream?output_format=pcm_24000");
+      expect(result).toMatchObject({
+        provider: "elevenlabs",
+        contentType: "audio/pcm",
+        sampleRate: 24_000,
+      });
+      expect(frames).toEqual([
+        {
+          type: "tts_audio",
+          contentType: "audio/pcm",
+          sampleRate: 24_000,
+          dataBase64: Buffer.from([0x01, 0x02, 0x03, 0x04]).toString("base64"),
+        },
+      ]);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
   test("returns a typed configuration error for a non-streaming provider", async () => {
     config = makeConfig({ provider: "elevenlabs" });
     _setTtsProviderForTests({