@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

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,
@@ -380,6 +381,56 @@ describe("startVoiceTurn escalation-continuation persistence", () => {
       voiceSessionTurn: true,
     });
   });
+
+  test("a live-voice turn persists its session attribution under metadata.client", async () => {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      voiceTelemetry: { sessionId: "session-123", client: "ios" },
+    });
+
+    // `turn-events-store` projects `$.client` onto `TurnTelemetryEvent.client`,
+    // so this bag is what makes a voice turn countable per client and joinable
+    // to its session's funnel rows. The platform goes in `os`, the same key
+    // the HTTP send path fills, so voice turns sit in the column existing turn
+    // analytics already read.
+    expect(fake.lastPersistOpts()?.metadata).toEqual({
+      voiceSessionTurn: true,
+      client: {
+        voice: true,
+        voice_session_id: "session-123",
+        os: "ios",
+      },
+    });
+  });
+
+  test("omits the client key when the session reported no originating client", async () => {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      voiceTelemetry: { sessionId: "session-123" },
+    });
+
+    expect(fake.lastPersistOpts()?.metadata).toEqual({
+      voiceSessionTurn: true,
+      client: { voice: true, voice_session_id: "session-123" },
+    });
+  });
+
+  test("a phone turn carries no client bag", async () => {
+    const fake = makeFakeConversation({ processing: false });
+    fakeConversation = fake.conversation;
+
+    await startVoiceTurn(makeTurnOptions());
+
+    // Only live-voice sessions pass `voiceTelemetry`; a phone call has no
+    // live-voice session id to attribute a turn to.
+    expect(fake.lastPersistOpts()?.metadata).not.toHaveProperty("client");
+  });
 });
 
 describe("startVoiceTurn hiddenSyntheticPrompt", () => {
@@ -448,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.
@@ -455,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({
@@ -510,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());
   }
 }

package/src/calls/call-speech-output.ts

@@ -68,8 +68,10 @@ export async function speakSystemPrompt(
     });
 
   if (!useSynthesizedPath || !provider) {
-    // Native path — send text tokens through the transport.
-    relay.sendTextToken(text, true);
+    // Native path: send text tokens through the transport. Marked as
+    // system copy so transports that re-synthesize tokens (media-stream)
+    // never attach the caller-language hint to these fixed English prompts.
+    relay.sendTextToken(text, true, { systemCopy: true });
     return;
   }
 
@@ -128,6 +130,11 @@ async function synthesizeAndPlay(
       },
     });
 
+    // No language hint: this path speaks fixed English copy (verification
+    // codes, guardian prompts), so a pin-based hint would tell an
+    // enforcing provider to render English text in the pinned language.
+    // Conversational synthesis (call-controller, media-stream-output)
+    // carries the hint instead.
     const result = await synthesizeAndEmit({
       provider,
       text,
@@ -258,8 +265,9 @@ async function synthesizeAndPlay(
     // Fallback: send text via native TTS so the caller still hears the message.
     // sendTextToken with last:true includes the end-of-turn signal inherently.
     // This fallback is only used for providers whose catalog entry allows
-    // native fallback.
-    relay.sendTextToken(text, true);
+    // native fallback. Marked as system copy for the same reason as the
+    // native path above.
+    relay.sendTextToken(text, true, { systemCopy: true });
   } finally {
     sink?.finalize();
   }

package/src/calls/call-transport.ts

@@ -9,6 +9,19 @@
 
 // ── Transport interface ──────────────────────────────────────────────
 
+/** Options for {@link CallTransport.sendTextToken}. */
+export interface SendTextTokenOptions {
+  /**
+   * The token is fixed, known-English system copy (error recovery, silence
+   * checks, duration warnings, deterministic prompts) rather than
+   * model-generated turn text. Transports that synthesize text themselves
+   * must not attach the caller-language hint to these tokens: a provider
+   * that enforces the hint would render the English words as though they
+   * were the caller's language. Model text keeps the hint.
+   */
+  systemCopy?: boolean;
+}
+
 /**
  * Minimal output surface that CallController uses to send speech,
  * audio, and lifecycle signals to the caller.
@@ -18,7 +31,11 @@ export interface CallTransport {
    * Send a text token for TTS playback. When `last` is true the
    * transport should signal end-of-turn to the caller.
    */
-  sendTextToken(token: string, last: boolean): void;
+  sendTextToken(
+    token: string,
+    last: boolean,
+    opts?: SendTextTokenOptions,
+  ): void;
 
   /**
    * Send a pre-synthesized audio URL for playback.

package/src/calls/media-stream-output.ts

@@ -41,7 +41,7 @@ import { extractSpeakableSegments } from "../tts/speakable-segments.js";
 import { synthesizeAndEmit } from "../tts/synthesis-stream.js";
 import { getLogger } from "../util/logger.js";
 import type { CallAudioFormat } from "./audio-store.js";
-import type { CallTransport } from "./call-transport.js";
+import type { CallTransport, SendTextTokenOptions } from "./call-transport.js";
 import {
   chunkMulawToBase64Frames,
   MULAW_FRAME_SIZE,
@@ -54,6 +54,10 @@ import type {
   MediaStreamSendMediaCommand,
 } from "./media-stream-protocol.js";
 import { resolveCallTtsProvider } from "./resolve-call-tts-provider.js";
+import {
+  resolveTelephonyLanguageVoice,
+  resolveTelephonySynthesisLanguage,
+} from "./telephony-synthesis-language.js";
 
 const log = getLogger("media-stream-output");
 
@@ -289,7 +293,7 @@ export type MediaStreamOutputState = "connected" | "closed";
  */
 type PlaybackItem =
   | { type: "frames"; frames: string[] }
-  | { type: "synthesize"; text: string }
+  | { type: "synthesize"; text: string; systemCopy: boolean }
   | { type: "fetch-url"; url: string }
   | { type: "mark"; name: string };
 
@@ -338,6 +342,15 @@ export class MediaStreamOutput implements CallTransport {
    */
   private audioStartCallback: (() => void) | null = null;
 
+  /**
+   * Resolves the language hint passed on synthesis requests. Defaults to
+   * the pin-based resolution; the media-stream server overrides it with
+   * a resolver that consults the STT session's detected dominant
+   * language.
+   */
+  private resolveSynthesisLanguage: () => string | undefined = () =>
+    resolveTelephonySynthesisLanguage();
+
   /** Incremented per end-of-turn mark enqueued. */
   private enqueuedEndOfTurnSeq = 0;
 
@@ -373,8 +386,16 @@ export class MediaStreamOutput implements CallTransport {
    * An empty token with `last: true` signals end-of-turn without TTS:
    * a mark is sent so the session transitions from "assistant speaking"
    * to "caller speaking".
+   *
+   * `opts.systemCopy` marks fixed English system copy: its segments
+   * synthesize without the caller-language hint (see
+   * {@link processSynthesizeItem}).
    */
-  sendTextToken(token: string, last: boolean): void {
+  sendTextToken(
+    token: string,
+    last: boolean,
+    opts?: SendTextTokenOptions,
+  ): void {
     if (this.state === "closed") {
       return;
     }
@@ -388,7 +409,11 @@ export class MediaStreamOutput implements CallTransport {
     );
     this.textBuffer = remainder;
     for (const segment of segments) {
-      this.enqueuePlayback({ type: "synthesize", text: segment });
+      this.enqueuePlayback({
+        type: "synthesize",
+        text: segment,
+        systemCopy: opts?.systemCopy === true,
+      });
       this.turnSegmentEnqueued = true;
     }
 
@@ -427,6 +452,14 @@ export class MediaStreamOutput implements CallTransport {
     this.audioStartCallback = cb;
   }
 
+  /**
+   * Override the synthesis-language resolver (see
+   * {@link resolveSynthesisLanguage}).
+   */
+  setSynthesisLanguageResolver(resolver: () => string | undefined): void {
+    this.resolveSynthesisLanguage = resolver;
+  }
+
   /**
    * Discard accumulated text that has not yet been queued for synthesis.
    * The call controller invokes this when it aborts an in-flight turn so
@@ -778,7 +811,9 @@ export class MediaStreamOutput implements CallTransport {
             break;
 
           case "synthesize":
-            await this.processSynthesizeItem(item.text, version);
+            await this.processSynthesizeItem(item.text, version, {
+              systemCopy: item.systemCopy,
+            });
             break;
 
           case "fetch-url":
@@ -827,10 +862,17 @@ export class MediaStreamOutput implements CallTransport {
    * each streamed chunk becomes frames as it arrives — while other
    * providers accumulate into the whole-buffer conversion path. Falls
    * back to a silent frame if synthesis fails.
+   *
+   * `systemCopy` items are fixed English copy: they synthesize without a
+   * language hint (and therefore without a per-language voice override),
+   * so an enforcing provider never renders English text in the caller's
+   * language (same exemption as call-speech-output's synthesized path).
+   * Model text keeps the resolver's hint.
    */
   private async processSynthesizeItem(
     text: string,
     version: number,
+    { systemCopy }: { systemCopy: boolean },
   ): Promise<void> {
     const abortController = new AbortController();
     this.activePlaybackAbort = abortController;
@@ -876,12 +918,18 @@ export class MediaStreamOutput implements CallTransport {
       // Providers that support it (e.g. ElevenLabs pcm_16000) will
       // return raw PCM; others fall back to their default format and
       // the content-type sniffing below handles the mismatch.
+      const language = systemCopy ? undefined : 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);
       const result = await synthesizeAndEmit({
         provider,
         text,
         useCase: "phone-call",
         outputFormat: "pcm",
         sampleRateHz: STREAMING_PCM_SAMPLE_RATE_HZ,
+        ...(voiceId !== undefined ? { voiceId } : {}),
+        ...(language !== undefined ? { language } : {}),
         signal: abortController.signal,
         isCurrent,
         onChunk: (chunk) => {