@vellumai/assistant 0.12.0-dev.202609111458.db63c16 → 0.12.0-dev.202609111617.f60422f

package/ARCHITECTURE.md

@@ -612,6 +612,8 @@ Transcription mode is selected once per session in `media-stream-stt-session.ts`
 - **Streaming** (default): when `calls.voice.telephonyStreaming` is enabled and the `telephony` role resolves a streaming transcriber (`resolveStreamingTranscriber({ role: "telephony" })`), inbound audio is decoded (mu-law → PCM16, resampled 8 kHz → 16 kHz) and fed to the provider's realtime adapter. Replies trigger only on utterance-boundary finals (for Deepgram, `speech_final`/`UtteranceEnd`, never mid-sentence `is_final` segments), and barge-in fires from local energy VAD, never from transcriber partials.
 - **Batch fallback**: otherwise the session segments turns with the energy-based `MediaTurnDetector` and transcribes each completed turn via the same role's batch API. Both halves of a call read the `telephony` role, which is why a role names its consumer rather than a boundary.
 
+Every phone turn runs the same two-leg triage as live voice through `startVoiceTurn` (`src/calls/voice-session-bridge.ts`): `call-controller.ts` opens on a toolless front-door leg (`routingLeg: "front-door"`, the `voiceFrontDoor` call site) and reads its stream through the shared `createFrontDoorVerdictMachine`; an escalate verdict speaks the capped holding phrase (or the localized canned bridge) and continues on an escalated leg pinned to the conversation's own model. Phone has no partial transcripts, so the hold verdict is never taught and routing is escalate-only. The controller also passes the bridge's turn callbacks (tool activity is recorded as `tool_use_started` / `tool_use_completed` call events, persisted row ids ride the `assistant_spoke` event), `launchedAtMs` for dispatch timing, and a `voiceTelemetry` bag keyed by the call session with a `phone_inbound` / `phone_outbound` entry.
+
 A credential preflight (`resolveTelephonyCredentialReadiness()` in `src/calls/telephony-credential-preflight.ts`) gates every call: it requires a credentialed, telephony-capable STT provider **and** a media-stream-playable TTS provider (the configured one or a credentialed playable fallback). Inbound calls that fail the preflight receive `<Say>` setup-required copy plus `<Hangup/>` instead of a doomed stream; outbound placement fails before dialing via `preflightVoiceIngress()` with the same user-facing message.
 
 Key modules:
@@ -2189,7 +2191,7 @@ The `TtsUseCase` discriminator (`"phone-call"` or `"message-playback"`) lets pro
 - **`native-twilio`** — the text-token path: spoken text is sent via `sendTextToken()`, which the media-stream transport re-synthesizes through daemon TTS. Collapsing this mode into `synthesized-play` is a documented deferred follow-up.
 - **`synthesized-play`** — The assistant synthesises audio via the provider's HTTP API and streams it through the audio store / `sendPlayUrl()` path.
 
-**Phone call integration:** Phone calls run on the media-stream transport, where the daemon synthesises speech via the configured TTS provider and transcodes it to mu-law 8 kHz frames (`media-stream-output.ts`). Each catalog entry declares `mediaStreamPlayback.outputFormat` (`pcm`, `wav`, or `none`); `resolveTelephonyTtsCapability()` (`src/calls/telephony-tts-capability.ts`) combines that field with credential availability into a playable / not-playable verdict, and the call TTS resolver falls back to a credentialed playable provider rather than producing silence.
+**Phone call integration:** Phone calls run on the media-stream transport, where the daemon synthesises speech via the effective TTS provider (the configured one after managed-speech defaulting, `resolveEffectiveSpeechProviders`, the same substitution live voice makes) and transcodes it to mu-law 8 kHz frames (`media-stream-output.ts`). Each catalog entry declares `mediaStreamPlayback.outputFormat` (`pcm`, `wav`, or `none`); `resolveTelephonyTtsCapability()` (`src/calls/telephony-tts-capability.ts`) combines that field with credential availability into a playable / not-playable verdict, and the call TTS resolver falls back to a credentialed playable provider rather than producing silence.
 
 **Adding a new TTS provider (catalog-first checklist):**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.0-dev.202609111458.db63c16",
+  "version": "0.12.0-dev.202609111617.f60422f",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/telephony-tts-guard.test.ts

@@ -455,10 +455,11 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.provider?.id).toBe("elevenlabs");
   });
 
-  test("without requiresPcmAudio the configured provider is not swapped", async () => {
+  test("without requiresPcmAudio the configured provider is not swapped for playability", async () => {
     testConfig.services.tts.provider = "deepgram";
-    // No credentials at all — the CR transport path does not consult the
-    // media-stream playability capability.
+    storedKeys["deepgram"] = "dg-key";
+    // The CR transport path does not consult the media-stream playability
+    // capability.
     registerStubProvider("deepgram", async () => {
       return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
     });
@@ -468,6 +469,37 @@ describe("resolveCallTtsProvider with requiresPcmAudio", () => {
     expect(result.useSynthesizedPath).toBe(true);
     expect(result.audioFormat).toBe("mp3");
   });
+
+  test("managed speech stands in for a configured provider whose credential is missing", async () => {
+    testConfig.services.tts.provider = "deepgram";
+    // No deepgram key, managed speech available: the phone speaks through
+    // managed speech, the same substitution live voice makes.
+    registerStubProvider("deepgram", async () => {
+      throw new Error("should not be used");
+    });
+    registerStubProvider("vellum", async () => {
+      return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
+    });
+
+    const result = await resolveCallTtsProvider();
+    expect(result.provider?.id).toBe("vellum");
+    expect(result.useSynthesizedPath).toBe(true);
+  });
+
+  test("without managed speech a credential-less configured provider is kept", async () => {
+    mockManagedSpeechAvailable = false;
+    try {
+      testConfig.services.tts.provider = "deepgram";
+      registerStubProvider("deepgram", async () => {
+        return { audio: Buffer.from("x"), contentType: "audio/mpeg" };
+      });
+
+      const result = await resolveCallTtsProvider();
+      expect(result.provider?.id).toBe("deepgram");
+    } finally {
+      mockManagedSpeechAvailable = true;
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -584,6 +616,7 @@ describe("speakSystemPrompt mid-stream failure after audio started", () => {
   test("non-PCM transport: skips the native text fallback — no full-prompt re-speak", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const fishStream = jest.fn(failAfterFirstChunk());
     registerStreamingStubProvider("fish-audio", fishStream);
@@ -657,6 +690,7 @@ describe("speakSystemPrompt aborted synthesis", () => {
   test("non-PCM transport with native-fallback provider: abort skips the text fallback and end-of-turn", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const controller = new AbortController();
     controller.abort();
@@ -742,6 +776,7 @@ describe("speakSystemPrompt aborted synthesis", () => {
   test("provider AbortError without any signal is a failure — non-PCM native fallback still runs", async () => {
     testConfig.services.tts.provider = "fish-audio";
     testConfig.services.tts.providers["fish-audio"].referenceId = "ref-123";
+    storedKeys["fish-audio"] = "fa-key";
 
     const fishSynthesize = jest.fn(async () => {
       throw new DOMException("socket torn down", "AbortError");

package/src/calls/__tests__/call-controller.test.ts

@@ -45,6 +45,18 @@ mock.module("../../security/secure-keys.js", () => ({
       : "test-key",
 }));
 
+// Managed-speech defaulting reaches the platform client and the credential
+// store. The controller tests drive the bridge mock on a microtask budget, so
+// the configured providers stand as the effective ones here.
+mock.module("../../config/managed-speech-defaults.js", () => ({
+  resolveEffectiveSpeechProviders: async (config?: {
+    services: { stt: { provider: string }; tts: { provider: string } };
+  }) => {
+    const services = (config ?? loadConfig()).services;
+    return { stt: services.stt.provider, tts: services.tts.provider };
+  },
+}));
+
 mock.module("../../security/credential-key.js", () => ({
   credentialKey: (...args: string[]) => args.join("/"),
 }));
@@ -229,6 +241,11 @@ import {
 } from "../call-store.js";
 import type { CallTransport } from "../call-transport.js";
 import { resolveCallTtsProvider } from "../resolve-call-tts-provider.js";
+import {
+  ESCALATION_CONTINUATION_CONTENT,
+  FALLBACK_ESCALATION_BRIDGE,
+  FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE,
+} from "../voice-triage-escalate.js";
 
 // Disable memory so persisted call messages skip background indexing, and
 // seed the ingress base URL used for synthesized-audio play URLs.
@@ -248,6 +265,8 @@ afterAll(() => {
 
 interface MockTransport extends CallTransport {
   sentTokens: Array<{ token: string; last: boolean }>;
+  /** Tokens sent with the system-copy flag (no caller-language hint). */
+  systemCopyTokens: string[];
   sentPlayUrls: string[];
   endCalled: boolean;
   endReason: string | undefined;
@@ -257,6 +276,7 @@ interface MockTransport extends CallTransport {
 function createMockTransport(): MockTransport {
   const state = {
     sentTokens: [] as Array<{ token: string; last: boolean }>,
+    systemCopyTokens: [] as string[],
     sentPlayUrls: [] as string[],
     _endCalled: false,
     _endReason: undefined as string | undefined,
@@ -267,6 +287,9 @@ function createMockTransport(): MockTransport {
     get sentTokens() {
       return state.sentTokens;
     },
+    get systemCopyTokens() {
+      return state.systemCopyTokens;
+    },
     get sentPlayUrls() {
       return state.sentPlayUrls;
     },
@@ -279,8 +302,15 @@ function createMockTransport(): MockTransport {
     get cancelPendingSpeechCount() {
       return state._cancelPendingSpeechCount;
     },
-    sendTextToken(token: string, last: boolean) {
+    sendTextToken(
+      token: string,
+      last: boolean,
+      opts?: { systemCopy?: boolean },
+    ) {
       state.sentTokens.push({ token, last });
+      if (opts?.systemCopy === true) {
+        state.systemCopyTokens.push(token);
+      }
     },
     sendPlayUrl(url: string) {
       state.sentPlayUrls.push(url);
@@ -4194,6 +4224,319 @@ describe("call-controller", () => {
     });
   });
 
+  // ── Triage-and-escalate routing ─────────────────────────────────────
+
+  describe("triage-and-escalate routing", () => {
+    interface LegOpts {
+      content: string;
+      routingLeg?: string;
+      spokenEscalationBridge?: string;
+      launchedAtMs?: number;
+      voiceTelemetry?: { sessionId: string; entry?: string };
+      callbacks?: {
+        persisted_user_message_id?: (id: string) => void;
+        persisted_assistant_message_id?: (id: string) => void;
+        tool_use_start?: (
+          toolName: string,
+          detail?: { toolUseId?: string },
+        ) => void;
+        tool_result?: (event: {
+          toolName: string;
+          toolUseId?: string;
+          isError?: boolean;
+          resultPreview: string;
+        }) => void;
+      };
+      onTextDelta: (t: string) => void;
+      onComplete: () => void;
+      signal?: AbortSignal;
+    }
+
+    /**
+     * Script the bridge one leg per call: the front-door leg's tokens first,
+     * then the escalated leg's. Records every call's options and which legs
+     * the controller aborted.
+     */
+    function scriptLegs(
+      legs: string[][],
+      beforeComplete?: (opts: LegOpts, index: number) => void,
+    ) {
+      const calls: LegOpts[] = [];
+      const aborted: number[] = [];
+      mockStartVoiceTurn.mockImplementation(async (opts: LegOpts) => {
+        const index = calls.length;
+        calls.push(opts);
+        for (const token of legs[index] ?? []) {
+          opts.onTextDelta(token);
+        }
+        beforeComplete?.(opts, index);
+        opts.onComplete();
+        return { turnId: `run-${index}`, abort: () => aborted.push(index) };
+      });
+      return { calls, aborted };
+    }
+
+    function spokenText(relay: MockTransport): string {
+      return relay.sentTokens
+        .filter((t) => !t.last)
+        .map((t) => t.token)
+        .join("");
+    }
+
+    function assistantSpokePayload(sessionId: string): Record<string, unknown> {
+      const spoke = getCallEvents(sessionId).filter(
+        (e) => e.eventType === "assistant_spoke",
+      );
+      expect(spoke.length).toBe(1);
+      return JSON.parse(spoke[0].payloadJson) as Record<string, unknown>;
+    }
+
+    test("a front-door answer runs one leg and is spoken verbatim", async () => {
+      const { calls, aborted } = scriptLegs([["Hello", " there."]]);
+      const { session, relay, controller } = setupController();
+
+      await controller.handleCallerUtterance("Hi");
+
+      expect(calls.length).toBe(1);
+      expect(calls[0].routingLeg).toBe("front-door");
+      expect(calls[0].content).toBe("Hi");
+      expect(calls[0].spokenEscalationBridge).toBeUndefined();
+      expect(aborted).toEqual([]);
+      expect(spokenText(relay)).toContain("Hello there.");
+      expect(assistantSpokePayload(session.id).text).toBe("Hello there.");
+
+      controller.destroy();
+    });
+
+    test("an escalate verdict speaks the holding phrase, aborts the front-door leg, and continues on the escalated leg", async () => {
+      const { calls, aborted } = scriptLegs([
+        // The verdict token may arrive split across deltas; the leading
+        // "[" is held until it classifies.
+        ["[", "1] Let me check", " that.", " Ignored past the cap."],
+        ["The answer is 42."],
+      ]);
+      const { session, relay, controller } = setupController();
+
+      await controller.handleCallerUtterance("What is six times seven?");
+
+      expect(calls.length).toBe(2);
+      expect(calls[0].routingLeg).toBe("front-door");
+      expect(calls[1].routingLeg).toBe("escalated");
+      expect(calls[1].content).toBe(ESCALATION_CONTINUATION_CONTENT);
+      expect(calls[1].spokenEscalationBridge).toBe("Let me check that.");
+      expect(aborted).toEqual([0]);
+
+      const spoken = spokenText(relay);
+      expect(spoken).toContain("Let me check that.");
+      expect(spoken).toContain("The answer is 42.");
+      expect(spoken.indexOf("Let me check that.")).toBeLessThan(
+        spoken.indexOf("The answer is 42."),
+      );
+      expect(spoken).not.toContain("[1]");
+      expect(spoken).not.toContain("Ignored past the cap.");
+      expect(assistantSpokePayload(session.id).text).toBe(
+        "Let me check that. The answer is 42.",
+      );
+      // One end-of-turn signal for the whole turn, after the escalated leg.
+      expect(relay.sentTokens.filter((t) => t.last).length).toBe(1);
+
+      controller.destroy();
+    });
+
+    test("a bare escalate verdict speaks the canned bridge, audio-only", async () => {
+      const { calls } = scriptLegs([["[1]"], ["Forty-two."]]);
+      const { session, relay, controller } = setupController();
+
+      await controller.handleCallerUtterance("What is six times seven?");
+
+      expect(calls.length).toBe(2);
+      expect(calls[1].spokenEscalationBridge).toBe(FALLBACK_ESCALATION_BRIDGE);
+      expect(spokenText(relay)).toContain(FALLBACK_ESCALATION_BRIDGE);
+      // The canned bridge is not the model's speech: the turn's text (and the
+      // transcript row the bridge keeps) carry only the escalated answer.
+      expect(assistantSpokePayload(session.id).text).toBe("Forty-two.");
+
+      controller.destroy();
+    });
+
+    test("a leg cancelled mid-bridge never spawns the escalated leg", async () => {
+      const calls: LegOpts[] = [];
+      let releaseLeg: () => void = () => {};
+      mockStartVoiceTurn.mockImplementation(async (opts: LegOpts) => {
+        calls.push(opts);
+        opts.onTextDelta("[1] Let me");
+        await new Promise<void>((resolve) => {
+          releaseLeg = resolve;
+          opts.signal?.addEventListener("abort", () => resolve());
+        });
+        // The bridge reports a cancelled leg's completion too.
+        opts.onComplete();
+        return { turnId: "run-cancelled", abort: () => releaseLeg() };
+      });
+      const { relay, controller } = setupController();
+
+      const turnPromise = controller.handleCallerUtterance("Hi");
+      for (let i = 0; i < 10; i++) {
+        await Promise.resolve();
+      }
+      expect(calls.length).toBe(1);
+
+      controller.handleInterrupt();
+      await turnPromise;
+
+      expect(calls.length).toBe(1);
+      expect(spokenText(relay)).toBe("");
+
+      controller.destroy();
+    });
+
+    test("passes the launch time, phone telemetry, and callbacks to the bridge", async () => {
+      const before = Date.now();
+      const { calls } = scriptLegs([["Done."]], (opts) => {
+        opts.callbacks?.persisted_user_message_id?.("user-row-1");
+        opts.callbacks?.tool_use_start?.("web_search", { toolUseId: "tu-1" });
+        opts.callbacks?.tool_result?.({
+          toolName: "web_search",
+          toolUseId: "tu-1",
+          isError: false,
+          resultPreview: "three results",
+        });
+        opts.callbacks?.persisted_assistant_message_id?.("assistant-row-1");
+      });
+      const { session, controller } = setupController();
+
+      await controller.handleCallerUtterance("Look that up");
+
+      expect(calls.length).toBe(1);
+      expect(calls[0].launchedAtMs).toBeGreaterThanOrEqual(before);
+      expect(calls[0].launchedAtMs).toBeLessThanOrEqual(Date.now());
+      expect(calls[0].voiceTelemetry).toEqual({
+        sessionId: session.id,
+        entry: "phone_inbound",
+      });
+
+      const events = getCallEvents(session.id);
+      const started = events.filter((e) => e.eventType === "tool_use_started");
+      expect(started.length).toBe(1);
+      expect(JSON.parse(started[0].payloadJson)).toEqual({
+        toolName: "web_search",
+        toolUseId: "tu-1",
+      });
+      const completed = events.filter(
+        (e) => e.eventType === "tool_use_completed",
+      );
+      expect(completed.length).toBe(1);
+      expect(JSON.parse(completed[0].payloadJson)).toEqual({
+        toolName: "web_search",
+        toolUseId: "tu-1",
+        isError: false,
+        resultPreview: "three results",
+      });
+      expect(assistantSpokePayload(session.id)).toEqual({
+        text: "Done.",
+        userMessageId: "user-row-1",
+        assistantMessageId: "assistant-row-1",
+      });
+
+      controller.destroy();
+    });
+
+    test("the escalated leg's hidden continuation row is not the caller's utterance", async () => {
+      const { calls } = scriptLegs(
+        [["[1] One moment."], ["Here you go."]],
+        (opts, index) => {
+          opts.callbacks?.persisted_user_message_id?.(`user-row-${index}`);
+          opts.callbacks?.persisted_assistant_message_id?.(
+            `assistant-row-${index}`,
+          );
+        },
+      );
+      const { session, controller } = setupController();
+
+      await controller.handleCallerUtterance("Hi");
+
+      expect(calls.length).toBe(2);
+      expect(assistantSpokePayload(session.id)).toEqual({
+        text: "One moment. Here you go.",
+        userMessageId: "user-row-0",
+        assistantMessageId: "assistant-row-1",
+      });
+
+      controller.destroy();
+    });
+
+    test("native route: a canned bridge in a language the table lacks goes out as system copy", async () => {
+      scriptLegs([["[1]"], ["Forty-two."]]);
+      const { relay, controller } = setupController(undefined, {
+        resolveSynthesisLanguage: () => "ko",
+      });
+
+      await controller.handleCallerUtterance("What is six times seven?");
+
+      // The English fallback must not ride the caller's Korean hint.
+      expect(relay.systemCopyTokens).toEqual([
+        `${FALLBACK_ESCALATION_BRIDGE} `,
+      ]);
+      expect(spokenText(relay)).toContain("Forty-two.");
+
+      controller.destroy();
+    });
+
+    test("native route: a localized canned bridge rides the caller's language like model text", async () => {
+      scriptLegs([["[1]"], ["Cuarenta y dos."]]);
+      const { relay, controller } = setupController(undefined, {
+        resolveSynthesisLanguage: () => "es",
+      });
+
+      await controller.handleCallerUtterance("¿Cuánto es seis por siete?");
+
+      expect(relay.systemCopyTokens).toEqual([]);
+      expect(spokenText(relay)).toContain(
+        FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.es,
+      );
+
+      controller.destroy();
+    });
+
+    test("synthesized route: the canned bridge carries its own language hint, the answer the caller's", async () => {
+      const requests: Array<{ text: string; language: string | undefined }> =
+        [];
+      registerFishAudioSegmentRecorder({
+        onSynthesizeStream: async (text, request) => {
+          requests.push({ text, language: request.language });
+        },
+      });
+      scriptLegs([["[1]"], ["Forty-two."]]);
+      const { controller } = setupController(undefined, {
+        resolveSynthesisLanguage: () => "ko",
+      });
+
+      await controller.handleCallerUtterance("What is six times seven?");
+
+      expect(requests).toEqual([
+        { text: FALLBACK_ESCALATION_BRIDGE, language: "en" },
+        { text: "Forty-two.", language: "ko" },
+      ]);
+
+      controller.destroy();
+    });
+
+    test("an outbound call reports the outbound entry", async () => {
+      const { calls } = scriptLegs([["Hello, this is Ava."]]);
+      const { session, controller } = setupController("Book a table for two");
+
+      await controller.startInitialGreeting();
+
+      expect(calls.length).toBe(1);
+      expect(calls[0].voiceTelemetry).toEqual({
+        sessionId: session.id,
+        entry: "phone_outbound",
+      });
+
+      controller.destroy();
+    });
+  });
+
   // ── handleBargeIn ───────────────────────────────────────────────────
 
   describe("handleBargeIn", () => {

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

@@ -842,6 +842,42 @@ describe("startVoiceTurn triage-and-escalate control prompt", () => {
     expect(installed()).toContain(escalatedContinuationRule());
   });
 
+  test("the auto-built phone prompt carries the front-door rule anchored to the caller's words", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      content: "what time is it",
+      routingLeg: "front-door",
+    });
+    expect(installed()).toContain("<voice_call_control>");
+    expect(installed()).toContain(
+      `13. ${frontDoorDecisionRule({ callerUtterance: "what time is it" })}`,
+    );
+  });
+
+  test("a phone sentinel anchors the front-door rule on its persisted form", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({ ...makeTurnOptions(), routingLeg: "front-door" });
+    expect(installed()).toContain(
+      frontDoorDecisionRule({
+        callerUtterance: "(call connected — deliver opening greeting)",
+      }),
+    );
+    expect(installed()).not.toContain(JSON.stringify(CALL_OPENING_MARKER));
+  });
+
+  test("the auto-built phone prompt carries the escalated continuation rule", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      routingLeg: "escalated",
+      spokenEscalationBridge: "One moment.",
+    });
+    expect(installed()).toContain(
+      `13. ${escalatedContinuationRule("One moment.")}`,
+    );
+  });
+
   test("leaves a caller-supplied prompt verbatim when no routing leg is set", async () => {
     const installed = captureInstalledPrompt();
     await startVoiceTurn({

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

@@ -18,6 +18,7 @@ import {
   isEscalationBridgeComplete,
   MAX_ESCALATION_BRIDGE_CHARS,
   needsFallbackBridge,
+  resolveSpokenEscalationBridge,
   spokenBridgeText,
 } from "../voice-triage-escalate.js";
 
@@ -282,6 +283,34 @@ describe("fallbackEscalationBridgeFor", () => {
   });
 });
 
+describe("resolveSpokenEscalationBridge", () => {
+  test("a real capped bridge is spoken as the model's own speech", () => {
+    expect(resolveSpokenEscalationBridge("Let me check that.", "es")).toEqual({
+      spokenBridge: "Let me check that.",
+      usesFallback: false,
+    });
+  });
+
+  test("an empty or too-short bridge falls back to the localized canned phrase, audio-only", () => {
+    expect(resolveSpokenEscalationBridge("", "es")).toEqual({
+      spokenBridge: FALLBACK_ESCALATION_BRIDGE_BY_LANGUAGE.es,
+      usesFallback: true,
+    });
+    expect(resolveSpokenEscalationBridge("Ok", undefined)).toEqual({
+      spokenBridge: FALLBACK_ESCALATION_BRIDGE,
+      usesFallback: true,
+    });
+  });
+
+  test("a canned phrase the table lacks for the caller's language is English and says so", () => {
+    expect(resolveSpokenEscalationBridge("", "ko")).toEqual({
+      spokenBridge: FALLBACK_ESCALATION_BRIDGE,
+      usesFallback: true,
+      language: "en",
+    });
+  });
+});
+
 describe("capEscalationBridge", () => {
   test("cuts just after the first sentence terminator", () => {
     expect(