@vellumai/assistant 0.11.3-staging.2 → 0.11.3-staging.3

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

@@ -12,6 +12,7 @@ import {
   type LiveVoiceStreamingTranscriberResolver,
 } from "../live-voice-session.js";
 import type { LiveVoiceSessionFactoryContext } from "../live-voice-session-manager.js";
+import type { LiveVoiceTtsOptions } from "../live-voice-tts.js";
 import {
   createLiveVoiceServerFrameSequencer,
   type LiveVoiceClientStartFrame,
@@ -29,7 +30,9 @@ const START_FRAME = {
 } as const satisfies LiveVoiceClientStartFrame;
 
 class MockStreamingTranscriber implements StreamingTranscriber {
-  readonly providerId = "deepgram" as const;
+  // Configurable: the session gates the language-pin fallback on the DIALED
+  // transcriber's providerId (see turnLanguageFor).
+  readonly providerId: StreamingTranscriber["providerId"];
   readonly boundaryId = "daemon-streaming" as const;
   readonly audioChunks: Buffer[] = [];
   readonly mimeTypes: string[] = [];
@@ -37,6 +40,10 @@ class MockStreamingTranscriber implements StreamingTranscriber {
   stopped = false;
   private onEvent: ((event: SttStreamServerEvent) => void) | null = null;
 
+  constructor(providerId: StreamingTranscriber["providerId"] = "deepgram") {
+    this.providerId = providerId;
+  }
+
   async start(onEvent: (event: SttStreamServerEvent) => void): Promise<void> {
     this.started = true;
     this.onEvent = onEvent;
@@ -135,6 +142,39 @@ function completingVoiceTurnStarter() {
   });
 }
 
+// A starter whose leg streams one spoken sentence so the turn reaches TTS.
+function speakingVoiceTurnStarter(reply = "Okay.") {
+  return mock(async (options: VoiceTurnOptions) => {
+    options.callbacks?.assistant_text_delta?.({
+      type: "assistant_text_delta",
+      text: reply,
+      conversationId: options.conversationId,
+    });
+    options.callbacks?.message_complete?.({
+      type: "message_complete",
+      conversationId: options.conversationId,
+      messageId: "assistant-message-123",
+    });
+    return { turnId: "bridge-turn-1", abort: mock() };
+  });
+}
+
+// Records the exact options object of every TTS synthesis request.
+function recordingTtsStreamer() {
+  const ttsCalls: LiveVoiceTtsOptions[] = [];
+  const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+    ttsCalls.push(options);
+    return {
+      provider: "fish-audio" as const,
+      contentType: "audio/pcm",
+      sampleRate: 24_000,
+      chunks: 0,
+      bytes: 0,
+    };
+  });
+  return { streamTtsAudio, ttsCalls };
+}
+
 function createContext(overrides: Partial<LiveVoiceClientStartFrame> = {}): {
   context: LiveVoiceSessionFactoryContext;
   frames: LiveVoiceServerFrame[];
@@ -1337,6 +1377,269 @@ describe("LiveVoiceSession STT", () => {
     ]);
   });
 
+  test("finals tagged with a detected language carry it to TTS and the control prompt", async () => {
+    const transcriber = new MockStreamingTranscriber();
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(new Uint8Array([1]));
+    transcriber.emit({ type: "final", text: "नमस्ते", languages: ["hi"] });
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => ttsCalls.length >= 1);
+
+    expect(ttsCalls[0]?.language).toBe("hi");
+    expect(startVoiceTurn.mock.calls[0]?.[0]?.voiceControlPrompt).toContain(
+      'speaking the language with code "hi"',
+    );
+  });
+
+  test("a tagged partial supplies the turn language when finals carry no tags", async () => {
+    // Speculative turns dispatch from partials before the first tagged
+    // final, so the latest tagged partial must resolve the language.
+    const transcriber = new MockStreamingTranscriber();
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(new Uint8Array([1]));
+    transcriber.emit({ type: "partial", text: "hola", languages: ["es"] });
+    transcriber.emit({ type: "final", text: "hola amigo" });
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => ttsCalls.length >= 1);
+
+    expect(ttsCalls[0]?.language).toBe("es");
+  });
+
+  test("empty finals carrying language tags do not vote", async () => {
+    // Silence frames can carry container-level tags describing no emitted
+    // words; they must not outvote the language of real speech.
+    const transcriber = new MockStreamingTranscriber();
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(new Uint8Array([1]));
+    transcriber.emit({ type: "final", text: "", languages: ["es"] });
+    transcriber.emit({ type: "final", text: "", languages: ["es"] });
+    transcriber.emit({ type: "final", text: "hello there", languages: ["en"] });
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => ttsCalls.length >= 1);
+
+    expect(ttsCalls[0]?.language).toBe("en");
+  });
+
+  test("only each final's dominant language votes", async () => {
+    // `languages` is dominance-ranked per event: a Spanish-dominant segment
+    // tagged ["es", "en"] plus a short English segment tagged ["en"] must
+    // resolve to Spanish (one vote each, tie broken by first appearance),
+    // not English by counting the secondary tag as a full vote.
+    const transcriber = new MockStreamingTranscriber();
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(new Uint8Array([1]));
+    transcriber.emit({
+      type: "final",
+      text: "hola amigo como estas hoy",
+      languages: ["es", "en"],
+    });
+    transcriber.emit({ type: "final", text: "ok", languages: ["en"] });
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => ttsCalls.length >= 1);
+
+    expect(ttsCalls[0]?.language).toBe("es");
+  });
+
+  test("a tagged final outranks an earlier tagged partial", async () => {
+    const transcriber = new MockStreamingTranscriber();
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(new Uint8Array([1]));
+    transcriber.emit({ type: "partial", text: "hola", languages: ["es"] });
+    transcriber.emit({ type: "final", text: "नमस्ते", languages: ["hi"] });
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => ttsCalls.length >= 1);
+
+    expect(ttsCalls[0]?.language).toBe("hi");
+  });
+
+  test("a monolingual services.stt.language pin is the turn language when finals carry no tags", async () => {
+    const originalRaw = loadRawConfig();
+    const rawServices = (originalRaw.services ?? {}) as Record<string, unknown>;
+    saveRawConfig({
+      ...originalRaw,
+      services: {
+        ...rawServices,
+        stt: {
+          ...((rawServices.stt ?? {}) as Record<string, unknown>),
+          language: "ja",
+        },
+      },
+    });
+    const transcriber = new MockStreamingTranscriber();
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    try {
+      await session.start();
+      await session.handleBinaryAudio(new Uint8Array([1]));
+      await session.handleClientFrame({ type: "ptt_release" });
+      await waitFor(() => ttsCalls.length >= 1);
+
+      expect(ttsCalls[0]?.language).toBe("ja");
+      expect(startVoiceTurn.mock.calls[0]?.[0]?.voiceControlPrompt).toContain(
+        'speaking the language with code "ja"',
+      );
+    } finally {
+      await session.close("websocket_close");
+      saveRawConfig(originalRaw);
+    }
+  });
+
+  test("a pin on an auto-detecting provider does not become the turn language", async () => {
+    // google-gemini and openai-whisper ignore services.stt.language, so a
+    // stale persisted pin must not force every turn into that language.
+    const originalRaw = loadRawConfig();
+    const rawServices = (originalRaw.services ?? {}) as Record<string, unknown>;
+    saveRawConfig({
+      ...originalRaw,
+      services: {
+        ...rawServices,
+        stt: {
+          ...((rawServices.stt ?? {}) as Record<string, unknown>),
+          provider: "google-gemini",
+          language: "es",
+        },
+      },
+    });
+    const transcriber = new MockStreamingTranscriber("google-gemini");
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    try {
+      await session.start();
+      await session.handleBinaryAudio(new Uint8Array([1]));
+      await session.handleClientFrame({ type: "ptt_release" });
+      await waitFor(() => ttsCalls.length >= 1);
+
+      expect(ttsCalls[0] && "language" in ttsCalls[0]).toBe(false);
+    } finally {
+      await session.close("websocket_close");
+      saveRawConfig(originalRaw);
+    }
+  });
+
+  test("the pin gate follows the dialed provider, not the configured one", async () => {
+    // A BYOK gemini config without credentials silently dials the managed
+    // vellum transcriber, which DOES honor the pin; the gate must follow
+    // what was dialed, not what was configured.
+    const originalRaw = loadRawConfig();
+    const rawServices = (originalRaw.services ?? {}) as Record<string, unknown>;
+    saveRawConfig({
+      ...originalRaw,
+      services: {
+        ...rawServices,
+        stt: {
+          ...((rawServices.stt ?? {}) as Record<string, unknown>),
+          provider: "google-gemini",
+          language: "es",
+        },
+      },
+    });
+    const transcriber = new MockStreamingTranscriber("vellum");
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    try {
+      await session.start();
+      await session.handleBinaryAudio(new Uint8Array([1]));
+      await session.handleClientFrame({ type: "ptt_release" });
+      await waitFor(() => ttsCalls.length >= 1);
+
+      expect(ttsCalls[0]?.language).toBe("es");
+    } finally {
+      await session.close("websocket_close");
+      saveRawConfig(originalRaw);
+    }
+  });
+
+  test('the default "multi" with tag-less finals leaves every language-aware path untouched', async () => {
+    const transcriber = new MockStreamingTranscriber();
+    const startVoiceTurn = speakingVoiceTurnStarter();
+    const { streamTtsAudio, ttsCalls } = recordingTtsStreamer();
+    const { context } = createContext();
+    const session = new LiveVoiceSession(context, {
+      resolveTranscriber: mock(async () => transcriber),
+      startVoiceTurn,
+      streamTtsAudio,
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(new Uint8Array([1]));
+    await session.handleClientFrame({ type: "ptt_release" });
+    await waitFor(() => ttsCalls.length >= 1);
+
+    // With the language unknown the TTS request carries no language key at
+    // all and the control prompt has no per-turn language note: byte-for-byte
+    // the language-blind behavior.
+    expect("language" in ttsCalls[0]!).toBe(false);
+    expect(startVoiceTurn.mock.calls[0]?.[0]?.voiceControlPrompt).not.toContain(
+      "language with code",
+    );
+  });
+
   test("uses the production streaming transcriber resolver by default", () => {
     const source = readFileSync(
       new URL("../live-voice-session.ts", import.meta.url),

package/src/live-voice/__tests__/live-voice-triage-escalate.test.ts

@@ -1,9 +1,11 @@
 import { describe, expect, mock, test } from "bun:test";
 
+import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import type { VoiceTurnOptions } from "../../calls/voice-session-bridge.js";
 import {
   ESCALATION_CONTINUATION_CONTENT,
   FALLBACK_ESCALATION_BRIDGE,
+  FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
 } from "../../calls/voice-triage-escalate.js";
 import type {
   StreamingTranscriber,
@@ -11,9 +13,11 @@ import type {
 } from "../../stt/types.js";
 import {
   LiveVoiceSession,
+  type LiveVoiceTtsStreamer,
   type LiveVoiceTurnStarter,
 } from "../live-voice-session.js";
 import type { LiveVoiceSessionFactoryContext } from "../live-voice-session-manager.js";
+import type { LiveVoiceTtsOptions } from "../live-voice-tts.js";
 import {
   createLiveVoiceServerFrameSequencer,
   type LiveVoiceClientStartFrame,
@@ -57,7 +61,13 @@ class MockStreamingTranscriber implements StreamingTranscriber {
   }
 }
 
-function createHarness(startVoiceTurn: LiveVoiceTurnStarter) {
+function createHarness(
+  startVoiceTurn: LiveVoiceTurnStarter,
+  opts: {
+    transcriber?: MockStreamingTranscriber;
+    streamTtsAudio?: LiveVoiceTtsStreamer;
+  } = {},
+) {
   const sequencer = createLiveVoiceServerFrameSequencer();
   const frames: LiveVoiceServerFrame[] = [];
   const context: LiveVoiceSessionFactoryContext = {
@@ -69,10 +79,11 @@ function createHarness(startVoiceTurn: LiveVoiceTurnStarter) {
       return frame;
     }),
   };
-  const transcriber = new MockStreamingTranscriber();
+  const transcriber = opts.transcriber ?? new MockStreamingTranscriber();
   const session = new LiveVoiceSession(context, {
     resolveTranscriber: mock(async () => transcriber),
     startVoiceTurn,
+    ...(opts.streamTtsAudio ? { streamTtsAudio: opts.streamTtsAudio } : {}),
     createTurnId: () => "live-turn-1",
     emitMetrics: false,
   });
@@ -313,6 +324,95 @@ describe("live-voice triage-and-escalate routing", () => {
     expect(spokenText(frames)).not.toContain(FALLBACK_ESCALATION_BRIDGE);
   });
 
+  test("escalating a Hindi turn speaks the Hindi fallback bridge and quotes it to the escalated leg", async () => {
+    const { starter } = scriptedStartVoiceTurn({
+      frontDoor: ["[1]"],
+      escalated: ["तैयार उत्तर।"],
+    });
+    const ttsCalls: LiveVoiceTtsOptions[] = [];
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      ttsCalls.push(options);
+      return {
+        provider: "fish-audio" as const,
+        contentType: "audio/pcm",
+        sampleRate: 24_000,
+        chunks: 0,
+        bytes: 0,
+      };
+    });
+    const { frames, session } = createHarness(starter, {
+      transcriber: new MockStreamingTranscriber([
+        { type: "final", text: "नमस्ते", languages: ["hi"] },
+        { type: "closed" },
+      ]),
+      streamTtsAudio,
+    });
+
+    await driveTurn(session);
+    await waitFor(() => starter.mock.calls.length >= 2);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    const hindiBridge = FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.hi!;
+    // The escalated leg is told the exact phrase the caller heard, so its
+    // continuation rule can quote it and ban a re-announcing echo.
+    expect(starter.mock.calls[1]?.[0]?.spokenEscalationBridge).toBe(
+      hindiBridge,
+    );
+    // The caller hears the Hindi fallback; like every canned bridge it is
+    // audio-only, so it reaches TTS but never a caption frame.
+    expect(ttsCalls.map((call) => call.text)).toContain(
+      sanitizeForTts(hindiBridge).trim(),
+    );
+    expect(spokenText(frames)).not.toContain(hindiBridge);
+    // The detected language rides every synthesis request of the turn.
+    expect(ttsCalls.every((call) => call.language === "hi")).toBe(true);
+  });
+
+  test("escalating an out-of-roster-language turn hints the English fallback bridge as 'en'", async () => {
+    // "ar" is outside the localized bridge table, so the canned fallback is
+    // English text; its synthesis request must carry an "en" hint rather
+    // than the turn's "ar", while the escalated leg's model speech keeps
+    // the turn language.
+    const { starter } = scriptedStartVoiceTurn({
+      frontDoor: ["[1]"],
+      escalated: ["The thorough answer."],
+    });
+    const ttsCalls: LiveVoiceTtsOptions[] = [];
+    const streamTtsAudio = mock(async (options: LiveVoiceTtsOptions) => {
+      ttsCalls.push(options);
+      return {
+        provider: "fish-audio" as const,
+        contentType: "audio/pcm",
+        sampleRate: 24_000,
+        chunks: 0,
+        bytes: 0,
+      };
+    });
+    const { frames, session } = createHarness(starter, {
+      transcriber: new MockStreamingTranscriber([
+        { type: "final", text: "مرحبا", languages: ["ar"] },
+        { type: "closed" },
+      ]),
+      streamTtsAudio,
+    });
+
+    await driveTurn(session);
+    await waitFor(() => starter.mock.calls.length >= 2);
+    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
+
+    expect(starter.mock.calls[1]?.[0]?.spokenEscalationBridge).toBe(
+      FALLBACK_ESCALATION_BRIDGE,
+    );
+    const bridgeCall = ttsCalls.find(
+      (call) => call.text === sanitizeForTts(FALLBACK_ESCALATION_BRIDGE).trim(),
+    );
+    expect(bridgeCall?.language).toBe("en");
+    const answerCall = ttsCalls.find((call) =>
+      call.text.includes("The thorough answer"),
+    );
+    expect(answerCall?.language).toBe("ar");
+  });
+
   test("barge-in during the escalated leg aborts it", async () => {
     const { starter, escalatedAbort } = scriptedStartVoiceTurn({
       frontDoor: ["[1] ", "Let me think about that."],

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

@@ -24,8 +24,11 @@ mock.module("../../security/secure-keys.js", () => ({
   getProviderKeyAsync: async () => "test-api-key",
 }));
 
-const { LiveVoiceTtsError, streamLiveVoiceTtsAudio } =
-  await import("../live-voice-tts.js");
+const {
+  LiveVoiceTtsError,
+  resolveLanguageVoiceOverride,
+  streamLiveVoiceTtsAudio,
+} = await import("../live-voice-tts.js");
 
 beforeEach(() => {
   config = makeConfig();
@@ -494,6 +497,76 @@ describe("streamLiveVoiceTtsAudio", () => {
     }
   });
 
+  test("applies the configured per-language voice for a language-known turn", async () => {
+    config = makeConfig({
+      provider: "elevenlabs",
+      elevenlabsLanguageVoices: { hi: "voice-hindi", ja: "voice-japanese" },
+    });
+    const { requests, probeRequests } = installCapturingElevenLabsStub();
+
+    await streamLiveVoiceTtsAudio({
+      config,
+      text: "namaste",
+      language: "hi",
+      onAudioChunk: () => {},
+    });
+
+    expect(requests[0]?.voiceId).toBe("voice-hindi");
+    expect(probeRequests[0]?.voiceId).toBe("voice-hindi");
+  });
+
+  test("skips the override when the map has no entry for the turn language", async () => {
+    config = makeConfig({
+      provider: "elevenlabs",
+      elevenlabsLanguageVoices: { hi: "voice-hindi" },
+    });
+    const { requests } = installCapturingElevenLabsStub();
+
+    await streamLiveVoiceTtsAudio({
+      config,
+      text: "hola",
+      language: "es",
+      onAudioChunk: () => {},
+    });
+
+    expect(requests[0]?.voiceId).toBeUndefined();
+  });
+
+  test("an explicit request voiceId outranks the per-language map", async () => {
+    config = makeConfig({
+      provider: "elevenlabs",
+      elevenlabsLanguageVoices: { hi: "voice-hindi" },
+    });
+    const { requests, probeRequests } = installCapturingElevenLabsStub();
+
+    await streamLiveVoiceTtsAudio({
+      config,
+      text: "namaste",
+      language: "hi",
+      voiceId: "voice-explicit",
+      onAudioChunk: () => {},
+    });
+
+    expect(requests[0]?.voiceId).toBe("voice-explicit");
+    expect(probeRequests[0]?.voiceId).toBe("voice-explicit");
+  });
+
+  test("performs no lookup when the turn has no language", async () => {
+    config = makeConfig({
+      provider: "elevenlabs",
+      elevenlabsLanguageVoices: { hi: "voice-hindi" },
+    });
+    const { requests } = installCapturingElevenLabsStub();
+
+    await streamLiveVoiceTtsAudio({
+      config,
+      text: "hello",
+      onAudioChunk: () => {},
+    });
+
+    expect(requests[0]?.voiceId).toBeUndefined();
+  });
+
   test("keeps live voice TTS behind the registry instead of direct provider SDKs", () => {
     const source = readFileSync(
       new URL("../live-voice-tts.ts", import.meta.url),
@@ -508,11 +581,83 @@ describe("streamLiveVoiceTtsAudio", () => {
   });
 });
 
+describe("resolveLanguageVoiceOverride", () => {
+  test("keys the lookup by the language's lowercase base subtag", () => {
+    const map = { hi: "voice-hindi" };
+    expect(resolveLanguageVoiceOverride(map, "hi")).toBe("voice-hindi");
+    expect(resolveLanguageVoiceOverride(map, "hi-IN")).toBe("voice-hindi");
+    expect(resolveLanguageVoiceOverride(map, "HI")).toBe("voice-hindi");
+  });
+
+  test("returns undefined without a language", () => {
+    expect(
+      resolveLanguageVoiceOverride({ hi: "voice-hindi" }, undefined),
+    ).toBeUndefined();
+    expect(
+      resolveLanguageVoiceOverride({ hi: "voice-hindi" }, ""),
+    ).toBeUndefined();
+  });
+
+  test("returns undefined for a missing map, a missing entry, or a blank voice", () => {
+    expect(resolveLanguageVoiceOverride(undefined, "hi")).toBeUndefined();
+    expect(
+      resolveLanguageVoiceOverride({ ja: "voice-japanese" }, "hi"),
+    ).toBeUndefined();
+    expect(resolveLanguageVoiceOverride({ hi: "  " }, "hi")).toBeUndefined();
+    expect(resolveLanguageVoiceOverride({}, "constructor")).toBeUndefined();
+  });
+
+  test("trims the resolved voice identifier", () => {
+    expect(resolveLanguageVoiceOverride({ hi: " voice-hindi " }, "hi")).toBe(
+      "voice-hindi",
+    );
+  });
+});
+
+/**
+ * Install an ElevenLabs-id streaming stub that records the sample-rate probe
+ * and synthesis requests.
+ */
+function installCapturingElevenLabsStub(): {
+  requests: TtsSynthesisRequest[];
+  probeRequests: TtsSynthesisRequest[];
+} {
+  const requests: TtsSynthesisRequest[] = [];
+  const probeRequests: TtsSynthesisRequest[] = [];
+  _setTtsProviderForTests({
+    id: "elevenlabs",
+    capabilities: {
+      supportsStreaming: true,
+      supportedFormats: ["mp3", "pcm"],
+    },
+    resolveOutputSampleRateHz: (request) => {
+      probeRequests.push(request);
+      return 24_000;
+    },
+    async synthesize(): Promise<TtsSynthesisResult> {
+      throw new Error("buffered synthesis should not be used");
+    },
+    async synthesizeStream(
+      request: TtsSynthesisRequest,
+      onChunk: (chunk: Uint8Array) => void,
+    ): Promise<TtsSynthesisResult> {
+      requests.push(request);
+      onChunk(Buffer.from("pcm-one!"));
+      return {
+        audio: Buffer.from("pcm-one!"),
+        contentType: "audio/pcm",
+      };
+    },
+  });
+  return { requests, probeRequests };
+}
+
 function makeConfig(
   overrides: {
     provider?: string;
     format?: "mp3" | "wav" | "opus";
     sampleRate?: number;
+    elevenlabsLanguageVoices?: Record<string, string>;
   } = {},
 ): LiveVoiceTtsConfig {
   return {
@@ -535,6 +680,7 @@ function makeConfig(
             stability: 0.5,
             similarityBoost: 0.75,
             conversationTimeoutSeconds: 30,
+            languageVoices: overrides.elevenlabsLanguageVoices,
           },
           deepgram: {
             model: "aura-asteria-en",