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

package/src/manager/events.ts

@@ -1,17 +1,14 @@
 import crypto from "node:crypto";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isAllowlistedCaller, normalizePhoneNumber } from "../allowlist.js";
-import type { CallRecord, CallState, NormalizedEvent } from "../types.js";
+import type { CallRecord, NormalizedEvent } from "../types.js";
 import type { CallManagerContext } from "./context.js";
+import { finalizeCall } from "./lifecycle.js";
 import { findCall } from "./lookup.js";
 import { endCall } from "./outbound.js";
 import { addTranscriptEntry, transitionState } from "./state.js";
 import { persistCallRecord } from "./store.js";
-import {
-  clearMaxDurationTimer,
-  rejectTranscriptWaiter,
-  resolveTranscriptWaiter,
-  startMaxDurationTimer,
-} from "./timers.js";
+import { resolveTranscriptWaiter, startMaxDurationTimer } from "./timers.js";
 
 type EventContext = Pick<
   CallManagerContext,
@@ -102,7 +99,6 @@ export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
   if (ctx.processedEventIds.has(dedupeKey)) {
     return;
   }
-  ctx.processedEventIds.add(dedupeKey);
 
   let call = findCall({
     activeCalls: ctx.activeCalls,
@@ -128,6 +124,7 @@ export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
         );
         return;
       }
+      ctx.processedEventIds.add(dedupeKey);
       if (ctx.rejectedProviderCallIds.has(pid)) {
         return;
       }
@@ -141,7 +138,8 @@ export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
           reason: "hangup-bot",
         })
         .catch((err) => {
-          const message = err instanceof Error ? err.message : String(err);
+          ctx.rejectedProviderCallIds.delete(pid);
+          const message = formatErrorMessage(err);
           console.warn(`[voice-call] Failed to reject inbound call ${pid}:`, message);
         });
       return;
@@ -175,11 +173,29 @@ export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
     }
   }
 
-  call.processedEventIds.push(dedupeKey);
+  const shouldCommitReplayKey = !(event.type === "call.error" && event.retryable);
+  if (shouldCommitReplayKey) {
+    ctx.processedEventIds.add(dedupeKey);
+    call.processedEventIds.push(dedupeKey);
+  }
 
   switch (event.type) {
     case "call.initiated":
       transitionState(call, "initiated");
+      if (call.direction === "inbound" && call.providerCallId && ctx.provider?.answerCall) {
+        void ctx.provider
+          .answerCall({
+            callId: call.callId,
+            providerCallId: call.providerCallId,
+          })
+          .catch((err) => {
+            const message = formatErrorMessage(err);
+            console.warn(
+              `[voice-call] Failed to answer inbound call ${call.providerCallId}:`,
+              message,
+            );
+          });
+      }
       break;
 
     case "call.ringing":
@@ -193,7 +209,7 @@ export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
         ctx,
         callId: call.callId,
         onTimeout: async (callId) => {
-          await endCall(ctx, callId);
+          await endCall(ctx, callId, { reason: "timeout" });
         },
       });
       ctx.onCallAnswered?.(call);
@@ -227,30 +243,32 @@ export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
       transitionState(call, "listening");
       break;
 
-    case "call.ended":
-      call.endedAt = event.timestamp;
-      call.endReason = event.reason;
-      transitionState(call, event.reason as CallState);
-      clearMaxDurationTimer(ctx, call.callId);
-      rejectTranscriptWaiter(ctx, call.callId, `Call ended: ${event.reason}`);
-      ctx.activeCalls.delete(call.callId);
-      if (call.providerCallId) {
-        ctx.providerCallIdMap.delete(call.providerCallId);
-      }
+    case "call.silence":
+    case "call.dtmf":
       break;
 
+    case "call.ended":
+      finalizeCall({
+        ctx,
+        call,
+        endReason: event.reason,
+        endedAt: event.timestamp,
+      });
+      return;
+
     case "call.error":
       if (!event.retryable) {
-        call.endedAt = event.timestamp;
-        call.endReason = "error";
-        transitionState(call, "error");
-        clearMaxDurationTimer(ctx, call.callId);
-        rejectTranscriptWaiter(ctx, call.callId, `Call error: ${event.error}`);
-        ctx.activeCalls.delete(call.callId);
-        if (call.providerCallId) {
-          ctx.providerCallIdMap.delete(call.providerCallId);
-        }
+        finalizeCall({
+          ctx,
+          call,
+          endReason: "error",
+          endedAt: event.timestamp,
+          transcriptRejectReason: `Call error: ${event.error}`,
+        });
+        return;
       }
+      // Keep retryable provider errors replayable so a redelivery can still
+      // drive later recovery or terminal handling for the same event key.
       break;
   }
 

package/src/manager/lifecycle.ts

@@ -0,0 +1,53 @@
+import type { CallRecord, EndReason } from "../types.js";
+import type { CallManagerContext } from "./context.js";
+import { transitionState } from "./state.js";
+import { persistCallRecord } from "./store.js";
+import { clearMaxDurationTimer, rejectTranscriptWaiter } from "./timers.js";
+
+type CallLifecycleContext = Pick<
+  CallManagerContext,
+  "activeCalls" | "providerCallIdMap" | "storePath"
+> &
+  Partial<Pick<CallManagerContext, "transcriptWaiters" | "maxDurationTimers">>;
+
+function removeProviderCallMapping(
+  providerCallIdMap: Map<string, string>,
+  call: Pick<CallRecord, "callId" | "providerCallId">,
+): void {
+  if (!call.providerCallId) {
+    return;
+  }
+  const mappedCallId = providerCallIdMap.get(call.providerCallId);
+  if (mappedCallId === call.callId) {
+    providerCallIdMap.delete(call.providerCallId);
+  }
+}
+
+export function finalizeCall(params: {
+  ctx: CallLifecycleContext;
+  call: CallRecord;
+  endReason: EndReason;
+  endedAt?: number;
+  transcriptRejectReason?: string;
+}): void {
+  const { ctx, call, endReason } = params;
+
+  call.endedAt = params.endedAt ?? Date.now();
+  call.endReason = endReason;
+  transitionState(call, endReason);
+  persistCallRecord(ctx.storePath, call);
+
+  if (ctx.maxDurationTimers) {
+    clearMaxDurationTimer({ maxDurationTimers: ctx.maxDurationTimers }, call.callId);
+  }
+  if (ctx.transcriptWaiters) {
+    rejectTranscriptWaiter(
+      { transcriptWaiters: ctx.transcriptWaiters },
+      call.callId,
+      params.transcriptRejectReason ?? `Call ended: ${endReason}`,
+    );
+  }
+
+  ctx.activeCalls.delete(call.callId);
+  removeProviderCallMapping(ctx.providerCallIdMap, call);
+}

package/src/manager/lookup.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { findCall, getCallByProviderCallId } from "./lookup.js";
+
+describe("voice-call manager lookup", () => {
+  it("resolves provider call ids from the explicit map first", () => {
+    const activeCalls = new Map([
+      ["call-1", { id: "call-1", providerCallId: "prov-1" }],
+      ["call-2", { id: "call-2", providerCallId: "prov-2" }],
+    ]);
+    const providerCallIdMap = new Map([["provider-lookup", "call-2"]]);
+
+    expect(
+      getCallByProviderCallId({
+        activeCalls: activeCalls as never,
+        providerCallIdMap,
+        providerCallId: "provider-lookup",
+      }),
+    ).toEqual({ id: "call-2", providerCallId: "prov-2" });
+  });
+
+  it("falls back to scanning active calls and supports direct call ids", () => {
+    const activeCalls = new Map([
+      ["call-1", { id: "call-1", providerCallId: "prov-1" }],
+      ["call-2", { id: "call-2", providerCallId: "prov-2" }],
+    ]);
+    const providerCallIdMap = new Map<string, string>();
+
+    expect(
+      getCallByProviderCallId({
+        activeCalls: activeCalls as never,
+        providerCallIdMap,
+        providerCallId: "prov-1",
+      }),
+    ).toEqual({ id: "call-1", providerCallId: "prov-1" });
+
+    expect(
+      findCall({
+        activeCalls: activeCalls as never,
+        providerCallIdMap,
+        callIdOrProviderCallId: "call-2",
+      }),
+    ).toEqual({ id: "call-2", providerCallId: "prov-2" });
+
+    expect(
+      findCall({
+        activeCalls: activeCalls as never,
+        providerCallIdMap,
+        callIdOrProviderCallId: "missing",
+      }),
+    ).toBeUndefined();
+  });
+});