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

package/src/__tests__/trusted-contact-inline-approval-integration.test.ts

@@ -170,6 +170,7 @@ mock.module("../channels/gateway-guardian-requests.js", () => sim.module);
 import { applyGuardianDecision } from "../approvals/guardian-decision-primitive.js";
 import type { ActorContext } from "../approvals/guardian-request-resolvers.js";
 import { getResolver } from "../approvals/guardian-request-resolvers.js";
+import { getConfig } from "../config/loader.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
@@ -177,12 +178,14 @@ import { scopedApprovalGrants } from "../persistence/schema/index.js";
 import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-request-guardian-bridge.js";
 import { resolveRoutingState } from "../runtime/trust-context-resolver.js";
 import {
+  resolveInlineGrantWaitMs,
   TC_GRANT_WAIT_MAX_MS,
   ToolApprovalHandler,
   waitForInlineGrant,
 } from "../tools/tool-approval-handler.js";
 import type { ToolContext } from "../tools/types.js";
 import { seedContactChannel } from "./helpers/seed-contact-channel.js";
+import { setConfig } from "./helpers/set-config.js";
 
 await initializeDb();
 
@@ -754,7 +757,10 @@ describe("(f) timeout/stale flow: stale guardian decision after inline wait time
   test("inline_wait_active staleness guard: expired marker allows retry notification", async () => {
     // Create a guardian request with a stale inline_wait_active marker
     // that simulates a daemon crash during the wait.
-    const staleTimestamp = Date.now() - TC_GRANT_WAIT_MAX_MS - 60_000;
+    // Age the marker past the real wait budget, which the resolver's
+    // staleness threshold tracks. Deriving it from the same helper the
+    // waiter uses keeps this case meaningful if the budget changes.
+    const staleTimestamp = Date.now() - resolveInlineGrantWaitMs() - 60_000;
     const req = sim.seedRequest({
       id: `req-stale-${Date.now()}`,
       kind: "tool_grant_request",
@@ -802,6 +808,67 @@ describe("(f) timeout/stale flow: stale guardian decision after inline wait time
     expect(retryNotifications.length).toBeGreaterThan(0);
   });
 
+  test("inline_wait_active marker older than the fallback constant but inside the real budget still suppresses retry", async () => {
+    // The staleness threshold must track the wait budget, not the fallback
+    // constant. A marker aged past TC_GRANT_WAIT_MAX_MS + buffer but still
+    // well inside the configured budget belongs to a waiter that is very
+    // much alive: telling the requester to retry would race a call that is
+    // about to resume, and the retry then fails against the one-time grant
+    // the live waiter consumes.
+    const priorTimeouts = getConfig().timeouts;
+    // Seed the budget rather than leaning on the ambient default, so the
+    // window this case probes exists no matter what the suite's config holds.
+    setConfig("timeouts", { ...priorTimeouts, permissionTimeoutSec: 300 });
+    try {
+      const budgetMs = resolveInlineGrantWaitMs();
+      // Comfortably past the old 90s threshold, comfortably short of the budget.
+      const markerAgeMs = TC_GRANT_WAIT_MAX_MS + 45_000;
+      const liveTimestamp = Date.now() - markerAgeMs;
+      expect(markerAgeMs).toBeLessThan(budgetMs);
+
+      const req = sim.seedRequest({
+        id: `req-live-${Date.now()}`,
+        kind: "tool_grant_request",
+        sourceType: "channel",
+        sourceChannel: "telegram",
+        sourceConversationId: "conv-live-1",
+        requesterExternalUserId: "requester-1",
+        requesterChatId: "requester-chat-1",
+        guardianExternalUserId: "guardian-1",
+        guardianPrincipalId: "test-principal-id",
+        toolName: "bash",
+        inputDigest: "sha256:livewait",
+        expiresAt: Date.now() + 60_000,
+      });
+
+      await sim.module.updateGuardianRequest(req.id, {
+        followupState: `inline_wait_active:${liveTimestamp}`,
+      });
+
+      deliveredReplies.length = 0;
+      const approvalResult = await applyGuardianDecision({
+        requestId: req.id,
+        action: "approve_once",
+        actorContext: guardianActor(),
+        channelDeliveryContext: {
+          replyCallbackUrl: "http://localhost:3000/reply",
+          guardianChatId: "guardian-chat-1",
+          assistantId: "self",
+        },
+      });
+      expect(approvalResult.applied).toBe(true);
+
+      const retryNotifications = deliveredReplies.filter(
+        (r) =>
+          typeof r.payload.text === "string" &&
+          (r.payload.text as string).includes("Please retry"),
+      );
+      expect(retryNotifications.length).toBe(0);
+    } finally {
+      setConfig("timeouts", priorTimeouts);
+    }
+  });
+
   test("fresh inline_wait_active marker suppresses retry notification", async () => {
     // Create a request with a FRESH inline_wait_active marker
     const freshTimestamp = Date.now();

package/src/approvals/guardian-request-resolvers.ts

@@ -54,7 +54,7 @@ import {
   readBatchMetadata,
   resolvePendingQuestion,
 } from "../runtime/question-resolution.js";
-import { TC_GRANT_WAIT_MAX_MS } from "../tools/tool-approval-handler.js";
+import { resolveInlineGrantWaitMs } from "../tools/tool-approval-handler.js";
 import { getLogger } from "../util/logger.js";
 import {
   channelCanAddressOneReaderInBand,
@@ -1587,7 +1587,10 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
     // outlive the actual waiter if the daemon crashes or restarts during
     // the wait. To avoid permanently suppressing the retry notification, we
     // treat the marker as stale if the encoded start timestamp is older than
-    // the maximum wait budget plus a 30s buffer.
+    // the maximum wait budget plus a 30s buffer. The budget is read from the
+    // same resolver the waiter itself uses, so a config change moves both
+    // together; sizing this off a constant would let it fall below the real
+    // wait and declare a live waiter dead.
     const INLINE_WAIT_STALENESS_BUFFER_MS = 30_000;
     const freshRequest = await getGuardianRequestOrNull(request.id);
     const followupState = freshRequest?.followupState ?? "";
@@ -1604,7 +1607,7 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
         ? Date.now() - waitStartMs
         : Infinity; // Treat unparseable timestamps as stale for safety.
       const stalenessThresholdMs =
-        TC_GRANT_WAIT_MAX_MS + INLINE_WAIT_STALENESS_BUFFER_MS;
+        resolveInlineGrantWaitMs() + INLINE_WAIT_STALENESS_BUFFER_MS;
       if (markerAgeMs > stalenessThresholdMs) {
         log.warn(
           {

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());
   }
 }

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.