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

package/src/deep-merge.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { deepMergeDefined } from "./deep-merge.js";
+
+describe("deepMergeDefined", () => {
+  it("deep merges nested plain objects and preserves base values for undefined overrides", () => {
+    expect(
+      deepMergeDefined(
+        {
+          provider: { voice: "alloy", language: "en" },
+          enabled: true,
+        },
+        {
+          provider: { voice: "echo", language: undefined },
+          enabled: undefined,
+        },
+      ),
+    ).toEqual({
+      provider: { voice: "echo", language: "en" },
+      enabled: true,
+    });
+  });
+
+  it("replaces non-objects directly and blocks dangerous prototype keys", () => {
+    expect(deepMergeDefined(["a"], ["b"])).toEqual(["b"]);
+    expect(deepMergeDefined("base", undefined)).toBe("base");
+    expect(
+      deepMergeDefined(
+        { safe: { keep: true } },
+        {
+          safe: { next: true },
+          __proto__: { polluted: true },
+          constructor: { polluted: true },
+          prototype: { polluted: true },
+        },
+      ),
+    ).toEqual({
+      safe: { keep: true, next: true },
+    });
+  });
+});

package/src/gateway-continue-operation.ts

@@ -0,0 +1,200 @@
+import { randomUUID } from "node:crypto";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import type { VoiceCallConfig } from "./config.js";
+import type { CoreConfig } from "./core-bridge.js";
+import type { VoiceCallRuntime } from "./runtime.js";
+import { TELEPHONY_DEFAULT_TTS_TIMEOUT_MS } from "./telephony-tts.js";
+
+const VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS = 30000;
+const VOICE_CALL_CONTINUE_OPERATION_CLEANUP_MS = 5 * 60 * 1000;
+
+type VoiceCallContinueOperation =
+  | {
+      operationId: string;
+      status: "pending";
+      callId: string;
+      startedAtMs: number;
+      pollTimeoutMs: number;
+    }
+  | {
+      operationId: string;
+      status: "completed";
+      callId: string;
+      startedAtMs: number;
+      completedAtMs: number;
+      pollTimeoutMs: number;
+      result: { success: true; transcript?: string };
+    }
+  | {
+      operationId: string;
+      status: "failed";
+      callId: string;
+      startedAtMs: number;
+      completedAtMs: number;
+      pollTimeoutMs: number;
+      error: string;
+    };
+
+type VoiceCallContinueOperationStartPayload = {
+  operationId: string;
+  status: "pending";
+  pollTimeoutMs: number;
+};
+
+type VoiceCallContinueOperationResultPayload =
+  | {
+      operationId: string;
+      status: "pending";
+      pollTimeoutMs: number;
+    }
+  | {
+      operationId: string;
+      status: "completed";
+      result: { success: true; transcript?: string };
+    }
+  | {
+      operationId: string;
+      status: "failed";
+      error: string;
+    };
+
+type VoiceCallContinueOperationRequest = {
+  rt: VoiceCallRuntime;
+  callId: string;
+  message: string;
+};
+
+export function createVoiceCallContinueOperationStore(params: {
+  config: VoiceCallConfig;
+  coreConfig: CoreConfig;
+}) {
+  const operations = new Map<string, VoiceCallContinueOperation>();
+
+  const resolvePollTimeoutMs = (rt: VoiceCallRuntime): number => {
+    const ttsTimeoutMs =
+      rt.config.tts?.timeoutMs ??
+      params.config.tts?.timeoutMs ??
+      params.coreConfig.messages?.tts?.timeoutMs ??
+      TELEPHONY_DEFAULT_TTS_TIMEOUT_MS;
+    return (
+      (rt.config.transcriptTimeoutMs ?? params.config.transcriptTimeoutMs) +
+      ttsTimeoutMs +
+      VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS
+    );
+  };
+
+  const scheduleCleanup = (operationId: string) => {
+    const timer = setTimeout(() => {
+      operations.delete(operationId);
+    }, VOICE_CALL_CONTINUE_OPERATION_CLEANUP_MS);
+    timer.unref?.();
+  };
+
+  const start = (
+    request: VoiceCallContinueOperationRequest,
+  ): VoiceCallContinueOperationStartPayload => {
+    const operationId = randomUUID();
+    const startedAtMs = Date.now();
+    const pollTimeoutMs = resolvePollTimeoutMs(request.rt);
+    operations.set(operationId, {
+      operationId,
+      status: "pending",
+      callId: request.callId,
+      startedAtMs,
+      pollTimeoutMs,
+    });
+
+    void request.rt.manager
+      .continueCall(request.callId, request.message)
+      .then((result) => {
+        const current = operations.get(operationId);
+        if (!current || current.status !== "pending") {
+          return;
+        }
+        if (!result.success) {
+          operations.set(operationId, {
+            operationId,
+            status: "failed",
+            callId: request.callId,
+            startedAtMs,
+            completedAtMs: Date.now(),
+            pollTimeoutMs,
+            error: result.error || "continue failed",
+          });
+          return;
+        }
+        operations.set(operationId, {
+          operationId,
+          status: "completed",
+          callId: request.callId,
+          startedAtMs,
+          completedAtMs: Date.now(),
+          pollTimeoutMs,
+          result: { success: true, transcript: result.transcript },
+        });
+      })
+      .catch((err) => {
+        const current = operations.get(operationId);
+        if (!current || current.status !== "pending") {
+          return;
+        }
+        operations.set(operationId, {
+          operationId,
+          status: "failed",
+          callId: request.callId,
+          startedAtMs,
+          completedAtMs: Date.now(),
+          pollTimeoutMs,
+          error: formatErrorMessage(err),
+        });
+      })
+      .finally(() => {
+        scheduleCleanup(operationId);
+      });
+
+    return { operationId, status: "pending", pollTimeoutMs };
+  };
+
+  const read = (
+    operationId: string,
+  ):
+    | { ok: true; payload: VoiceCallContinueOperationResultPayload }
+    | { ok: false; error: string } => {
+    const operation = operations.get(operationId);
+    if (!operation) {
+      return { ok: false, error: "operation not found" };
+    }
+    if (operation.status === "pending") {
+      return {
+        ok: true,
+        payload: {
+          operationId,
+          status: "pending",
+          pollTimeoutMs: operation.pollTimeoutMs,
+        },
+      };
+    }
+    if (operation.status === "failed") {
+      operations.delete(operationId);
+      return {
+        ok: true,
+        payload: {
+          operationId,
+          status: "failed",
+          error: operation.error,
+        },
+      };
+    }
+    operations.delete(operationId);
+    return {
+      ok: true,
+      payload: {
+        operationId,
+        status: "completed",
+        result: operation.result,
+      },
+    };
+  };
+
+  return { start, read };
+}

package/src/http-headers.ts

@@ -1,10 +1,13 @@
-export type HttpHeaderMap = Record<string, string | string[] | undefined>;
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+
+type HttpHeaderMap = Record<string, string | string[] | undefined>;
 
 export function getHeader(headers: HttpHeaderMap, name: string): string | undefined {
-  const target = name.toLowerCase();
+  const target = normalizeLowercaseStringOrEmpty(name);
   const direct = headers[target];
   const value =
-    direct ?? Object.entries(headers).find(([key]) => key.toLowerCase() === target)?.[1];
+    direct ??
+    Object.entries(headers).find(([key]) => normalizeLowercaseStringOrEmpty(key) === target)?.[1];
   if (Array.isArray(value)) {
     return value[0];
   }

package/src/manager/context.ts

@@ -2,14 +2,14 @@ import type { VoiceCallConfig } from "../config.js";
 import type { VoiceCallProvider } from "../providers/base.js";
 import type { CallId, CallRecord } from "../types.js";
 
-export type TranscriptWaiter = {
+type TranscriptWaiter = {
   resolve: (text: string) => void;
   reject: (err: Error) => void;
   timeout: NodeJS.Timeout;
   turnToken?: string;
 };
 
-export type CallManagerRuntimeState = {
+type CallManagerRuntimeState = {
   activeCalls: Map<CallId, CallRecord>;
   providerCallIdMap: Map<string, CallId>;
   processedEventIds: Set<string>;
@@ -17,20 +17,21 @@ export type CallManagerRuntimeState = {
   rejectedProviderCallIds: Set<string>;
 };
 
-export type CallManagerRuntimeDeps = {
+type CallManagerRuntimeDeps = {
   provider: VoiceCallProvider | null;
   config: VoiceCallConfig;
   storePath: string;
   webhookUrl: string | null;
 };
 
-export type CallManagerTransientState = {
+type CallManagerTransientState = {
   activeTurnCalls: Set<CallId>;
   transcriptWaiters: Map<CallId, TranscriptWaiter>;
   maxDurationTimers: Map<CallId, NodeJS.Timeout>;
+  initialMessageInFlight: Set<CallId>;
 };
 
-export type CallManagerHooks = {
+type CallManagerHooks = {
   /** Optional runtime hook invoked after an event transitions a call into answered state. */
   onCallAnswered?: (call: CallRecord) => void;
 };

package/src/manager/events.test.ts

@@ -1,17 +1,34 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { describe, expect, it } from "vitest";
+import { afterEach, 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 { AnswerCallInput, HangupCallInput, NormalizedEvent } from "../types.js";
 import type { CallManagerContext } from "./context.js";
 import { processEvent } from "./events.js";
+import { flushPendingCallRecordWritesForTest } from "./store.js";
+
+const contexts: CallManagerContext[] = [];
+
+afterEach(async () => {
+  for (const ctx of contexts.splice(0)) {
+    for (const timer of ctx.maxDurationTimers.values()) {
+      clearTimeout(timer);
+    }
+    ctx.maxDurationTimers.clear();
+    for (const waiter of ctx.transcriptWaiters.values()) {
+      clearTimeout(waiter.timeout);
+    }
+    ctx.transcriptWaiters.clear();
+    await flushPendingCallRecordWritesForTest();
+    fs.rmSync(ctx.storePath, { recursive: true, force: true });
+  }
+});
 
 function createContext(overrides: Partial<CallManagerContext> = {}): CallManagerContext {
-  const storePath = path.join(os.tmpdir(), `openclaw-voice-call-events-test-${Date.now()}`);
-  fs.mkdirSync(storePath, { recursive: true });
-  return {
+  const storePath = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-voice-call-events-test-"));
+  const ctx: CallManagerContext = {
     activeCalls: new Map(),
     providerCallIdMap: new Map(),
     processedEventIds: new Set(),
@@ -27,8 +44,11 @@ function createContext(overrides: Partial<CallManagerContext> = {}): CallManager
     activeTurnCalls: new Set(),
     transcriptWaiters: new Map(),
     maxDurationTimers: new Map(),
+    initialMessageInFlight: new Set(),
     ...overrides,
   };
+  contexts.push(ctx);
+  return ctx;
 }
 
 function createProvider(overrides: Partial<VoiceCallProvider> = {}): VoiceCallProvider {
@@ -89,6 +109,14 @@ function createRejectingInboundContext(): {
   return { ctx, hangupCalls };
 }
 
+function requireFirstActiveCall(ctx: CallManagerContext) {
+  const call = [...ctx.activeCalls.values()][0];
+  if (!call) {
+    throw new Error("expected one active call");
+  }
+  return call;
+}
+
 describe("processEvent (functional)", () => {
   it("calls provider hangup when rejecting inbound call", () => {
     const { ctx, hangupCalls } = createRejectingInboundContext();
@@ -147,8 +175,50 @@ describe("processEvent (functional)", () => {
     processEvent(ctx, event2);
 
     expect(ctx.activeCalls.size).toBe(0);
-    expect(hangupCalls).toHaveLength(1);
-    expect(hangupCalls[0]?.providerCallId).toBe("prov-dup");
+    expect(hangupCalls).toEqual([
+      expect.objectContaining({
+        providerCallId: "prov-dup",
+        reason: "hangup-bot",
+      }),
+    ]);
+  });
+
+  it("answers accepted inbound calls when the provider requires an answer command", () => {
+    const answerCalls: AnswerCallInput[] = [];
+    const provider = createProvider({
+      answerCall: async (input: AnswerCallInput): Promise<void> => {
+        answerCalls.push(input);
+      },
+    });
+    const ctx = createContext({
+      config: VoiceCallConfigSchema.parse({
+        enabled: true,
+        provider: "telnyx",
+        fromNumber: "+15550000000",
+        inboundPolicy: "open",
+        telnyx: {
+          apiKey: "KEY123",
+          connectionId: "CONN456",
+        },
+        skipSignatureVerification: true,
+      }),
+      provider,
+    });
+    const event = createInboundInitiatedEvent({
+      id: "evt-answer",
+      providerCallId: "call-control-1",
+      from: "+15552222222",
+    });
+
+    processEvent(ctx, event);
+
+    const call = requireFirstActiveCall(ctx);
+    expect(answerCalls).toEqual([
+      {
+        callId: call.callId,
+        providerCallId: "call-control-1",
+      },
+    ]);
   });
 
   it("updates providerCallId map when provider ID changes", () => {
@@ -177,11 +247,57 @@ describe("processEvent (functional)", () => {
       timestamp: now + 1,
     });
 
-    expect(ctx.activeCalls.get("call-1")?.providerCallId).toBe("call-uuid");
+    const activeCall = ctx.activeCalls.get("call-1");
+    if (!activeCall) {
+      throw new Error("expected active call after provider id change");
+    }
+    expect(activeCall.providerCallId).toBe("call-uuid");
     expect(ctx.providerCallIdMap.get("call-uuid")).toBe("call-1");
     expect(ctx.providerCallIdMap.has("request-uuid")).toBe(false);
   });
 
+  it("does not burn replay keys for unknown calls before a later replay can resolve them", () => {
+    const now = Date.now();
+    const ctx = createContext();
+    const event: NormalizedEvent = {
+      id: "evt-late-call",
+      dedupeKey: "stable-late-call",
+      type: "call.answered",
+      callId: "call-late",
+      providerCallId: "provider-late",
+      timestamp: now + 1,
+    };
+
+    processEvent(ctx, event);
+
+    expect(ctx.processedEventIds.size).toBe(0);
+
+    ctx.activeCalls.set("call-late", {
+      callId: "call-late",
+      providerCallId: "provider-late",
+      provider: "plivo",
+      direction: "inbound",
+      state: "ringing",
+      from: "+15550000002",
+      to: "+15550000000",
+      startedAt: now,
+      transcript: [],
+      processedEventIds: [],
+      metadata: {},
+    });
+    ctx.providerCallIdMap.set("provider-late", "call-late");
+
+    processEvent(ctx, event);
+
+    const call = ctx.activeCalls.get("call-late");
+    if (!call) {
+      throw new Error("expected replayed event to resolve after call registration");
+    }
+    expect(call.state).toBe("answered");
+    expect(call.answeredAt).toBe(now + 1);
+    expect(Array.from(ctx.processedEventIds)).toEqual(["stable-late-call"]);
+  });
+
   it("invokes onCallAnswered hook for answered events", () => {
     const now = Date.now();
     let answeredCallId: string | null = null;
@@ -253,12 +369,12 @@ describe("processEvent (functional)", () => {
 
     // Call should be registered in activeCalls and providerCallIdMap
     expect(ctx.activeCalls.size).toBe(1);
-    expect(ctx.providerCallIdMap.get("CA-external-123")).toBeDefined();
-    const call = [...ctx.activeCalls.values()][0];
-    expect(call?.providerCallId).toBe("CA-external-123");
-    expect(call?.direction).toBe("outbound");
-    expect(call?.from).toBe("+15550000000");
-    expect(call?.to).toBe("+15559876543");
+    const call = requireFirstActiveCall(ctx);
+    expect(ctx.providerCallIdMap.get("CA-external-123")).toBe(call.callId);
+    expect(call.providerCallId).toBe("CA-external-123");
+    expect(call.direction).toBe("outbound");
+    expect(call.from).toBe("+15550000000");
+    expect(call.to).toBe("+15559876543");
   });
 
   it("does not reject externally-initiated outbound calls even with disabled inbound policy", () => {
@@ -279,8 +395,8 @@ describe("processEvent (functional)", () => {
     // External outbound calls bypass inbound policy — they should be accepted
     expect(ctx.activeCalls.size).toBe(1);
     expect(hangupCalls).toHaveLength(0);
-    const call = [...ctx.activeCalls.values()][0];
-    expect(call?.direction).toBe("outbound");
+    const call = requireFirstActiveCall(ctx);
+    expect(call.direction).toBe("outbound");
   });
 
   it("preserves inbound direction for auto-registered inbound calls", () => {
@@ -306,8 +422,8 @@ describe("processEvent (functional)", () => {
     processEvent(ctx, event);
 
     expect(ctx.activeCalls.size).toBe(1);
-    const call = [...ctx.activeCalls.values()][0];
-    expect(call?.direction).toBe("inbound");
+    const call = requireFirstActiveCall(ctx);
+    expect(call.direction).toBe("inbound");
   });
 
   it("deduplicates by dedupeKey even when event IDs differ", () => {
@@ -351,7 +467,51 @@ describe("processEvent (functional)", () => {
     });
 
     const call = ctx.activeCalls.get("call-dedupe");
-    expect(call?.transcript).toHaveLength(1);
+    if (!call) {
+      throw new Error("expected deduped call to remain active");
+    }
+    expect(call.transcript).toHaveLength(1);
     expect(Array.from(ctx.processedEventIds)).toEqual(["stable-key-1"]);
   });
+
+  it("keeps retryable call.error events replayable", () => {
+    const now = Date.now();
+    const ctx = createContext();
+    ctx.activeCalls.set("call-retryable-error", {
+      callId: "call-retryable-error",
+      providerCallId: "provider-retryable-error",
+      provider: "plivo",
+      direction: "outbound",
+      state: "active",
+      from: "+15550000000",
+      to: "+15550000001",
+      startedAt: now,
+      transcript: [],
+      processedEventIds: [],
+      metadata: {},
+    });
+    ctx.providerCallIdMap.set("provider-retryable-error", "call-retryable-error");
+
+    const event: NormalizedEvent = {
+      id: "evt-retryable-error",
+      dedupeKey: "stable-retryable-error",
+      type: "call.error",
+      callId: "call-retryable-error",
+      providerCallId: "provider-retryable-error",
+      timestamp: now + 1,
+      error: "temporary upstream failure",
+      retryable: true,
+    };
+
+    processEvent(ctx, event);
+    processEvent(ctx, event);
+
+    const call = ctx.activeCalls.get("call-retryable-error");
+    if (!call) {
+      throw new Error("expected retryable error call to remain active");
+    }
+    expect(call.state).toBe("active");
+    expect(Array.from(ctx.processedEventIds)).toEqual([]);
+    expect(call.processedEventIds).toEqual([]);
+  });
 });