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

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) => {

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

@@ -81,6 +81,7 @@ import {
   type MediaStreamSttSessionCallbacks,
   type MediaStreamSttSessionConfig,
 } from "./media-stream-stt-session.js";
+import { resolveTelephonySynthesisLanguage } from "./telephony-synthesis-language.js";
 import {
   TRUST_UNAVAILABLE_DENY_MESSAGE,
   unresolvedActorTrust,
@@ -192,6 +193,14 @@ export class MediaStreamCallSession {
   /** Number of transcript finals produced (non-empty). */
   private transcriptFinalsProduced = 0;
 
+  /**
+   * Synthesized speech follows the caller's latest detected language when
+   * the transcriber tags finals, falling back to the pin-based
+   * resolution. Shared by the output adapter and the call controller.
+   */
+  private readonly resolveSynthesisLanguage = (): string | undefined =>
+    resolveTelephonySynthesisLanguage(this.sttSession.currentLanguage());
+
   constructor(
     ws: ServerWebSocket<unknown>,
     callSessionId: string,
@@ -216,6 +225,8 @@ export class MediaStreamCallSession {
 
     this.sttSession = new MediaStreamSttSession(sttConfig ?? {}, callbacks);
 
+    this.output.setSynthesisLanguageResolver(this.resolveSynthesisLanguage);
+
     log.info({ callSessionId }, "Media stream call session created");
   }
 
@@ -681,6 +692,7 @@ export class MediaStreamCallSession {
       {
         assistantId: result.assistantId,
         trustContext: result.trustContext,
+        resolveSynthesisLanguage: this.resolveSynthesisLanguage,
       },
     );
     this.controller = controller;

package/src/calls/media-stream-stt-session.ts

@@ -48,6 +48,7 @@ import type {
   SttCallContextHints,
   SttStreamServerEvent,
 } from "../stt/types.js";
+import { baseLanguageSubtag } from "../util/language-subtag.js";
 import { getLogger } from "../util/logger.js";
 import {
   mulawToLinear,
@@ -220,6 +221,20 @@ export class MediaStreamSttSession {
   /** Speech-bearing audio milliseconds since the last streaming final. */
   private utteranceAudioMs = 0;
 
+  /**
+   * The dominant detected-language base subtag of the latest committed
+   * streaming final that carried language tags. Overwritten per
+   * utterance, matching live voice's per-utterance resolution, so a
+   * caller who switches languages retargets synthesis on their next
+   * utterance instead of having to outvote the session's history. Only
+   * finals that carry transcript text update it: silence finals can
+   * carry container-level tags describing no emitted words. Untagged
+   * finals keep the previous value; batch transcription reports no
+   * language tags, so it stays unset there and any streaming-detected
+   * value is cleared when the session settles on batch mode.
+   */
+  private latestUtteranceLanguage: string | undefined;
+
   constructor(
     config: MediaStreamSttSessionConfig = {},
     callbacks: MediaStreamSttSessionCallbacks = {},
@@ -304,6 +319,15 @@ export class MediaStreamSttSession {
     return this.startupFramesDroppedCount;
   }
 
+  /**
+   * The caller's detected language as of the latest tagged streaming
+   * final, as a lowercase base subtag. Undefined until a tagged final
+   * commits (batch mode, non-tagging providers, silence).
+   */
+  currentLanguage(): string | undefined {
+    return this.latestUtteranceLanguage;
+  }
+
   // ── Event handlers ─────────────────────────────────────────────────
 
   private handleStart(event: MediaStreamStartEvent): void {
@@ -477,6 +501,10 @@ export class MediaStreamSttSession {
    */
   private enterBatchMode(): void {
     this.mode = "batch";
+    // Batch transcripts carry no language metadata, so a language detected
+    // while streaming would otherwise hint synthesis for the rest of the
+    // call. Clear it so the configured pin (or no hint) takes over.
+    this.latestUtteranceLanguage = undefined;
     this.startupFrames = [];
     this.capabilityPromise ??= resolveTelephonySttCapability();
 
@@ -515,6 +543,12 @@ export class MediaStreamSttSession {
         this.utteranceAudioMs = 0;
         const text = event.text.trim();
         if (text.length > 0) {
+          // `languages` is dominance-ranked, so the first entry is the
+          // utterance's dominant tag.
+          const dominant = baseLanguageSubtag(event.languages?.[0]);
+          if (dominant !== undefined) {
+            this.latestUtteranceLanguage = dominant;
+          }
           this.callbacks.onTranscriptFinal?.(text, durationMs);
         }
         return;

package/src/calls/telephony-synthesis-language.ts

@@ -0,0 +1,84 @@
+/**
+ * Synthesis-language resolution for telephony TTS.
+ *
+ * The telephony call-control prompt instructs the model to speak the
+ * caller's language; this resolver produces the matching TTS hint so
+ * providers that can enforce a language render the reply in it (the hint
+ * is a no-op for providers that cannot). Resolution mirrors live voice's
+ * per-utterance turn language (live-voice-session.ts): the caller's
+ * latest STT-detected language when the transcriber tags finals, else a
+ * monolingual `services.stt.language` pin when the configured provider
+ * honors manual language selection, else undefined (no hint, provider
+ * default behavior).
+ */
+
+import { getConfig } from "../config/loader.js";
+import type { AssistantConfig } from "../config/types.js";
+import { pinnedListeningLanguage } from "../providers/speech-to-text/provider-catalog.js";
+import { resolveLanguageVoiceOverride } from "../tts/language-voices.js";
+import { resolveTtsConfig } from "../tts/tts-config-resolver.js";
+import type { TtsProviderId } from "../tts/types.js";
+import { baseLanguageSubtag } from "../util/language-subtag.js";
+
+/**
+ * Resolve the language hint for telephony synthesis as a lowercase base
+ * subtag, or undefined when no signal resolves.
+ *
+ * @param detectedLanguage - The caller language the STT session detected
+ *   on its latest tagged utterance, when a session is reachable from the
+ *   call site. Wins over the pin whenever it normalizes to a non-empty
+ *   tag.
+ */
+export function resolveTelephonySynthesisLanguage(
+  detectedLanguage?: string,
+): string | undefined {
+  const detected = baseLanguageSubtag(detectedLanguage);
+  if (detected !== undefined) {
+    return detected;
+  }
+
+  let stt: { provider: string; language?: string };
+  try {
+    stt = getConfig().services.stt;
+  } catch {
+    // Config unavailable (early startup, minimal test workspaces): no hint.
+    return undefined;
+  }
+
+  return pinnedListeningLanguage(stt.provider, stt.language);
+}
+
+/**
+ * Resolve the per-language voice for a telephony synthesis request from
+ * the synthesizing provider's `services.tts.providers.<id>.languageVoices`
+ * map. Keyed by the provider actually synthesizing, which on the
+ * media-stream transport may be a playability fallback rather than the
+ * configured provider, because voice identifiers are provider-specific.
+ * Returns undefined (provider default voice) when the request carries no
+ * language, config is unavailable, or the provider's map has no entry.
+ */
+export function resolveTelephonyLanguageVoice(
+  providerId: string,
+  language: string | undefined,
+): string | undefined {
+  if (language === undefined) {
+    return undefined;
+  }
+
+  let config: AssistantConfig;
+  try {
+    config = getConfig();
+  } catch {
+    // Config unavailable (early startup, minimal test workspaces): no override.
+    return undefined;
+  }
+
+  const { providerConfig } = resolveTtsConfig(
+    config,
+    providerId as TtsProviderId,
+  );
+  return resolveLanguageVoiceOverride(
+    providerConfig.languageVoices as Record<string, string> | undefined,
+    language,
+  );
+}

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

@@ -49,11 +49,18 @@ export function sanitizeForTts(text: string): string {
   result = result.replace(/^[-*]\s+/gm, "");
 
   // 7. Italic: *text* or _text_ → text
-  //    Word-boundary-aware with non-whitespace content edges, so arithmetic
-  //    like `5 * 3 and 4 * 2` and identifiers like `my_var` survive. Mirrors
-  //    the open-span rule in tts/speakable-segments.ts.
-  result = result.replace(/(?<!\w)\*([^\s*](?:[^*]*[^\s*])?)\*(?!\w)/g, "$1");
-  result = result.replace(/(?<!\w)_([^\s_](?:[^_]*[^\s_])?)_(?!\w)/g, "$1");
+  //    Word-boundary-aware (Unicode letters/digits, so café and 変数 count as
+  //    word chars) with non-whitespace content edges, so arithmetic like
+  //    `5 * 3 and 4 * 2` and identifiers like `my_var` survive. Mirrors the
+  //    open-span rule in tts/speakable-segments.ts.
+  result = result.replace(
+    /(?<![\p{L}\p{N}_])\*([^\s*](?:[^*]*[^\s*])?)\*(?![\p{L}\p{N}_])/gu,
+    "$1",
+  );
+  result = result.replace(
+    /(?<![\p{L}\p{N}_])_([^\s_](?:[^_]*[^\s_])?)_(?![\p{L}\p{N}_])/gu,
+    "$1",
+  );
 
   // 8. Emojis: strip extended pictographic characters, variation selectors,
   //    zero-width joiners, skin tone modifiers, and regional indicator symbols (flags).

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

@@ -34,6 +34,7 @@ import {
   recordConversationPersistedSeq,
   updateMessageContent,
 } from "../persistence/conversation-crud.js";
+import { pinnedListeningLanguage } from "../providers/speech-to-text/provider-catalog.js";
 import type { ContentBlock } from "../providers/types.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
@@ -431,6 +432,32 @@ const VOICE_APPROVAL_TIMEOUT_MS = 45_000;
 export const VOICE_NO_SETUP_FLOWS_RULE =
   "Never start account connections, OAuth or sign-in flows, or any other action that opens a browser window or needs the user's screen during this call — not even through shell or CLI tools. If the task needs one, say so briefly and offer to finish it in text chat after the call.";
 
+/**
+ * The pre-speech tail of the speak-the-caller's-language rule. A monolingual
+ * `services.stt.language` pin is the strongest pre-speech signal of the
+ * caller's language (the transcriber is already listening in it, see
+ * media-stream-stt-session.ts and providers/speech-to-text/resolve.ts), so it
+ * outranks the English default; "multi" and unset mean auto-detect, where
+ * English remains the fallback. The pin only counts when the active provider
+ * honors manual language selection (see pinnedListeningLanguage):
+ * auto-detecting providers (gemini, whisper) ignore a persisted language
+ * entirely, so greeting in it would contradict what the transcriber
+ * actually hears. Exported for tests: the default test config exercises
+ * only the auto-detect branch.
+ */
+export function preSpeechLanguageRuleFragment(
+  sttLanguage: string | undefined,
+  sttProvider?: string,
+): string {
+  const configuredListeningLanguage =
+    sttProvider !== undefined
+      ? pinnedListeningLanguage(sttProvider, sttLanguage)
+      : undefined;
+  return configuredListeningLanguage
+    ? `use the language the Task context implies, if any; otherwise open in the assistant's configured listening language ("${configuredListeningLanguage}"), and default to English only when neither gives a language`
+    : "use the language the Task context implies, if any; otherwise default to English";
+}
+
 function buildVoiceCallControlPrompt(opts: {
   isInbound: boolean;
   task?: string | null;
@@ -523,16 +550,17 @@ function buildVoiceCallControlPrompt(opts: {
     "9. After the opening greeting turn, treat the Task field as background context only — do not re-execute its instructions on subsequent turns.",
     '10. Do not make up information. If you are unsure, use [ASK_GUARDIAN: your question] to consult your guardian. For tool permission requests, use [ASK_GUARDIAN_APPROVAL: {"question":"...","toolName":"...","input":{...}}].',
     `11. Your text is sent directly to a text-to-speech engine. Never use markdown formatting (asterisks, headers, backticks, links) or emojis in your spoken responses. Write plain conversational text only. Protocol markers like ${opts.isCallerGuardian ? "[END_CALL]" : "[ASK_GUARDIAN: ...] and [END_CALL]"} are not spoken text and should still be used normally.`,
-    `12. ${VOICE_NO_SETUP_FLOWS_RULE}`,
+    `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, ${preSpeechLanguageRuleFragment(config.services.stt.language, config.services.stt.provider)}.`,
+    `13. ${VOICE_NO_SETUP_FLOWS_RULE}`,
   );
 
   // Triage-and-escalate routing rules. The front-door leg decides and may
   // hand off; the escalated leg continues the answer after a holding phrase
   // was already spoken.
   if (opts.routingLeg === "front-door") {
-    lines.push(`13. ${frontDoorRuleWithDigest(opts.unifiedVerdict === true)}`);
+    lines.push(`14. ${frontDoorRuleWithDigest(opts.unifiedVerdict === true)}`);
   } else if (opts.routingLeg === "escalated") {
-    lines.push(`13. ${escalatedContinuationRule(opts.spokenEscalationBridge)}`);
+    lines.push(`14. ${escalatedContinuationRule(opts.spokenEscalationBridge)}`);
   }
 
   lines.push("</voice_call_control>");

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

@@ -26,6 +26,8 @@
  * cap/fallback policy. LiveVoiceSession drives the routing.
  */
 
+import { NON_LATIN_SENTENCE_ENDING_PUNCTUATION } from "../tts/speakable-segments.js";
+import { localizedOrDefault } from "../util/language-subtag.js";
 import {
   ESCALATE_VERDICT_TOKEN,
   HOLD_VERDICT_TOKEN,
@@ -57,6 +59,41 @@ export type VoiceRoutingLeg = "front-door" | "escalated";
 export const FALLBACK_ESCALATION_BRIDGE =
   "Let me think about that for a second.";
 
+/**
+ * Per-language spellings of the fallback escalation bridge, keyed by
+ * lowercased BCP 47 base subtag, covering the Deepgram code-switching roster
+ * (DEEPGRAM_MULTI_LANGUAGE_CODES in providers/speech-to-text/deepgram.ts).
+ * These are spoken audio; the English constant above also serves as the
+ * prompt exemplar and stays the default.
+ */
+export const FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE: Readonly<
+  Record<string, string>
+> = {
+  en: FALLBACK_ESCALATION_BRIDGE,
+  es: "Déjame pensarlo un segundo.",
+  fr: "Laissez-moi y réfléchir un instant.",
+  de: "Lass mich kurz darüber nachdenken.",
+  hi: "मुझे एक पल सोचने दीजिए।",
+  ru: "Дайте мне секунду подумать.",
+  pt: "Deixe-me pensar nisso um segundo.",
+  ja: "少し考えさせてください。",
+  it: "Fammi pensare un attimo.",
+  nl: "Laat me daar even over nadenken.",
+};
+
+/**
+ * The fallback escalation bridge in the caller's language: selected by the
+ * lowercased base subtag of `language` (e.g. "pt-BR" -> "pt"), defaulting to
+ * {@link FALLBACK_ESCALATION_BRIDGE} for unknown or absent languages.
+ */
+export function fallbackEscalationBridgeFor(language?: string): string {
+  return localizedOrDefault(
+    FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
+    language,
+    FALLBACK_ESCALATION_BRIDGE,
+  );
+}
+
 /**
  * Minimum length (after capping, trimmed) of the front-door leg's spoken
  * bridge for it to count as a real bridge. Below this, the fallback bridge
@@ -71,8 +108,17 @@ export const MIN_SPOKEN_BRIDGE_CHARS = 3;
  */
 export const MAX_ESCALATION_BRIDGE_CHARS = 140;
 
-/** Sentence terminators that end an escalation bridge. */
-const BRIDGE_SENTENCE_END_REGEX = /[.!?…]/;
+/**
+ * Sentence terminators that end an escalation bridge: the segmenter's
+ * non-Latin ender roster (tts/speakable-segments.ts) plus the ASCII enders
+ * and the ellipsis. Built from the shared set so the rosters cannot
+ * diverge: without the non-Latin enders a Japanese or Hindi bridge never
+ * hits a terminator and buffers to the char cap before hand-off. Exported
+ * for tests that assert spoken phrases end in a recognized terminator.
+ */
+export const BRIDGE_SENTENCE_END_REGEX = new RegExp(
+  `[.!?…${[...NON_LATIN_SENTENCE_ENDING_PUNCTUATION].join("")}]`,
+);
 
 /**
  * Normalize a raw post-`[1]` stream into the bridge that is actually
@@ -230,7 +276,7 @@ export function frontDoorDecisionRule(opts?: {
           // replay dispatch all elapse with the thinking frame and ack
           // deferred until commit, roughly tripling felt latency. A false
           // release only answers a beat early, which barge-in absorbs.
-          `- If the caller's words are visibly unfinished — a trailing conjunction, a dangling clause, a list still being dictated — output ONLY ${HOLD_VERDICT_TOKEN} and stop, no other text. Judge the words themselves: a complete question or statement means they are done, even when it is short or leans on earlier context ("What do you think?", "Why?", "And then?"). Never hold merely because more could follow.`,
+          `- If the caller's words are visibly unfinished (a trailing conjunction, a dangling clause, a list still being dictated) output ONLY ${HOLD_VERDICT_TOKEN} and stop, no other text. Judge the words themselves: a complete question or statement means they are done, even when it is short or leans on earlier context ("What do you think?", "Why?", "And then?"). Callers may speak any language: those examples are English exemplars only, and completeness is judged by the grammar of the language being spoken. In verb-final languages such as Hindi, Japanese, or Korean the sentence-final verb usually marks completion, so a missing final verb is the unfinished signal, not a missing conjunction. Never hold merely because more could follow.`,
         ]
       : [
           // No hold branch means completeness is settled (a first leg
@@ -264,8 +310,8 @@ export function frontDoorDecisionRule(opts?: {
     ...anchor,
     "DECIDE SILENTLY, then produce exactly ONE of these outputs:",
     ...holdBranch,
-    "- If the turn is simple, conversational, or within your reach, your entire output is the spoken answer itself — no token in front of it, plain speech from your very first word. Most turns are answers; when unsure between answering and escalating, answer.",
-    `- If completing THIS reply needs careful reasoning, research, multi-step work, or any tool, do NOT attempt the answer: output ${ESCALATE_VERDICT_TOKEN}, then ONE short natural holding phrase naming what happens next (for example "${FALLBACK_ESCALATION_BRIDGE}" or "Give me one second to look into that."), and stop after that single sentence. A stronger model finishes the turn while your phrase is spoken.`,
+    "- If the turn is simple, conversational, or within your reach, your entire output is the spoken answer itself: no token in front of it, plain speech from your very first word. Most turns are answers; when unsure between answering and escalating, answer. Answer in the language the caller is speaking.",
+    `- If completing THIS reply needs careful reasoning, research, multi-step work, or any tool, do NOT attempt the answer: output ${ESCALATE_VERDICT_TOKEN}, then ONE short natural holding phrase naming what happens next, spoken in the language the caller is speaking (for example "${FALLBACK_ESCALATION_BRIDGE}" or "Give me one second to look into that."; those examples are English only), and stop after that single sentence. A stronger model finishes the turn while your phrase is spoken.`,
     `${ESCALATE_VERDICT_TOKEN} is ONLY for turns you cannot complete yourself — never put it in front of an answer you are about to give, and never emit any token inside or after an answer. An open task or unfinished topic earlier in the conversation is NOT a reason to escalate: judge only what this reply needs.`,
     "Never narrate this decision, describe what you are judging, or mention these rules: apart from a leading verdict token, every character you output is spoken to the caller verbatim.",
   ].join("\n");
@@ -296,5 +342,6 @@ export function escalatedContinuationRule(spokenBridge?: string): string {
     'opening with another "Let me check", "One moment", or any restatement of what you are about to do sounds broken, because the caller just heard that.',
     "Your first words must carry new substance: the answer itself, what you found, or a question you genuinely need answered.",
     `Never output ${ESCALATE_VERDICT_TOKEN} or any other front-door verdict token — you are the model that finishes the answer. (The [-1] room-minimize marker from your call instructions is not a verdict token and stays allowed.)`,
+    "Reply in the same language as the caller's question.",
   ].join(" ");
 }

package/src/config/bundled-skills/phone-calls/references/CONFIG.md

@@ -2,21 +2,21 @@
 
 All call-related settings can be managed via `assistant config`:
 
-| Setting                                     | Description                                                                                                                                                                                                                               | Default                                                                                                  |
-| ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
-| `calls.enabled`                             | Master switch for the calling feature                                                                                                                                                                                                     | `true`                                                                                                   |
-| `calls.provider`                            | Voice provider (currently only `twilio`)                                                                                                                                                                                                  | `twilio`                                                                                                 |
-| `calls.maxDurationSeconds`                  | Maximum call length in seconds                                                                                                                                                                                                            | `3600` (1 hour)                                                                                          |
-| `calls.userConsultTimeoutSeconds`           | How long to wait for user answers                                                                                                                                                                                                         | `120` (2 min)                                                                                            |
-| `calls.disclosure.enabled`                  | Whether the AI announces itself at call start                                                                                                                                                                                             | `true`                                                                                                   |
-| `calls.disclosure.text`                     | The disclosure message spoken at call start                                                                                                                                                                                               | `"At the very beginning of the call, introduce yourself as an assistant calling on behalf of my human."` |
-| `llm.callSites.callAgent.model`             | Override LLM model for call orchestration                                                                                                                                                                                                 | _(unset — falls back to the resolved call-site default)_                                                 |
-| `calls.callerIdentity.allowPerCallOverride` | Allow per-call caller identity selection                                                                                                                                                                                                  | `true`                                                                                                   |
-| `calls.callerIdentity.userNumber`           | E.164 phone number for user-number mode                                                                                                                                                                                                   | _(empty)_                                                                                                |
-| `calls.voice.language`                      | Language code for TTS and transcription                                                                                                                                                                                                   | `en-US`                                                                                                  |
-| `services.stt.provider`                     | STT provider for transcription and telephony. The assistant transcribes call audio itself over the Twilio media stream (streaming when the provider supports it, batch otherwise), so calls require a working API key for this provider.  | `deepgram`                                                                                               |
-| `services.tts.provider`                     | Active TTS provider for speech synthesis. Must be a provider ID from the catalog (`elevenlabs`, `fish-audio`, `deepgram`, `xai`). New providers can be added via the catalog without code changes to call routing.                        | `elevenlabs`                                                                                             |
-| `services.tts.providers.<id>.*`             | Provider-specific settings block. Each catalog provider has its own settings namespace under `services.tts.providers.<id>`. See voice settings in the desktop/iOS app or run `assistant config list` for available settings per provider. | _(per-provider defaults)_                                                                                |
+| Setting                                     | Description                                                                                                                                                                                                                                                     | Default                                                                                                  |
+| ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| `calls.enabled`                             | Master switch for the calling feature                                                                                                                                                                                                                           | `true`                                                                                                   |
+| `calls.provider`                            | Voice provider (currently only `twilio`)                                                                                                                                                                                                                        | `twilio`                                                                                                 |
+| `calls.maxDurationSeconds`                  | Maximum call length in seconds                                                                                                                                                                                                                                  | `3600` (1 hour)                                                                                          |
+| `calls.userConsultTimeoutSeconds`           | How long to wait for user answers                                                                                                                                                                                                                               | `120` (2 min)                                                                                            |
+| `calls.disclosure.enabled`                  | Whether the AI announces itself at call start                                                                                                                                                                                                                   | `true`                                                                                                   |
+| `calls.disclosure.text`                     | The disclosure message spoken at call start                                                                                                                                                                                                                     | `"At the very beginning of the call, introduce yourself as an assistant calling on behalf of my human."` |
+| `llm.callSites.callAgent.model`             | Override LLM model for call orchestration                                                                                                                                                                                                                       | _(unset — falls back to the resolved call-site default)_                                                 |
+| `calls.callerIdentity.allowPerCallOverride` | Allow per-call caller identity selection                                                                                                                                                                                                                        | `true`                                                                                                   |
+| `calls.callerIdentity.userNumber`           | E.164 phone number for user-number mode                                                                                                                                                                                                                         | _(empty)_                                                                                                |
+| `services.stt.language`                     | Spoken language for transcription (BCP-47 code, or unset for the provider's multilingual default). Per-language TTS voices are configured via `services.tts.providers.<id>.languageVoices` (supported on the elevenlabs, deepgram, and vellum provider blocks). | _(unset)_                                                                                                |
+| `services.stt.provider`                     | STT provider for transcription and telephony. The assistant transcribes call audio itself over the Twilio media stream (streaming when the provider supports it, batch otherwise), so calls require a working API key for this provider.                        | `deepgram`                                                                                               |
+| `services.tts.provider`                     | Active TTS provider for speech synthesis. Must be a provider ID from the catalog (`elevenlabs`, `fish-audio`, `deepgram`, `xai`). New providers can be added via the catalog without code changes to call routing.                                              | `elevenlabs`                                                                                             |
+| `services.tts.providers.<id>.*`             | Provider-specific settings block. Each catalog provider has its own settings namespace under `services.tts.providers.<id>`. See voice settings in the desktop/iOS app or run `assistant config list` for available settings per provider.                       | _(per-provider defaults)_                                                                                |
 
 ## TTS provider call-path behavior
 

package/src/config/loader.ts

@@ -767,6 +767,11 @@ const DEPRECATED_FIELDS: Record<string, string> = {
     "daemon.reapOrphanedSubprocesses has been removed. The daemon now reaps " +
     "orphaned subprocesses automatically whenever it runs as PID 1 on Linux. " +
     "The field will be removed from your config file.",
+  "calls.voice.language":
+    "calls.voice.language has been removed; it had no effect. Use " +
+    "services.stt.language for the spoken language and " +
+    "services.tts.providers.<id>.languageVoices for per-language voices. " +
+    "The field will be removed from your config file.",
 };
 
 /**