@openclaw/voice-call 2026.3.13 → 2026.5.2-beta.1

package/src/manager/outbound.ts

@@ -1,6 +1,13 @@
 import crypto from "node:crypto";
-import type { CallMode } from "../config.js";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import {
+  resolveVoiceCallEffectiveConfig,
+  resolveVoiceCallSessionKey,
+  type CallMode,
+} from "../config.js";
+import { resolvePreferredTtsVoice } from "../tts-provider-voice.js";
+import {
+  type EndReason,
   TerminalStates,
   type CallId,
   type CallRecord,
@@ -8,16 +15,12 @@ import {
 } from "../types.js";
 import { mapVoiceToPolly } from "../voice-mapping.js";
 import type { CallManagerContext } from "./context.js";
+import { finalizeCall } from "./lifecycle.js";
 import { getCallByProviderCallId } from "./lookup.js";
 import { addTranscriptEntry, transitionState } from "./state.js";
 import { persistCallRecord } from "./store.js";
-import {
-  clearMaxDurationTimer,
-  clearTranscriptWaiter,
-  rejectTranscriptWaiter,
-  waitForFinalTranscript,
-} from "./timers.js";
-import { generateNotifyTwiml } from "./twiml.js";
+import { clearTranscriptWaiter, waitForFinalTranscript } from "./timers.js";
+import { generateDtmfRedirectTwiml, generateNotifyTwiml } from "./twiml.js";
 
 type InitiateContext = Pick<
   CallManagerContext,
@@ -39,6 +42,7 @@ type ConversationContext = Pick<
   | "activeTurnCalls"
   | "transcriptWaiters"
   | "maxDurationTimers"
+  | "initialMessageInFlight"
 >;
 
 type EndCallContext = Pick<
@@ -102,6 +106,12 @@ function requireConnectedCall(ctx: ConnectedCallContext, callId: CallId): Connec
   };
 }
 
+function validateDtmfDigits(digits: string): string | null {
+  return /^[0-9*#wWpP,]+$/.test(digits)
+    ? null
+    : "digits may only contain digits, *, #, comma, w, p";
+}
+
 export async function initiateCall(
   ctx: InitiateContext,
   to: string,
@@ -112,6 +122,20 @@ export async function initiateCall(
     typeof options === "string" ? { message: options } : (options ?? {});
   const initialMessage = opts.message;
   const mode = opts.mode ?? ctx.config.outbound.defaultMode;
+  const dtmfSequence = opts.dtmfSequence;
+  if (dtmfSequence) {
+    const validationError = validateDtmfDigits(dtmfSequence);
+    if (validationError) {
+      return { callId: "", success: false, error: validationError };
+    }
+    if (mode !== "conversation") {
+      return {
+        callId: "",
+        success: false,
+        error: "dtmfSequence requires conversation mode",
+      };
+    }
+  }
 
   if (!ctx.provider) {
     return { callId: "", success: false, error: "Provider not initialized" };
@@ -142,7 +166,12 @@ export async function initiateCall(
     state: "initiated",
     from,
     to,
-    sessionKey,
+    sessionKey: resolveVoiceCallSessionKey({
+      config: ctx.config,
+      callId,
+      phone: to,
+      explicitSessionKey: sessionKey,
+    }),
     startedAt: Date.now(),
     transcript: [],
     processedEventIds: [],
@@ -158,10 +187,16 @@ export async function initiateCall(
   try {
     // For notify mode with a message, use inline TwiML with <Say>.
     let inlineTwiml: string | undefined;
+    let preConnectTwiml: string | undefined;
     if (mode === "notify" && initialMessage) {
-      const pollyVoice = mapVoiceToPolly(ctx.config.tts?.openai?.voice);
+      const pollyVoice = mapVoiceToPolly(resolvePreferredTtsVoice(ctx.config));
       inlineTwiml = generateNotifyTwiml(initialMessage, pollyVoice);
       console.log(`[voice-call] Using inline TwiML for notify mode (voice: ${pollyVoice})`);
+    } else if (dtmfSequence) {
+      preConnectTwiml = generateDtmfRedirectTwiml(dtmfSequence, ctx.webhookUrl);
+      console.log(
+        `[voice-call] Using pre-connect DTMF TwiML for call ${callId} (digits=${dtmfSequence.length}, initialMessage=${initialMessage ? "yes" : "no"})`,
+      );
     }
 
     const result = await ctx.provider.initiateCall({
@@ -170,27 +205,28 @@ export async function initiateCall(
       to,
       webhookUrl: ctx.webhookUrl,
       inlineTwiml,
+      preConnectTwiml,
     });
 
     callRecord.providerCallId = result.providerCallId;
     ctx.providerCallIdMap.set(result.providerCallId, callId);
     persistCallRecord(ctx.storePath, callRecord);
+    console.log(
+      `[voice-call] Outbound call initiated: callId=${callId} providerCallId=${result.providerCallId} mode=${mode} preConnectDtmf=${preConnectTwiml ? "yes" : "no"} initialMessage=${initialMessage ? "yes" : "no"}`,
+    );
 
     return { callId, success: true };
   } catch (err) {
-    callRecord.state = "failed";
-    callRecord.endedAt = Date.now();
-    callRecord.endReason = "failed";
-    persistCallRecord(ctx.storePath, callRecord);
-    ctx.activeCalls.delete(callId);
-    if (callRecord.providerCallId) {
-      ctx.providerCallIdMap.delete(callRecord.providerCallId);
-    }
+    finalizeCall({
+      ctx,
+      call: callRecord,
+      endReason: "failed",
+    });
 
     return {
       callId,
       success: false,
-      error: err instanceof Error ? err.message : String(err),
+      error: formatErrorMessage(err),
     };
   }
 }
@@ -210,9 +246,11 @@ export async function speak(
     transitionState(call, "speaking");
     persistCallRecord(ctx.storePath, call);
 
-    addTranscriptEntry(call, "bot", text);
-
-    const voice = provider.name === "twilio" ? ctx.config.tts?.openai?.voice : undefined;
+    const numberRouteKey =
+      typeof call.metadata?.numberRouteKey === "string" ? call.metadata.numberRouteKey : call.to;
+    const voice = resolvePreferredTtsVoice(
+      resolveVoiceCallEffectiveConfig(ctx.config, numberRouteKey).config,
+    );
     await provider.playTts({
       callId,
       providerCallId,
@@ -220,9 +258,57 @@ export async function speak(
       voice,
     });
 
+    addTranscriptEntry(call, "bot", text);
+    persistCallRecord(ctx.storePath, call);
+
+    return { success: true };
+  } catch (err) {
+    // A failed playback should not leave the call stuck in speaking state.
+    transitionState(call, "listening");
+    persistCallRecord(ctx.storePath, call);
+    return { success: false, error: formatErrorMessage(err) };
+  }
+}
+
+function shouldStartListeningAfterInitialMessage(ctx: ConversationContext): boolean {
+  if (ctx.provider?.name !== "twilio") {
+    return true;
+  }
+  if (!ctx.config.streaming.enabled) {
+    return true;
+  }
+  const streamAwareProvider = ctx.provider as typeof ctx.provider & {
+    isConversationStreamConnectEnabled?: () => boolean;
+  };
+  return streamAwareProvider.isConversationStreamConnectEnabled?.() !== true;
+}
+
+export async function sendDtmf(
+  ctx: SpeakContext,
+  callId: CallId,
+  digits: string,
+): Promise<{ success: boolean; error?: string }> {
+  const validationError = validateDtmfDigits(digits);
+  if (validationError) {
+    return { success: false, error: validationError };
+  }
+  const connected = requireConnectedCall(ctx, callId);
+  if (!connected.ok) {
+    return { success: false, error: connected.error };
+  }
+  if (!connected.provider.sendDtmf) {
+    return { success: false, error: `${connected.provider.name} does not support outbound DTMF` };
+  }
+
+  try {
+    await connected.provider.sendDtmf({
+      callId,
+      providerCallId: connected.providerCallId,
+      digits,
+    });
     return { success: true };
   } catch (err) {
-    return { success: false, error: err instanceof Error ? err.message : String(err) };
+    return { success: false, error: formatErrorMessage(err) };
   }
 }
 
@@ -248,29 +334,52 @@ export async function speakInitialMessage(
     return;
   }
 
-  // Clear so we don't speak it again if the provider reconnects.
-  if (call.metadata) {
-    delete call.metadata.initialMessage;
-    persistCallRecord(ctx.storePath, call);
-  }
-
-  console.log(`[voice-call] Speaking initial message for call ${call.callId} (mode: ${mode})`);
-  const result = await speak(ctx, call.callId, initialMessage);
-  if (!result.success) {
-    console.warn(`[voice-call] Failed to speak initial message: ${result.error}`);
+  if (ctx.initialMessageInFlight.has(call.callId)) {
+    console.log(
+      `[voice-call] speakInitialMessage: initial message already in flight for ${call.callId}`,
+    );
     return;
   }
+  ctx.initialMessageInFlight.add(call.callId);
 
-  if (mode === "notify") {
-    const delaySec = ctx.config.outbound.notifyHangupDelaySec;
-    console.log(`[voice-call] Notify mode: auto-hangup in ${delaySec}s for call ${call.callId}`);
-    setTimeout(async () => {
-      const currentCall = ctx.activeCalls.get(call.callId);
-      if (currentCall && !TerminalStates.has(currentCall.state)) {
-        console.log(`[voice-call] Notify mode: hanging up call ${call.callId}`);
-        await endCall(ctx, call.callId);
-      }
-    }, delaySec * 1000);
+  try {
+    console.log(`[voice-call] Speaking initial message for call ${call.callId} (mode: ${mode})`);
+    const result = await speak(ctx, call.callId, initialMessage);
+    if (!result.success) {
+      console.warn(`[voice-call] Failed to speak initial message: ${result.error}`);
+      return;
+    }
+
+    // Clear only after successful playback so transient provider failures can retry.
+    if (call.metadata) {
+      delete call.metadata.initialMessage;
+      persistCallRecord(ctx.storePath, call);
+    }
+
+    if (mode === "notify") {
+      const delaySec = ctx.config.outbound.notifyHangupDelaySec;
+      console.log(`[voice-call] Notify mode: auto-hangup in ${delaySec}s for call ${call.callId}`);
+      setTimeout(async () => {
+        const currentCall = ctx.activeCalls.get(call.callId);
+        if (currentCall && !TerminalStates.has(currentCall.state)) {
+          console.log(`[voice-call] Notify mode: hanging up call ${call.callId}`);
+          await endCall(ctx, call.callId);
+        }
+      }, delaySec * 1000);
+    } else if (
+      mode === "conversation" &&
+      ctx.provider &&
+      shouldStartListeningAfterInitialMessage(ctx)
+    ) {
+      transitionState(call, "listening");
+      persistCallRecord(ctx.storePath, call);
+      await ctx.provider.startListening({
+        callId: call.callId,
+        providerCallId,
+      });
+    }
+  } finally {
+    ctx.initialMessageInFlight.delete(call.callId);
   }
 }
 
@@ -316,7 +425,7 @@ export async function continueCall(
         : 1;
 
     call.metadata = {
-      ...(call.metadata ?? {}),
+      ...call.metadata,
       turnCount,
       lastTurnLatencyMs,
       lastTurnListenWaitMs,
@@ -335,7 +444,7 @@ export async function continueCall(
 
     return { success: true, transcript };
   } catch (err) {
-    return { success: false, error: err instanceof Error ? err.message : String(err) };
+    return { success: false, error: formatErrorMessage(err) };
   } finally {
     ctx.activeTurnCalls.delete(callId);
     clearTranscriptWaiter(ctx, callId);
@@ -345,6 +454,7 @@ export async function continueCall(
 export async function endCall(
   ctx: EndCallContext,
   callId: CallId,
+  options?: { reason?: EndReason },
 ): Promise<{ success: boolean; error?: string }> {
   const lookup = lookupConnectedCall(ctx, callId);
   if (lookup.kind === "error") {
@@ -354,27 +464,23 @@ export async function endCall(
     return { success: true };
   }
   const { call, providerCallId, provider } = lookup;
+  const reason = options?.reason ?? "hangup-bot";
 
   try {
     await provider.hangupCall({
       callId,
       providerCallId,
-      reason: "hangup-bot",
+      reason,
     });
 
-    call.state = "hangup-bot";
-    call.endedAt = Date.now();
-    call.endReason = "hangup-bot";
-    persistCallRecord(ctx.storePath, call);
-
-    clearMaxDurationTimer(ctx, callId);
-    rejectTranscriptWaiter(ctx, callId, "Call ended: hangup-bot");
-
-    ctx.activeCalls.delete(callId);
-    ctx.providerCallIdMap.delete(providerCallId);
+    finalizeCall({
+      ctx,
+      call,
+      endReason: reason,
+    });
 
     return { success: true };
   } catch (err) {
-    return { success: false, error: err instanceof Error ? err.message : String(err) };
+    return { success: false, error: formatErrorMessage(err) };
   }
 }

package/src/manager/store.ts

@@ -3,13 +3,25 @@ import fsp from "node:fs/promises";
 import path from "node:path";
 import { CallRecordSchema, TerminalStates, type CallId, type CallRecord } from "../types.js";
 
+const pendingPersistWrites = new Set<Promise<void>>();
+
 export function persistCallRecord(storePath: string, call: CallRecord): void {
   const logPath = path.join(storePath, "calls.jsonl");
   const line = `${JSON.stringify(call)}\n`;
   // Fire-and-forget async write to avoid blocking event loop.
-  fsp.appendFile(logPath, line).catch((err) => {
-    console.error("[voice-call] Failed to persist call record:", err);
-  });
+  const write = fsp
+    .appendFile(logPath, line)
+    .catch((err) => {
+      console.error("[voice-call] Failed to persist call record:", err);
+    })
+    .finally(() => {
+      pendingPersistWrites.delete(write);
+    });
+  pendingPersistWrites.add(write);
+}
+
+export async function flushPendingCallRecordWritesForTest(): Promise<void> {
+  await Promise.allSettled(pendingPersistWrites);
 }
 
 export function loadActiveCallsFromStore(storePath: string): {
@@ -50,6 +62,9 @@ export function loadActiveCallsFromStore(storePath: string): {
   const rejectedProviderCallIds = new Set<string>();
 
   for (const [callId, call] of callMap) {
+    for (const eventId of call.processedEventIds) {
+      processedEventIds.add(eventId);
+    }
     if (TerminalStates.has(call.state)) {
       continue;
     }
@@ -57,9 +72,6 @@ export function loadActiveCallsFromStore(storePath: string): {
     if (call.providerCallId) {
       providerCallIdMap.set(call.providerCallId, callId);
     }
-    for (const eventId of call.processedEventIds) {
-      processedEventIds.add(eventId);
-    }
   }
 
   return { activeCalls, providerCallIdMap, processedEventIds, rejectedProviderCallIds };

package/src/manager/timers.test.ts

@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const { persistCallRecordMock } = vi.hoisted(() => ({
+  persistCallRecordMock: vi.fn(),
+}));
+
+vi.mock("./store.js", () => ({
+  persistCallRecord: persistCallRecordMock,
+}));
+
+import {
+  clearMaxDurationTimer,
+  clearTranscriptWaiter,
+  rejectTranscriptWaiter,
+  resolveTranscriptWaiter,
+  startMaxDurationTimer,
+  waitForFinalTranscript,
+} from "./timers.js";
+
+describe("voice-call manager timers", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("starts and clears max duration timers, persisting timeout metadata before delegation", async () => {
+    const call = { id: "call-1", state: "active" };
+    const ctx = {
+      activeCalls: new Map([["call-1", call]]),
+      maxDurationTimers: new Map(),
+      config: { maxDurationSeconds: 5 },
+      storePath: "/tmp/voice-call",
+    };
+    const onTimeout = vi.fn(async () => {});
+
+    startMaxDurationTimer({
+      ctx: ctx as never,
+      callId: "call-1",
+      onTimeout,
+    });
+
+    expect(ctx.maxDurationTimers.has("call-1")).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(5_000);
+
+    expect(call).toEqual({ id: "call-1", state: "active", endReason: "timeout" });
+    expect(persistCallRecordMock).toHaveBeenCalledWith("/tmp/voice-call", call);
+    expect(onTimeout).toHaveBeenCalledWith("call-1");
+    expect(ctx.maxDurationTimers.has("call-1")).toBe(false);
+
+    startMaxDurationTimer({
+      ctx: ctx as never,
+      callId: "call-1",
+      onTimeout,
+    });
+    clearMaxDurationTimer(ctx as never, "call-1");
+    expect(ctx.maxDurationTimers.has("call-1")).toBe(false);
+  });
+
+  it("does not time out terminal calls", async () => {
+    const ctx = {
+      activeCalls: new Map([["call-1", { id: "call-1", state: "completed" }]]),
+      maxDurationTimers: new Map(),
+      config: { maxDurationSeconds: 5 },
+      storePath: "/tmp/voice-call",
+    };
+    const onTimeout = vi.fn(async () => {});
+
+    startMaxDurationTimer({
+      ctx: ctx as never,
+      callId: "call-1",
+      onTimeout,
+    });
+
+    await vi.advanceTimersByTimeAsync(5_000);
+
+    expect(persistCallRecordMock).not.toHaveBeenCalled();
+    expect(onTimeout).not.toHaveBeenCalled();
+  });
+
+  it("waits for transcripts, resolves matching tokens, rejects mismatches and timeouts", async () => {
+    const ctx = {
+      transcriptWaiters: new Map(),
+      config: { transcriptTimeoutMs: 1_000 },
+    };
+
+    const pending = waitForFinalTranscript(ctx as never, "call-1", "turn-1");
+    expect(resolveTranscriptWaiter(ctx as never, "call-1", "ignored", "turn-2")).toBe(false);
+    expect(resolveTranscriptWaiter(ctx as never, "call-1", "final transcript", "turn-1")).toBe(
+      true,
+    );
+    await expect(pending).resolves.toBe("final transcript");
+
+    const another = waitForFinalTranscript(ctx as never, "call-2");
+    rejectTranscriptWaiter(ctx as never, "call-2", "provider failed");
+    await expect(another).rejects.toThrow("provider failed");
+
+    const timedOut = waitForFinalTranscript(ctx as never, "call-3").catch((error) => error);
+    await vi.advanceTimersByTimeAsync(1_000);
+    await expect(timedOut).resolves.toEqual(
+      expect.objectContaining({
+        message: "Timed out waiting for transcript after 1000ms",
+      }),
+    );
+
+    const toClear = waitForFinalTranscript(ctx as never, "call-4");
+    clearTranscriptWaiter(ctx as never, "call-4");
+    expect(ctx.transcriptWaiters.has("call-4")).toBe(false);
+    void toClear.catch(() => {});
+  });
+
+  it("rejects duplicate transcript waiters for the same call", async () => {
+    const ctx = {
+      transcriptWaiters: new Map(),
+      config: { transcriptTimeoutMs: 1_000 },
+    };
+
+    const pending = waitForFinalTranscript(ctx as never, "call-1");
+    await expect(waitForFinalTranscript(ctx as never, "call-1")).rejects.toThrow(
+      "Already waiting for transcript",
+    );
+    rejectTranscriptWaiter(ctx as never, "call-1", "done");
+    await expect(pending).rejects.toThrow("done");
+  });
+});

package/src/manager/timers.ts

@@ -27,12 +27,13 @@ export function startMaxDurationTimer(params: {
   ctx: MaxDurationTimerContext;
   callId: CallId;
   onTimeout: (callId: CallId) => Promise<void>;
+  timeoutMs?: number;
 }): void {
   clearMaxDurationTimer(params.ctx, params.callId);
 
-  const maxDurationMs = params.ctx.config.maxDurationSeconds * 1000;
+  const maxDurationMs = params.timeoutMs ?? params.ctx.config.maxDurationSeconds * 1000;
   console.log(
-    `[voice-call] Starting max duration timer (${params.ctx.config.maxDurationSeconds}s) for call ${params.callId}`,
+    `[voice-call] Starting max duration timer (${Math.ceil(maxDurationMs / 1000)}s) for call ${params.callId}`,
   );
 
   const timer = setTimeout(async () => {
@@ -40,7 +41,7 @@ export function startMaxDurationTimer(params: {
     const call = params.ctx.activeCalls.get(params.callId);
     if (call && !TerminalStates.has(call.state)) {
       console.log(
-        `[voice-call] Max duration reached (${params.ctx.config.maxDurationSeconds}s), ending call ${params.callId}`,
+        `[voice-call] Max duration reached (${Math.ceil(maxDurationMs / 1000)}s), ending call ${params.callId}`,
       );
       call.endReason = "timeout";
       persistCallRecord(params.ctx.storePath, call);

package/src/manager/twiml.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { generateNotifyTwiml } from "./twiml.js";
+
+describe("generateNotifyTwiml", () => {
+  it("renders escaped xml with the requested voice", () => {
+    expect(generateNotifyTwiml(`Call <ended> & "logged"`, "Polly.Joanna"))
+      .toBe(`<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <Say voice="Polly.Joanna">Call &lt;ended&gt; &amp; &quot;logged&quot;</Say>
+  <Hangup/>
+</Response>`);
+  });
+});

package/src/manager/twiml.ts

@@ -7,3 +7,11 @@ export function generateNotifyTwiml(message: string, voice: string): string {
   <Hangup/>
 </Response>`;
 }
+
+export function generateDtmfRedirectTwiml(digits: string, webhookUrl: string): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <Play digits="${escapeXml(digits)}" />
+  <Redirect method="POST">${escapeXml(webhookUrl)}</Redirect>
+</Response>`;
+}

package/src/manager.closed-loop.test.ts

@@ -1,6 +1,25 @@
 import { describe, expect, it } from "vitest";
 import { createManagerHarness, FakeProvider, markCallAnswered } from "./manager.test-harness.js";
 
+function requireCall(
+  manager: Awaited<ReturnType<typeof createManagerHarness>>["manager"],
+  callId: string,
+) {
+  const call = manager.getCall(callId);
+  if (!call) {
+    throw new Error(`expected active call ${callId}`);
+  }
+  return call;
+}
+
+function requireTurnToken(provider: Awaited<ReturnType<typeof createManagerHarness>>["provider"]) {
+  const firstStart = provider.startListeningCalls[0];
+  if (!firstStart?.turnToken) {
+    throw new Error("expected closed-loop turn to capture a turn token");
+  }
+  return firstStart.turnToken;
+}
+
 describe("CallManager closed-loop turns", () => {
   it("completes a closed-loop turn without live audio", async () => {
     const { manager, provider } = await createManagerHarness({
@@ -31,12 +50,12 @@ describe("CallManager closed-loop turns", () => {
     expect(provider.startListeningCalls).toHaveLength(1);
     expect(provider.stopListeningCalls).toHaveLength(1);
 
-    const call = manager.getCall(started.callId);
-    expect(call?.transcript.map((entry) => entry.text)).toEqual([
+    const call = requireCall(manager, started.callId);
+    expect(call.transcript.map((entry) => entry.text)).toEqual([
       "How can I help?",
       "Please check status",
     ]);
-    const metadata = (call?.metadata ?? {}) as Record<string, unknown>;
+    const metadata = call.metadata ?? {};
     expect(typeof metadata.lastTurnLatencyMs).toBe("number");
     expect(typeof metadata.lastTurnListenWaitMs).toBe("number");
     expect(metadata.turnCount).toBe(1);
@@ -90,8 +109,7 @@ describe("CallManager closed-loop turns", () => {
     const turnPromise = manager.continueCall(started.callId, "Prompt");
     await new Promise((resolve) => setTimeout(resolve, 0));
 
-    const expectedTurnToken = provider.startListeningCalls[0]?.turnToken;
-    expect(typeof expectedTurnToken).toBe("string");
+    const expectedTurnToken = requireTurnToken(provider);
 
     manager.processEvent({
       id: "evt-turn-token-bad",
@@ -125,8 +143,8 @@ describe("CallManager closed-loop turns", () => {
     expect(turnResult.success).toBe(true);
     expect(turnResult.transcript).toBe("final answer");
 
-    const call = manager.getCall(started.callId);
-    expect(call?.transcript.map((entry) => entry.text)).toEqual(["Prompt", "final answer"]);
+    const call = requireCall(manager, started.callId);
+    expect(call.transcript.map((entry) => entry.text)).toEqual(["Prompt", "final answer"]);
   });
 
   it("tracks latency metadata across multiple closed-loop turns", async () => {
@@ -167,14 +185,14 @@ describe("CallManager closed-loop turns", () => {
 
     expect(secondResult.success).toBe(true);
 
-    const call = manager.getCall(started.callId);
-    expect(call?.transcript.map((entry) => entry.text)).toEqual([
+    const call = requireCall(manager, started.callId);
+    expect(call.transcript.map((entry) => entry.text)).toEqual([
       "First question",
       "First answer",
       "Second question",
       "Second answer",
     ]);
-    const metadata = (call?.metadata ?? {}) as Record<string, unknown>;
+    const metadata = call.metadata ?? {};
     expect(metadata.turnCount).toBe(2);
     expect(typeof metadata.lastTurnLatencyMs).toBe("number");
     expect(typeof metadata.lastTurnListenWaitMs).toBe("number");
@@ -209,8 +227,8 @@ describe("CallManager closed-loop turns", () => {
       expect(result.transcript).toBe(`Answer ${i}`);
     }
 
-    const call = manager.getCall(started.callId);
-    const metadata = (call?.metadata ?? {}) as Record<string, unknown>;
+    const call = requireCall(manager, started.callId);
+    const metadata = call.metadata ?? {};
     expect(metadata.turnCount).toBe(5);
     expect(provider.startListeningCalls).toHaveLength(5);
     expect(provider.stopListeningCalls).toHaveLength(5);