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

package/src/__tests__/media-stream-output.test.ts

@@ -26,6 +26,7 @@ import {
 } from "../calls/media-stream-audio-transcode.js";
 import { MediaStreamOutput } from "../calls/media-stream-output.js";
 import { resolveCallTtsProvider } from "../calls/resolve-call-tts-provider.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const mockResolveCallTtsProvider = resolveCallTtsProvider as ReturnType<
   typeof jest.fn
@@ -1213,6 +1214,180 @@ describe("MediaStreamOutput", () => {
     });
   });
 
+  // ---------------------------------------------------------------------------
+  // Synthesis language hint
+  // ---------------------------------------------------------------------------
+
+  describe("synthesis language hint", () => {
+    /** Synthesize one turn and return the provider request it produced. */
+    async function synthesizeOneTurn(
+      output: MediaStreamOutput,
+    ): Promise<{ language?: string }> {
+      mockSynthesize.mockResolvedValue({
+        audio: makeWavBuffer([1000, 2000, 3000, 4000]),
+        contentType: "audio/wav",
+      });
+      output.sendTextToken("Hello caller.", true);
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+      return mockSynthesize.mock.calls[0][0] as { language?: string };
+    }
+
+    test("the resolver's language rides the provider request", async () => {
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-lang");
+      output.setSynthesisLanguageResolver(() => "es");
+
+      const request = await synthesizeOneTurn(output);
+
+      expect(request.language).toBe("es");
+    });
+
+    test("fixed system copy synthesizes without the caller-language hint while model text keeps it", async () => {
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-lang");
+      output.setSynthesisLanguageResolver(() => "ja");
+      mockSynthesize.mockResolvedValue({
+        audio: makeWavBuffer([1000, 2000, 3000, 4000]),
+        contentType: "audio/wav",
+      });
+
+      output.sendTextToken("Model reply.", true);
+      output.sendTextToken("Are you still there?", true, { systemCopy: true });
+      await drain(() => mockSynthesize.mock.calls.length >= 2);
+
+      const requests = mockSynthesize.mock.calls.map(
+        (call) => call[0] as { text: string; language?: string },
+      );
+      expect(requests[0]?.text).toBe("Model reply.");
+      expect(requests[0]?.language).toBe("ja");
+      expect(requests[1]?.text).toBe("Are you still there?");
+      expect(requests[1]?.language).toBeUndefined();
+    });
+
+    test("no language when nothing resolves (default multilingual pin)", async () => {
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-lang");
+
+      const request = await synthesizeOneTurn(output);
+
+      expect(request.language).toBeUndefined();
+    });
+
+    test("a monolingual pin on a manual-selection provider resolves as the hint", async () => {
+      setConfig("services", {
+        stt: { provider: "deepgram", language: "es-ES" },
+      });
+      try {
+        const { ws } = createMockWs();
+        const output = makeOutput(ws, "stream-lang");
+
+        const request = await synthesizeOneTurn(output);
+
+        expect(request.language).toBe("es");
+      } finally {
+        setConfig("services", {});
+      }
+    });
+
+    test("the pin is ignored for auto-detecting providers", async () => {
+      setConfig("services", {
+        stt: { provider: "openai-whisper", language: "es" },
+      });
+      try {
+        const { ws } = createMockWs();
+        const output = makeOutput(ws, "stream-lang");
+
+        const request = await synthesizeOneTurn(output);
+
+        expect(request.language).toBeUndefined();
+      } finally {
+        setConfig("services", {});
+      }
+    });
+  });
+
+  // ---------------------------------------------------------------------------
+  // Per-language voice override (languageVoices)
+  // ---------------------------------------------------------------------------
+
+  describe("per-language voice override", () => {
+    afterEach(() => {
+      setConfig("services", {});
+    });
+
+    /** Seed a deepgram languageVoices entry and resolve deepgram as the provider. */
+    function useDeepgramWithHindiVoice(): void {
+      setConfig("services", {
+        tts: {
+          provider: "deepgram",
+          providers: {
+            deepgram: { languageVoices: { hi: "aura-2-hindi-voice" } },
+          },
+        },
+      });
+      useProvider({
+        id: "deepgram",
+        capabilities: { supportsStreaming: false, supportedFormats: ["wav"] },
+        synthesize: mockSynthesize,
+      });
+      mockSynthesize.mockResolvedValue({
+        audio: makeWavBuffer([1000, 2000, 3000, 4000]),
+        contentType: "audio/wav",
+      });
+    }
+
+    test("a configured languageVoices entry for the resolved language rides the request as voiceId", async () => {
+      useDeepgramWithHindiVoice();
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-voice");
+      output.setSynthesisLanguageResolver(() => "hi");
+
+      output.sendTextToken("Namaste.", true);
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+
+      const request = mockSynthesize.mock.calls[0][0] as {
+        voiceId?: string;
+        language?: string;
+      };
+      expect(request.language).toBe("hi");
+      expect(request.voiceId).toBe("aura-2-hindi-voice");
+    });
+
+    test("no voiceId when the map has no entry for the resolved language", async () => {
+      useDeepgramWithHindiVoice();
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-voice");
+      output.setSynthesisLanguageResolver(() => "es");
+
+      output.sendTextToken("Hola.", true);
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+
+      const request = mockSynthesize.mock.calls[0][0] as {
+        voiceId?: string;
+        language?: string;
+      };
+      expect(request.language).toBe("es");
+      expect(request.voiceId).toBeUndefined();
+    });
+
+    test("system copy gets neither the language hint nor the language voice", async () => {
+      useDeepgramWithHindiVoice();
+      const { ws } = createMockWs();
+      const output = makeOutput(ws, "stream-voice");
+      output.setSynthesisLanguageResolver(() => "hi");
+
+      output.sendTextToken("Are you still there?", true, { systemCopy: true });
+      await drain(() => mockSynthesize.mock.calls.length > 0);
+
+      const request = mockSynthesize.mock.calls[0][0] as {
+        voiceId?: string;
+        language?: string;
+      };
+      expect(request.language).toBeUndefined();
+      expect(request.voiceId).toBeUndefined();
+    });
+  });
+
   // ---------------------------------------------------------------------------
   // Streaming PCM synthesis (incremental transcode)
   // ---------------------------------------------------------------------------

package/src/__tests__/media-stream-stt-session.test.ts

@@ -897,6 +897,73 @@ describe("MediaStreamSttSession", () => {
       session.dispose();
     });
 
+    // ── Detected language (latest tagged utterance) ─────────────────
+
+    test("a language switch retargets on the first final in the new language", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      expect(session.currentLanguage()).toBeUndefined();
+
+      fake.emit({ type: "final", text: "hola", languages: ["es", "en"] });
+      fake.emit({ type: "final", text: "buenos dias", languages: ["es"] });
+      expect(session.currentLanguage()).toBe("es");
+
+      // The first ja-tagged utterance wins immediately: the caller does
+      // not have to outvote the session's es history. The secondary "es"
+      // tag does not dilute the utterance's dominant tag.
+      fake.emit({ type: "final", text: "konnichiwa", languages: ["ja", "es"] });
+      expect(session.currentLanguage()).toBe("ja");
+
+      session.dispose();
+    });
+
+    test("regional variants normalize to their base subtag", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      fake.emit({ type: "final", text: "tudo bem", languages: ["pt-BR"] });
+
+      expect(session.currentLanguage()).toBe("pt");
+
+      session.dispose();
+    });
+
+    test("empty and untagged finals keep the previous value", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      // A silence final can carry container-level tags describing no
+      // emitted words; it must not update the language.
+      fake.emit({ type: "final", text: "   ", languages: ["fr"] });
+      expect(session.currentLanguage()).toBeUndefined();
+
+      fake.emit({ type: "final", text: "hola", languages: ["es"] });
+      expect(session.currentLanguage()).toBe("es");
+
+      // A committed final without tags keeps the previous value.
+      fake.emit({ type: "final", text: "hello" });
+      expect(session.currentLanguage()).toBe("es");
+
+      // So does a tagged silence final after a language is established.
+      fake.emit({ type: "final", text: "   ", languages: ["fr"] });
+      expect(session.currentLanguage()).toBe("es");
+
+      session.dispose();
+    });
+
+    test("falling back to batch mid-call clears the detected language", async () => {
+      const { session, fake } = await startStreamingSession();
+
+      fake.emit({ type: "final", text: "konnichiwa", languages: ["ja"] });
+      expect(session.currentLanguage()).toBe("ja");
+
+      // Provider closes the stream unexpectedly: the session settles on
+      // batch, whose transcripts carry no language metadata. The stale ja
+      // detection must not keep hinting synthesis for English speech.
+      fake.emit({ type: "closed" });
+      expect(session.currentLanguage()).toBeUndefined();
+
+      session.dispose();
+    });
+
     test("local VAD turn end never triggers batch transcription in streaming mode", async () => {
       const onTranscriptFinal = jest.fn();
       const { session } = await startStreamingSession(

package/src/calls/__tests__/tts-text-sanitizer.test.ts

@@ -98,6 +98,19 @@ describe("sanitizeForTts", () => {
         "use some_function_name here",
       );
     });
+
+    test("strips italic with accented content", () => {
+      expect(sanitizeForTts("Hello *café* there")).toBe("Hello café there");
+    });
+
+    test("strips underscore italic with CJK content", () => {
+      expect(sanitizeForTts("値は _変数_ です")).toBe("値は 変数 です");
+    });
+
+    test("does not strip a span whose marker touches a non-ASCII word char", () => {
+      expect(sanitizeForTts("*強調*です")).toBe("*強調*です");
+      expect(sanitizeForTts("café*note* x")).toBe("café*note* x");
+    });
   });
 
   describe("headers", () => {

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -76,6 +76,7 @@ import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { CALL_OPENING_MARKER } from "../voice-control-protocol.js";
 import {
   cutFrontDoorContentAtVerdict,
+  preSpeechLanguageRuleFragment,
   startVoiceTurn,
   TOOL_RESULT_PREVIEW_MAX_CHARS,
   type VoiceTurnOptions,
@@ -498,6 +499,18 @@ describe("startVoiceTurn hiddenSyntheticPrompt", () => {
   });
 });
 
+// The turn installs its resolved control prompt, then cleanup resets it to
+// null, so capture every applied value and read the installed (non-null) one.
+function captureInstalledPrompt(): () => string | undefined {
+  const fake = makeFakeConversation({ processing: false });
+  fakeConversation = fake.conversation;
+  const applied: Array<string | null> = [];
+  fake.conversation.setVoiceCallControlPrompt = (prompt) => {
+    applied.push(prompt);
+  };
+  return () => applied.find((p): p is string => typeof p === "string");
+}
+
 describe("startVoiceTurn triage-and-escalate control prompt", () => {
   // Live-voice supplies its own voiceControlPrompt, bypassing
   // buildVoiceCallControlPrompt where the routing-leg rule is normally injected.
@@ -505,18 +518,6 @@ describe("startVoiceTurn triage-and-escalate control prompt", () => {
   // verdict protocol and can't hold or hand off.
   const LIVE_VOICE_PROMPT = "You are speaking in a local live voice session.";
 
-  // The turn installs its resolved control prompt, then cleanup resets it to
-  // null — so capture every applied value and read the installed (non-null) one.
-  function captureInstalledPrompt(): () => string | undefined {
-    const fake = makeFakeConversation({ processing: false });
-    fakeConversation = fake.conversation;
-    const applied: Array<string | null> = [];
-    fake.conversation.setVoiceCallControlPrompt = (prompt) => {
-      applied.push(prompt);
-    };
-    return () => applied.find((p): p is string => typeof p === "string");
-  }
-
   test("appends the front-door decision rule to a caller-supplied prompt", async () => {
     const installed = captureInstalledPrompt();
     await startVoiceTurn({
@@ -560,6 +561,74 @@ describe("startVoiceTurn triage-and-escalate control prompt", () => {
   });
 });
 
+describe("default call protocol numbered rules", () => {
+  // With no caller-supplied voiceControlPrompt the bridge builds the numbered
+  // CALL PROTOCOL RULES itself. Pin the speak-the-caller's-language rule and
+  // keep the numbering gapless so no rule silently shadows another.
+  test("teaches speaking the caller's language as its own numbered rule", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn(makeTurnOptions());
+    expect(installed()).toContain(
+      "12. Speak the caller's language: reply in the language of the caller's most recent actual speech, and follow them if they switch languages mid-call. Synthetic user turns (parenthetical markers like the call-connected and verification-completed notices) are not caller speech and never set the language. Before the caller has spoken, such as on the opening greeting turn, use the language the Task context implies, if any; otherwise default to English.",
+    );
+  });
+
+  test("the language rule excludes synthetic turns and covers pre-speech turns", async () => {
+    // Outbound calls open with the English "(call connected ...)" sentinel as
+    // the latest user-role turn, and the verification-complete sentinel does
+    // the same mid-call. Neither is caller speech, so neither may pull a
+    // Spanish or Japanese Task into an English opener.
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn(makeTurnOptions());
+    const prompt = installed()!;
+    expect(prompt).toContain("most recent actual speech");
+    expect(prompt).toContain("not caller speech and never set the language");
+    expect(prompt).toContain(
+      "use the language the Task context implies, if any; otherwise default to English",
+    );
+  });
+
+  test("a monolingual listening language becomes the pre-speech fallback", () => {
+    // An assistant pinned to services.stt.language = "es" on a provider that
+    // honors the pin (deepgram, vellum) is already transcribing Spanish, so
+    // the opener must not default to English. The default test config runs
+    // the auto-detect branch ("multi"), so the pinned branch is covered at
+    // the fragment level.
+    expect(preSpeechLanguageRuleFragment("es", "deepgram")).toContain(
+      'configured listening language ("es")',
+    );
+    expect(preSpeechLanguageRuleFragment("es", "vellum")).toContain(
+      "default to English only when neither gives a language",
+    );
+    for (const autoDetect of ["multi", "", "  ", undefined]) {
+      expect(preSpeechLanguageRuleFragment(autoDetect, "deepgram")).toBe(
+        "use the language the Task context implies, if any; otherwise default to English",
+      );
+    }
+  });
+
+  test("a language pin on an auto-detecting provider keeps the English fallback", () => {
+    // google-gemini and openai-whisper ignore services.stt.language entirely
+    // (languageSelection: "auto"), so a persisted "es" pin must not force a
+    // Spanish greeting the transcriber will not honor.
+    for (const provider of ["google-gemini", "openai-whisper", undefined]) {
+      expect(preSpeechLanguageRuleFragment("es", provider)).toBe(
+        "use the language the Task context implies, if any; otherwise default to English",
+      );
+    }
+  });
+
+  test("rule numbers stay sequential from 0, including the routing rule", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "escalated" });
+    const numbers = [...installed()!.matchAll(/^(\d+)\. /gm)].map((match) =>
+      Number(match[1]),
+    );
+    expect(numbers.length).toBeGreaterThan(12);
+    expect(numbers).toEqual(numbers.map((_, index) => index));
+  });
+});
+
 describe("startVoiceTurn channel capabilities", () => {
   // Whether a call can show a surface is a property of its channel, not of
   // calls in general, so the bridge applies no voice-specific override: a

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

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
+import { DEEPGRAM_MULTI_LANGUAGE_CODES } from "../../providers/speech-to-text/deepgram.js";
 import {
   capEscalationBridge,
   classifyFrontDoorLeading,
@@ -7,6 +8,8 @@ import {
   escalatedContinuationRule,
   ESCALATION_CONTINUATION_CONTENT,
   FALLBACK_ESCALATION_BRIDGE,
+  FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
+  fallbackEscalationBridgeFor,
   frontDoorCapabilityDigest,
   frontDoorDecisionRule,
   HOLD_VERDICT_TOKEN,
@@ -162,6 +165,33 @@ describe("front-door decision rule", () => {
     expect(rule.toLowerCase()).toContain("one short natural holding phrase");
     expect(rule.toLowerCase()).toContain("stop after that single sentence");
   });
+
+  test("hold completeness is judged in the caller's language", () => {
+    // Callers are not English-only: the hold branch's exemplars are English,
+    // so the rule must say completeness follows the grammar of the language
+    // being spoken, with the verb-final case called out (a missing final
+    // verb, not a missing conjunction, is the unfinished signal there).
+    const withHold = frontDoorDecisionRule({ includeHold: true });
+    expect(withHold.toLowerCase()).toContain("may speak any language");
+    expect(withHold.toLowerCase()).toContain(
+      "grammar of the language being spoken",
+    );
+    expect(withHold.toLowerCase()).toContain("verb-final");
+    expect(withHold.toLowerCase()).toContain("missing final verb");
+  });
+
+  test("the answer branch demands the caller's language", () => {
+    expect(rule).toContain("Answer in the language the caller is speaking.");
+  });
+
+  test("the escalation holding phrase demands the caller's language", () => {
+    // The bridge examples are English; without an explicit requirement a
+    // Spanish turn that needs a tool gets an English holding phrase before
+    // the localized answer. The examples stay, labeled as English only.
+    expect(rule).toContain("spoken in the language the caller is speaking");
+    expect(rule).toContain("those examples are English only");
+    expect(rule).toContain(`"${FALLBACK_ESCALATION_BRIDGE}"`);
+  });
 });
 
 describe("escalated continuation rule", () => {
@@ -190,6 +220,12 @@ describe("escalated continuation rule", () => {
     );
   });
 
+  test("demands the reply match the caller's language", () => {
+    expect(rule).toContain(
+      "Reply in the same language as the caller's question.",
+    );
+  });
+
   test("bans re-announcing the holding phrase (bridge-echo regression)", () => {
     // Regression: after the bridge "Let me check your calendar", the quality
     // model opened with "Let me check what calendar connections…" — a
@@ -201,6 +237,41 @@ describe("escalated continuation rule", () => {
   });
 });
 
+describe("fallbackEscalationBridgeFor", () => {
+  test("covers every Deepgram code-switching language with a non-empty bridge", () => {
+    for (const code of DEEPGRAM_MULTI_LANGUAGE_CODES) {
+      const bridge = FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE[code];
+      expect(bridge).toBeDefined();
+      expect(bridge!.trim().length).toBeGreaterThan(0);
+      expect(fallbackEscalationBridgeFor(code)).toBe(bridge!);
+    }
+  });
+
+  test("every bridge fits the session-side cap", () => {
+    for (const bridge of Object.values(
+      FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
+    )) {
+      expect(bridge.length).toBeLessThanOrEqual(MAX_ESCALATION_BRIDGE_CHARS);
+    }
+  });
+
+  test("selects by lowercased base subtag", () => {
+    expect(fallbackEscalationBridgeFor("pt-BR")).toBe(
+      FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.pt!,
+    );
+    expect(fallbackEscalationBridgeFor("JA")).toBe(
+      FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.ja!,
+    );
+  });
+
+  test("falls back to English for unknown or absent languages", () => {
+    expect(fallbackEscalationBridgeFor()).toBe(FALLBACK_ESCALATION_BRIDGE);
+    expect(fallbackEscalationBridgeFor("ko")).toBe(FALLBACK_ESCALATION_BRIDGE);
+    expect(fallbackEscalationBridgeFor("")).toBe(FALLBACK_ESCALATION_BRIDGE);
+    expect(fallbackEscalationBridgeFor("en")).toBe(FALLBACK_ESCALATION_BRIDGE);
+  });
+});
+
 describe("capEscalationBridge", () => {
   test("cuts just after the first sentence terminator", () => {
     expect(
@@ -218,6 +289,24 @@ describe("capEscalationBridge", () => {
   test("strips internal markers before capping", () => {
     expect(capEscalationBridge("[END_CALL] One moment.")).toBe("One moment.");
   });
+
+  test("the Unicode ellipsis still terminates a bridge", () => {
+    // Regression pin: widening the terminator class for non-Latin enders
+    // must not drop the ellipsis the original regex recognized.
+    expect(capEscalationBridge("One moment… and some rambling")).toBe(
+      "One moment…",
+    );
+    expect(isEscalationBridgeComplete("One moment…")).toBe(true);
+  });
+
+  test("cuts just after a non-Latin sentence terminator", () => {
+    expect(capEscalationBridge("少し考えさせてください。その間の余談")).toBe(
+      "少し考えさせてください。",
+    );
+    expect(capEscalationBridge("मुझे एक पल सोचने दीजिए। और कुछ बातें")).toBe(
+      "मुझे एक पल सोचने दीजिए।",
+    );
+  });
 });
 
 describe("isEscalationBridgeComplete", () => {
@@ -233,6 +322,23 @@ describe("isEscalationBridgeComplete", () => {
       isEscalationBridgeComplete("a".repeat(MAX_ESCALATION_BRIDGE_CHARS)),
     ).toBe(true);
   });
+
+  test("a Japanese bridge ending in 。 completes without waiting for the cap", () => {
+    expect(isEscalationBridgeComplete("少し考えさせてください")).toBe(false);
+    expect(isEscalationBridgeComplete("少し考えさせてください。")).toBe(true);
+  });
+
+  test("every localized fallback bridge ends in a recognized terminator", () => {
+    // A model-spoken bridge in any roster language must hand off at its
+    // terminator, never by buffering to the char cap; the canned bridges are
+    // the canonical sample of each language's ender.
+    for (const bridge of Object.values(
+      FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
+    )) {
+      expect(isEscalationBridgeComplete(bridge)).toBe(true);
+      expect(capEscalationBridge(bridge)).toBe(bridge);
+    }
+  });
 });
 
 describe("spokenBridgeText", () => {

package/src/calls/call-controller.ts

@@ -65,6 +65,10 @@ import {
   resolveSynthesisFormats,
 } from "./resolve-call-tts-provider.js";
 import type { PromptSpeakerContext } from "./speaker-identification.js";
+import {
+  resolveTelephonyLanguageVoice,
+  resolveTelephonySynthesisLanguage,
+} from "./telephony-synthesis-language.js";
 import { sanitizeForTts } from "./tts-text-sanitizer.js";
 import {
   ASK_GUARDIAN_CAPTURE_REGEX,
@@ -189,6 +193,13 @@ export class CallController {
   private guardianUnavailableForCall = false;
   /** Active synthesized-TTS session — tracked so interrupt handling can close it. */
   private activeSynthesisAbort: AbortController | null = null;
+  /**
+   * Resolves the language hint for synthesized speech. The media-stream
+   * server supplies a resolver backed by the STT session's detected
+   * dominant language; the default falls back to the pin-based
+   * resolution only.
+   */
+  private resolveSynthesisLanguage: () => string | undefined;
 
   constructor(
     callSessionId: string,
@@ -198,6 +209,7 @@ export class CallController {
       broadcast?: (msg: AssistantEvent) => void;
       assistantId?: string;
       trustContext?: TrustContext;
+      resolveSynthesisLanguage?: () => string | undefined;
     },
   ) {
     this.callSessionId = callSessionId;
@@ -207,6 +219,9 @@ export class CallController {
     this.broadcast = opts?.broadcast;
     this.assistantId = opts?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
     this.trustContext = opts?.trustContext ?? null;
+    this.resolveSynthesisLanguage =
+      opts?.resolveSynthesisLanguage ??
+      (() => resolveTelephonySynthesisLanguage());
 
     // Resolve the conversation ID and skipDisclosure from the call session
     const session = getCallSession(callSessionId);
@@ -663,7 +678,9 @@ export class CallController {
         // lock-hold wait budget, so surface a brief natural re-prompt (never a
         // technical-error message) and re-arm listening. last=true doubles as
         // the end-of-turn marker.
-        this.transport.sendTextToken("Sorry, could you say that again?", true);
+        this.transport.sendTextToken("Sorry, could you say that again?", true, {
+          systemCopy: true,
+        });
         this.state = "idle";
         this.resetSilenceTimer();
         this.flushPendingInstructions();
@@ -673,6 +690,7 @@ export class CallController {
       this.transport.sendTextToken(
         "I'm sorry, I encountered a technical issue. Could you repeat that?",
         true,
+        { systemCopy: true },
       );
       this.state = "idle";
       this.resetSilenceTimer();
@@ -1080,11 +1098,17 @@ export class CallController {
 
       this.activeSynthesisAbort = abortController;
 
+      const language = this.resolveSynthesisLanguage();
+      // A language-known segment may select the synthesizing provider's
+      // configured per-language voice; no entry keeps the provider default.
+      const voiceId = resolveTelephonyLanguageVoice(provider.id, language);
       await synthesizeAndEmit({
         provider,
         text,
         useCase: "phone-call",
         outputFormat,
+        ...(voiceId !== undefined ? { voiceId } : {}),
+        ...(language !== undefined ? { language } : {}),
         signal: abortController.signal,
         isCurrent: () => this.isCurrentRun(runVersion),
         onChunk: sink.onChunk,
@@ -1804,6 +1828,7 @@ export class CallController {
         this.transport.sendTextToken(
           "Just to let you know, we're running low on time for this call.",
           true,
+          { systemCopy: true },
         );
       }, warningMs);
     }
@@ -1816,6 +1841,7 @@ export class CallController {
       this.transport.sendTextToken(
         "I'm sorry, but we've reached the maximum time for this call. Thank you for your time. Goodbye!",
         true,
+        { systemCopy: true },
       );
       // Give TTS a moment to play, then end
       this.durationEndTimer = setTimeout(() => {
@@ -1878,7 +1904,9 @@ export class CallController {
         { callSessionId: this.callSessionId },
         "Silence timeout triggered",
       );
-      this.transport.sendTextToken("Are you still there?", true);
+      this.transport.sendTextToken("Are you still there?", true, {
+        systemCopy: true,
+      });
     }, getSilenceTimeoutMs());
   }
 }