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

package/src/core-bridge.ts

@@ -1,6 +1,4 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import type { OpenClawPluginApi } from "../api.js";
 import type { VoiceCallTtsConfig } from "./config.js";
 
 export type CoreConfig = {
@@ -13,147 +11,4 @@ export type CoreConfig = {
   [key: string]: unknown;
 };
 
-type CoreAgentDeps = {
-  resolveAgentDir: (cfg: CoreConfig, agentId: string) => string;
-  resolveAgentWorkspaceDir: (cfg: CoreConfig, agentId: string) => string;
-  resolveAgentIdentity: (
-    cfg: CoreConfig,
-    agentId: string,
-  ) => { name?: string | null } | null | undefined;
-  resolveThinkingDefault: (params: {
-    cfg: CoreConfig;
-    provider?: string;
-    model?: string;
-  }) => string;
-  runEmbeddedPiAgent: (params: {
-    sessionId: string;
-    sessionKey?: string;
-    messageProvider?: string;
-    sessionFile: string;
-    workspaceDir: string;
-    config?: CoreConfig;
-    prompt: string;
-    provider?: string;
-    model?: string;
-    thinkLevel?: string;
-    verboseLevel?: string;
-    timeoutMs: number;
-    runId: string;
-    lane?: string;
-    extraSystemPrompt?: string;
-    agentDir?: string;
-  }) => Promise<{
-    payloads?: Array<{ text?: string; isError?: boolean }>;
-    meta?: { aborted?: boolean };
-  }>;
-  resolveAgentTimeoutMs: (opts: { cfg: CoreConfig }) => number;
-  ensureAgentWorkspace: (params?: { dir: string }) => Promise<void>;
-  resolveStorePath: (store?: string, opts?: { agentId?: string }) => string;
-  loadSessionStore: (storePath: string) => Record<string, unknown>;
-  saveSessionStore: (storePath: string, store: Record<string, unknown>) => Promise<void>;
-  resolveSessionFilePath: (
-    sessionId: string,
-    entry: unknown,
-    opts?: { agentId?: string },
-  ) => string;
-  DEFAULT_MODEL: string;
-  DEFAULT_PROVIDER: string;
-};
-
-let coreRootCache: string | null = null;
-let coreDepsPromise: Promise<CoreAgentDeps> | null = null;
-
-function findPackageRoot(startDir: string, name: string): string | null {
-  let dir = startDir;
-  for (;;) {
-    const pkgPath = path.join(dir, "package.json");
-    try {
-      if (fs.existsSync(pkgPath)) {
-        const raw = fs.readFileSync(pkgPath, "utf8");
-        const pkg = JSON.parse(raw) as { name?: string };
-        if (pkg.name === name) {
-          return dir;
-        }
-      }
-    } catch {
-      // ignore parse errors and keep walking
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) {
-      return null;
-    }
-    dir = parent;
-  }
-}
-
-function resolveOpenClawRoot(): string {
-  if (coreRootCache) {
-    return coreRootCache;
-  }
-  const override = process.env.OPENCLAW_ROOT?.trim();
-  if (override) {
-    coreRootCache = override;
-    return override;
-  }
-
-  const candidates = new Set<string>();
-  if (process.argv[1]) {
-    candidates.add(path.dirname(process.argv[1]));
-  }
-  candidates.add(process.cwd());
-  try {
-    const urlPath = fileURLToPath(import.meta.url);
-    candidates.add(path.dirname(urlPath));
-  } catch {
-    // ignore
-  }
-
-  for (const start of candidates) {
-    for (const name of ["openclaw"]) {
-      const found = findPackageRoot(start, name);
-      if (found) {
-        coreRootCache = found;
-        return found;
-      }
-    }
-  }
-
-  throw new Error("Unable to resolve core root. Set OPENCLAW_ROOT to the package root.");
-}
-
-async function importCoreExtensionAPI(): Promise<{
-  resolveAgentDir: CoreAgentDeps["resolveAgentDir"];
-  resolveAgentWorkspaceDir: CoreAgentDeps["resolveAgentWorkspaceDir"];
-  DEFAULT_MODEL: string;
-  DEFAULT_PROVIDER: string;
-  resolveAgentIdentity: CoreAgentDeps["resolveAgentIdentity"];
-  resolveThinkingDefault: CoreAgentDeps["resolveThinkingDefault"];
-  runEmbeddedPiAgent: CoreAgentDeps["runEmbeddedPiAgent"];
-  resolveAgentTimeoutMs: CoreAgentDeps["resolveAgentTimeoutMs"];
-  ensureAgentWorkspace: CoreAgentDeps["ensureAgentWorkspace"];
-  resolveStorePath: CoreAgentDeps["resolveStorePath"];
-  loadSessionStore: CoreAgentDeps["loadSessionStore"];
-  saveSessionStore: CoreAgentDeps["saveSessionStore"];
-  resolveSessionFilePath: CoreAgentDeps["resolveSessionFilePath"];
-}> {
-  // Do not import any other module. You can't touch this or you will be fired.
-  const distPath = path.join(resolveOpenClawRoot(), "dist", "extensionAPI.js");
-  if (!fs.existsSync(distPath)) {
-    throw new Error(
-      `Missing core module at ${distPath}. Run \`pnpm build\` or install the official package.`,
-    );
-  }
-  return await import(pathToFileURL(distPath).href);
-}
-
-export async function loadCoreAgentDeps(): Promise<CoreAgentDeps> {
-  if (coreDepsPromise) {
-    return coreDepsPromise;
-  }
-
-  coreDepsPromise = (async () => {
-    return await importCoreExtensionAPI();
-  })();
-
-  return coreDepsPromise;
-}
+export type CoreAgentDeps = OpenClawPluginApi["runtime"]["agent"];

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;
 };