@openclaw/voice-call 2026.2.15 → 2026.2.19

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2026.2.19
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.2.16
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
 ## 2026.2.15
 
 ### Changes

package/README.md

@@ -87,6 +87,26 @@ Notes:
 - Telnyx requires `telnyx.publicKey` (or `TELNYX_PUBLIC_KEY`) unless `skipSignatureVerification` is true.
 - `tunnel.allowNgrokFreeTierLoopbackBypass: true` allows Twilio webhooks with invalid signatures **only** when `tunnel.provider="ngrok"` and `serve.bind` is loopback (ngrok local agent). Use for local dev only.
 
+## Stale call reaper
+
+Use `staleCallReaperSeconds` to end calls that never receive a terminal webhook
+(for example, notify-mode calls that never complete). The default is `0`
+(disabled).
+
+Recommended ranges:
+
+- **Production:** `120`–`300` seconds for notify-style flows.
+- Keep this value **higher than `maxDurationSeconds`** so normal calls can
+  finish. A good starting point is `maxDurationSeconds + 30–60` seconds.
+
+Example:
+
+```json5
+{
+  staleCallReaperSeconds: 360,
+}
+```
+
 ## TTS for calls
 
 Voice Call uses the core `messages.tts` configuration (OpenAI or ElevenLabs) for

package/index.ts

@@ -1,6 +1,5 @@
-import type { GatewayRequestHandlerOptions, OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { Type } from "@sinclair/typebox";
-import type { CoreConfig } from "./src/core-bridge.js";
+import type { GatewayRequestHandlerOptions, OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { registerVoiceCallCli } from "./src/cli.js";
 import {
   VoiceCallConfigSchema,
@@ -8,6 +7,7 @@ import {
   validateProviderConfig,
   type VoiceCallConfig,
 } from "./src/config.js";
+import type { CoreConfig } from "./src/core-bridge.js";
 import { createVoiceCallRuntime, type VoiceCallRuntime } from "./src/runtime.js";
 
 const voiceCallConfigSchema = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.2.15",
+  "version": "2026.2.19",
   "description": "OpenClaw voice-call plugin",
   "type": "module",
   "dependencies": {

package/src/cli.ts

@@ -1,7 +1,7 @@
-import type { Command } from "commander";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import type { Command } from "commander";
 import { sleep } from "openclaw/plugin-sdk";
 import type { VoiceCallConfig } from "./config.js";
 import type { VoiceCallRuntime } from "./runtime.js";
@@ -41,6 +41,46 @@ function resolveDefaultStorePath(config: VoiceCallConfig): string {
   return path.join(base, "calls.jsonl");
 }
 
+function percentile(values: number[], p: number): number {
+  if (values.length === 0) {
+    return 0;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+  return sorted[idx] ?? 0;
+}
+
+function summarizeSeries(values: number[]): {
+  count: number;
+  minMs: number;
+  maxMs: number;
+  avgMs: number;
+  p50Ms: number;
+  p95Ms: number;
+} {
+  if (values.length === 0) {
+    return { count: 0, minMs: 0, maxMs: 0, avgMs: 0, p50Ms: 0, p95Ms: 0 };
+  }
+
+  const minMs = values.reduce(
+    (min, value) => (value < min ? value : min),
+    Number.POSITIVE_INFINITY,
+  );
+  const maxMs = values.reduce(
+    (max, value) => (value > max ? value : max),
+    Number.NEGATIVE_INFINITY,
+  );
+  const avgMs = values.reduce((sum, value) => sum + value, 0) / values.length;
+  return {
+    count: values.length,
+    minMs,
+    maxMs,
+    avgMs,
+    p50Ms: percentile(values, 50),
+    p95Ms: percentile(values, 95),
+  };
+}
+
 export function registerVoiceCallCli(params: {
   program: Command;
   config: VoiceCallConfig;
@@ -216,6 +256,57 @@ export function registerVoiceCallCli(params: {
       }
     });
 
+  root
+    .command("latency")
+    .description("Summarize turn latency metrics from voice-call JSONL logs")
+    .option("--file <path>", "Path to calls.jsonl", resolveDefaultStorePath(config))
+    .option("--last <n>", "Analyze last N records", "200")
+    .action(async (options: { file: string; last?: string }) => {
+      const file = options.file;
+      const last = Math.max(1, Number(options.last ?? 200));
+
+      if (!fs.existsSync(file)) {
+        throw new Error("No log file at " + file);
+      }
+
+      const content = fs.readFileSync(file, "utf8");
+      const lines = content.split("\n").filter(Boolean).slice(-last);
+
+      const turnLatencyMs: number[] = [];
+      const listenWaitMs: number[] = [];
+
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line) as {
+            metadata?: { lastTurnLatencyMs?: unknown; lastTurnListenWaitMs?: unknown };
+          };
+          const latency = parsed.metadata?.lastTurnLatencyMs;
+          const listenWait = parsed.metadata?.lastTurnListenWaitMs;
+          if (typeof latency === "number" && Number.isFinite(latency)) {
+            turnLatencyMs.push(latency);
+          }
+          if (typeof listenWait === "number" && Number.isFinite(listenWait)) {
+            listenWaitMs.push(listenWait);
+          }
+        } catch {
+          // ignore malformed JSON lines
+        }
+      }
+
+      // eslint-disable-next-line no-console
+      console.log(
+        JSON.stringify(
+          {
+            recordsScanned: lines.length,
+            turnLatency: summarizeSeries(turnLatencyMs),
+            listenWait: summarizeSeries(listenWaitMs),
+          },
+          null,
+          2,
+        ),
+      );
+    });
+
   root
     .command("expose")
     .description("Enable/disable Tailscale serve/funnel for the webhook")

package/src/config.test.ts

@@ -10,6 +10,7 @@ function createBaseConfig(provider: "telnyx" | "twilio" | "plivo" | "mock"): Voi
     allowFrom: [],
     outbound: { defaultMode: "notify", notifyHangupDelaySec: 3 },
     maxDurationSeconds: 300,
+    staleCallReaperSeconds: 600,
     silenceTimeoutMs: 800,
     transcriptTimeoutMs: 180000,
     ringTimeoutMs: 30000,
@@ -32,7 +33,10 @@ function createBaseConfig(provider: "telnyx" | "twilio" | "plivo" | "mock"): Voi
     },
     skipSignatureVerification: false,
     stt: { provider: "openai", model: "whisper-1" },
-    tts: { provider: "openai", model: "gpt-4o-mini-tts", voice: "coral" },
+    tts: {
+      provider: "openai",
+      openai: { model: "gpt-4o-mini-tts", voice: "coral" },
+    },
     responseModel: "openai/gpt-4o-mini",
     responseTimeoutMs: 30000,
   };
@@ -40,9 +44,7 @@ function createBaseConfig(provider: "telnyx" | "twilio" | "plivo" | "mock"): Voi
 
 describe("validateProviderConfig", () => {
   const originalEnv = { ...process.env };
-
-  beforeEach(() => {
-    // Clear all relevant env vars before each test
+  const clearProviderEnv = () => {
     delete process.env.TWILIO_ACCOUNT_SID;
     delete process.env.TWILIO_AUTH_TOKEN;
     delete process.env.TELNYX_API_KEY;
@@ -50,6 +52,10 @@ describe("validateProviderConfig", () => {
     delete process.env.TELNYX_PUBLIC_KEY;
     delete process.env.PLIVO_AUTH_ID;
     delete process.env.PLIVO_AUTH_TOKEN;
+  };
+
+  beforeEach(() => {
+    clearProviderEnv();
   });
 
   afterEach(() => {
@@ -57,29 +63,43 @@ describe("validateProviderConfig", () => {
     process.env = { ...originalEnv };
   });
 
-  describe("twilio provider", () => {
-    it("passes validation when credentials are in config", () => {
-      const config = createBaseConfig("twilio");
-      config.twilio = { accountSid: "AC123", authToken: "secret" };
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
-    it("passes validation when credentials are in environment variables", () => {
-      process.env.TWILIO_ACCOUNT_SID = "AC123";
-      process.env.TWILIO_AUTH_TOKEN = "secret";
-      let config = createBaseConfig("twilio");
-      config = resolveVoiceCallConfig(config);
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
+  describe("provider credential sources", () => {
+    it("passes validation when credentials come from config or environment", () => {
+      for (const provider of ["twilio", "telnyx", "plivo"] as const) {
+        clearProviderEnv();
+        const fromConfig = createBaseConfig(provider);
+        if (provider === "twilio") {
+          fromConfig.twilio = { accountSid: "AC123", authToken: "secret" };
+        } else if (provider === "telnyx") {
+          fromConfig.telnyx = {
+            apiKey: "KEY123",
+            connectionId: "CONN456",
+            publicKey: "public-key",
+          };
+        } else {
+          fromConfig.plivo = { authId: "MA123", authToken: "secret" };
+        }
+        expect(validateProviderConfig(fromConfig)).toMatchObject({ valid: true, errors: [] });
+
+        clearProviderEnv();
+        if (provider === "twilio") {
+          process.env.TWILIO_ACCOUNT_SID = "AC123";
+          process.env.TWILIO_AUTH_TOKEN = "secret";
+        } else if (provider === "telnyx") {
+          process.env.TELNYX_API_KEY = "KEY123";
+          process.env.TELNYX_CONNECTION_ID = "CONN456";
+          process.env.TELNYX_PUBLIC_KEY = "public-key";
+        } else {
+          process.env.PLIVO_AUTH_ID = "MA123";
+          process.env.PLIVO_AUTH_TOKEN = "secret";
+        }
+        const fromEnv = resolveVoiceCallConfig(createBaseConfig(provider));
+        expect(validateProviderConfig(fromEnv)).toMatchObject({ valid: true, errors: [] });
+      }
     });
+  });
 
+  describe("twilio provider", () => {
     it("passes validation with mixed config and env vars", () => {
       process.env.TWILIO_AUTH_TOKEN = "secret";
       let config = createBaseConfig("twilio");
@@ -92,57 +112,27 @@ describe("validateProviderConfig", () => {
       expect(result.errors).toEqual([]);
     });
 
-    it("fails validation when accountSid is missing everywhere", () => {
+    it("fails validation when required twilio credentials are missing", () => {
       process.env.TWILIO_AUTH_TOKEN = "secret";
-      let config = createBaseConfig("twilio");
-      config = resolveVoiceCallConfig(config);
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain(
+      const missingSid = validateProviderConfig(resolveVoiceCallConfig(createBaseConfig("twilio")));
+      expect(missingSid.valid).toBe(false);
+      expect(missingSid.errors).toContain(
         "plugins.entries.voice-call.config.twilio.accountSid is required (or set TWILIO_ACCOUNT_SID env)",
       );
-    });
 
-    it("fails validation when authToken is missing everywhere", () => {
+      delete process.env.TWILIO_AUTH_TOKEN;
       process.env.TWILIO_ACCOUNT_SID = "AC123";
-      let config = createBaseConfig("twilio");
-      config = resolveVoiceCallConfig(config);
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain(
+      const missingToken = validateProviderConfig(
+        resolveVoiceCallConfig(createBaseConfig("twilio")),
+      );
+      expect(missingToken.valid).toBe(false);
+      expect(missingToken.errors).toContain(
         "plugins.entries.voice-call.config.twilio.authToken is required (or set TWILIO_AUTH_TOKEN env)",
       );
     });
   });
 
   describe("telnyx provider", () => {
-    it("passes validation when credentials are in config", () => {
-      const config = createBaseConfig("telnyx");
-      config.telnyx = { apiKey: "KEY123", connectionId: "CONN456", publicKey: "public-key" };
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
-    it("passes validation when credentials are in environment variables", () => {
-      process.env.TELNYX_API_KEY = "KEY123";
-      process.env.TELNYX_CONNECTION_ID = "CONN456";
-      process.env.TELNYX_PUBLIC_KEY = "public-key";
-      let config = createBaseConfig("telnyx");
-      config = resolveVoiceCallConfig(config);
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
     it("fails validation when apiKey is missing everywhere", () => {
       process.env.TELNYX_CONNECTION_ID = "CONN456";
       let config = createBaseConfig("telnyx");
@@ -156,69 +146,36 @@ describe("validateProviderConfig", () => {
       );
     });
 
-    it("fails validation when allowlist inbound policy lacks public key", () => {
-      const config = createBaseConfig("telnyx");
-      config.inboundPolicy = "allowlist";
-      config.telnyx = { apiKey: "KEY123", connectionId: "CONN456" };
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(false);
-      expect(result.errors).toContain(
+    it("requires a public key unless signature verification is skipped", () => {
+      const missingPublicKey = createBaseConfig("telnyx");
+      missingPublicKey.inboundPolicy = "allowlist";
+      missingPublicKey.telnyx = { apiKey: "KEY123", connectionId: "CONN456" };
+      const missingPublicKeyResult = validateProviderConfig(missingPublicKey);
+      expect(missingPublicKeyResult.valid).toBe(false);
+      expect(missingPublicKeyResult.errors).toContain(
         "plugins.entries.voice-call.config.telnyx.publicKey is required (or set TELNYX_PUBLIC_KEY env)",
       );
-    });
 
-    it("passes validation when allowlist inbound policy has public key", () => {
-      const config = createBaseConfig("telnyx");
-      config.inboundPolicy = "allowlist";
-      config.telnyx = {
+      const withPublicKey = createBaseConfig("telnyx");
+      withPublicKey.inboundPolicy = "allowlist";
+      withPublicKey.telnyx = {
         apiKey: "KEY123",
         connectionId: "CONN456",
         publicKey: "public-key",
       };
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
-    it("passes validation when skipSignatureVerification is true (even without public key)", () => {
-      const config = createBaseConfig("telnyx");
-      config.skipSignatureVerification = true;
-      config.telnyx = { apiKey: "KEY123", connectionId: "CONN456" };
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
+      expect(validateProviderConfig(withPublicKey)).toMatchObject({ valid: true, errors: [] });
+
+      const skippedVerification = createBaseConfig("telnyx");
+      skippedVerification.skipSignatureVerification = true;
+      skippedVerification.telnyx = { apiKey: "KEY123", connectionId: "CONN456" };
+      expect(validateProviderConfig(skippedVerification)).toMatchObject({
+        valid: true,
+        errors: [],
+      });
     });
   });
 
   describe("plivo provider", () => {
-    it("passes validation when credentials are in config", () => {
-      const config = createBaseConfig("plivo");
-      config.plivo = { authId: "MA123", authToken: "secret" };
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
-    it("passes validation when credentials are in environment variables", () => {
-      process.env.PLIVO_AUTH_ID = "MA123";
-      process.env.PLIVO_AUTH_TOKEN = "secret";
-      let config = createBaseConfig("plivo");
-      config = resolveVoiceCallConfig(config);
-
-      const result = validateProviderConfig(config);
-
-      expect(result.valid).toBe(true);
-      expect(result.errors).toEqual([]);
-    });
-
     it("fails validation when authId is missing everywhere", () => {
       process.env.PLIVO_AUTH_TOKEN = "secret";
       let config = createBaseConfig("plivo");

package/src/config.ts

@@ -273,6 +273,14 @@ export const VoiceCallConfigSchema = z
     /** Maximum call duration in seconds */
     maxDurationSeconds: z.number().int().positive().default(300),
 
+    /**
+     * Maximum age of a call in seconds before it is automatically reaped.
+     * Catches calls stuck in unexpected states (e.g., notify-mode calls that
+     * never receive a terminal webhook). Set to 0 to disable.
+     * Default: 0 (disabled). Recommended: 120-300 for production.
+     */
+    staleCallReaperSeconds: z.number().int().nonnegative().default(0),
+
     /** Silence timeout for end-of-speech detection (ms) */
     silenceTimeoutMs: z.number().int().positive().default(800),
 

package/src/manager/context.ts

@@ -24,6 +24,7 @@ export type CallManagerRuntimeDeps = {
 };
 
 export type CallManagerTransientState = {
+  activeTurnCalls: Set<CallId>;
   transcriptWaiters: Map<CallId, TranscriptWaiter>;
   maxDurationTimers: Map<CallId, NodeJS.Timeout>;
 };

package/src/manager/events.test.ts

@@ -2,9 +2,10 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { describe, expect, it } from "vitest";
+import { VoiceCallConfigSchema } from "../config.js";
+import type { VoiceCallProvider } from "../providers/base.js";
 import type { HangupCallInput, NormalizedEvent } from "../types.js";
 import type { CallManagerContext } from "./context.js";
-import { VoiceCallConfigSchema } from "../config.js";
 import { processEvent } from "./events.js";
 
 function createContext(overrides: Partial<CallManagerContext> = {}): CallManagerContext {
@@ -23,21 +24,35 @@ function createContext(overrides: Partial<CallManagerContext> = {}): CallManager
     }),
     storePath,
     webhookUrl: null,
+    activeTurnCalls: new Set(),
     transcriptWaiters: new Map(),
     maxDurationTimers: new Map(),
     ...overrides,
   };
 }
 
+function createProvider(overrides: Partial<VoiceCallProvider> = {}): VoiceCallProvider {
+  return {
+    name: "plivo",
+    verifyWebhook: () => ({ ok: true }),
+    parseWebhookEvent: () => ({ events: [] }),
+    initiateCall: async () => ({ providerCallId: "provider-call-id", status: "initiated" }),
+    hangupCall: async () => {},
+    playTts: async () => {},
+    startListening: async () => {},
+    stopListening: async () => {},
+    ...overrides,
+  };
+}
+
 describe("processEvent (functional)", () => {
   it("calls provider hangup when rejecting inbound call", () => {
     const hangupCalls: HangupCallInput[] = [];
-    const provider = {
-      name: "plivo" as const,
-      async hangupCall(input: HangupCallInput): Promise<void> {
+    const provider = createProvider({
+      hangupCall: async (input: HangupCallInput): Promise<void> => {
         hangupCalls.push(input);
       },
-    };
+    });
 
     const ctx = createContext({
       config: VoiceCallConfigSchema.parse({
@@ -98,12 +113,11 @@ describe("processEvent (functional)", () => {
 
   it("calls hangup only once for duplicate events for same rejected call", () => {
     const hangupCalls: HangupCallInput[] = [];
-    const provider = {
-      name: "plivo" as const,
-      async hangupCall(input: HangupCallInput): Promise<void> {
+    const provider = createProvider({
+      hangupCall: async (input: HangupCallInput): Promise<void> => {
         hangupCalls.push(input);
       },
-    };
+    });
     const ctx = createContext({
       config: VoiceCallConfigSchema.parse({
         enabled: true,
@@ -208,12 +222,11 @@ describe("processEvent (functional)", () => {
   });
 
   it("when hangup throws, logs and does not throw", () => {
-    const provider = {
-      name: "plivo" as const,
-      async hangupCall(): Promise<void> {
+    const provider = createProvider({
+      hangupCall: async (): Promise<void> => {
         throw new Error("provider down");
       },
-    };
+    });
     const ctx = createContext({
       config: VoiceCallConfigSchema.parse({
         enabled: true,

package/src/manager/events.ts

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
+import { isAllowlistedCaller, normalizePhoneNumber } from "../allowlist.js";
 import type { CallRecord, CallState, NormalizedEvent } from "../types.js";
 import type { CallManagerContext } from "./context.js";
-import { isAllowlistedCaller, normalizePhoneNumber } from "../allowlist.js";
 import { findCall } from "./lookup.js";
 import { endCall } from "./outbound.js";
 import { addTranscriptEntry, transitionState } from "./state.js";

package/src/manager/outbound.ts

@@ -1,6 +1,5 @@
 import crypto from "node:crypto";
 import type { CallMode } from "../config.js";
-import type { CallManagerContext } from "./context.js";
 import {
   TerminalStates,
   type CallId,
@@ -8,6 +7,7 @@ import {
   type OutboundCallOptions,
 } from "../types.js";
 import { mapVoiceToPolly } from "../voice-mapping.js";
+import type { CallManagerContext } from "./context.js";
 import { getCallByProviderCallId } from "./lookup.js";
 import { addTranscriptEntry, transitionState } from "./state.js";
 import { persistCallRecord } from "./store.js";
@@ -36,6 +36,7 @@ type ConversationContext = Pick<
   | "provider"
   | "config"
   | "storePath"
+  | "activeTurnCalls"
   | "transcriptWaiters"
   | "maxDurationTimers"
 >;
@@ -158,7 +159,6 @@ export async function speak(
   if (TerminalStates.has(call.state)) {
     return { success: false, error: "Call has ended" };
   }
-
   try {
     transitionState(call, "speaking");
     persistCallRecord(ctx.storePath, call);
@@ -242,6 +242,12 @@ export async function continueCall(
   if (TerminalStates.has(call.state)) {
     return { success: false, error: "Call has ended" };
   }
+  if (ctx.activeTurnCalls.has(callId) || ctx.transcriptWaiters.has(callId)) {
+    return { success: false, error: "Already waiting for transcript" };
+  }
+  ctx.activeTurnCalls.add(callId);
+
+  const turnStartedAt = Date.now();
 
   try {
     await speak(ctx, callId, prompt);
@@ -249,17 +255,45 @@ export async function continueCall(
     transitionState(call, "listening");
     persistCallRecord(ctx.storePath, call);
 
+    const listenStartedAt = Date.now();
     await ctx.provider.startListening({ callId, providerCallId: call.providerCallId });
 
     const transcript = await waitForFinalTranscript(ctx, callId);
+    const transcriptReceivedAt = Date.now();
 
     // Best-effort: stop listening after final transcript.
     await ctx.provider.stopListening({ callId, providerCallId: call.providerCallId });
 
+    const lastTurnLatencyMs = transcriptReceivedAt - turnStartedAt;
+    const lastTurnListenWaitMs = transcriptReceivedAt - listenStartedAt;
+    const turnCount =
+      call.metadata && typeof call.metadata.turnCount === "number"
+        ? call.metadata.turnCount + 1
+        : 1;
+
+    call.metadata = {
+      ...(call.metadata ?? {}),
+      turnCount,
+      lastTurnLatencyMs,
+      lastTurnListenWaitMs,
+      lastTurnCompletedAt: transcriptReceivedAt,
+    };
+    persistCallRecord(ctx.storePath, call);
+
+    console.log(
+      "[voice-call] continueCall latency call=" +
+        call.callId +
+        " totalMs=" +
+        String(lastTurnLatencyMs) +
+        " listenWaitMs=" +
+        String(lastTurnListenWaitMs),
+    );
+
     return { success: true, transcript };
   } catch (err) {
     return { success: false, error: err instanceof Error ? err.message : String(err) };
   } finally {
+    ctx.activeTurnCalls.delete(callId);
     clearTranscriptWaiter(ctx, callId);
   }
 }

package/src/manager/timers.ts

@@ -1,5 +1,5 @@
-import type { CallManagerContext } from "./context.js";
 import { TerminalStates, type CallId } from "../types.js";
+import type { CallManagerContext } from "./context.js";
 import { persistCallRecord } from "./store.js";
 
 type TimerContext = Pick<
@@ -87,8 +87,9 @@ export function resolveTranscriptWaiter(
 }
 
 export function waitForFinalTranscript(ctx: TimerContext, callId: CallId): Promise<string> {
-  // Only allow one in-flight waiter per call.
-  rejectTranscriptWaiter(ctx, callId, "Transcript waiter replaced");
+  if (ctx.transcriptWaiters.has(callId)) {
+    return Promise.reject(new Error("Already waiting for transcript"));
+  }
 
   const timeoutMs = ctx.config.transcriptTimeoutMs;
   return new Promise((resolve, reject) => {