@openclaw/voice-call 2026.2.3 → 2026.2.9

package/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Changelog
 
-## 2026.2.3
+## 2026.2.6-3
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.2.6-2
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.2.6
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.2.4
 
 ### Changes
 

package/index.ts

@@ -1,3 +1,4 @@
+import type { GatewayRequestHandlerOptions, OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { Type } from "@sinclair/typebox";
 import type { CoreConfig } from "./src/core-bridge.js";
 import { registerVoiceCallCli } from "./src/cli.js";
@@ -144,7 +145,7 @@ const voiceCallPlugin = {
   name: "Voice Call",
   description: "Voice-call plugin with Telnyx/Twilio/Plivo providers",
   configSchema: voiceCallConfigSchema,
-  register(api) {
+  register(api: OpenClawPluginApi) {
     const config = resolveVoiceCallConfig(voiceCallConfigSchema.parse(api.pluginConfig));
     const validation = validateProviderConfig(config);
 
@@ -188,142 +189,160 @@ const voiceCallPlugin = {
       respond(false, { error: err instanceof Error ? err.message : String(err) });
     };
 
-    api.registerGatewayMethod("voicecall.initiate", async ({ params, respond }) => {
-      try {
-        const message = typeof params?.message === "string" ? params.message.trim() : "";
-        if (!message) {
-          respond(false, { error: "message required" });
-          return;
-        }
-        const rt = await ensureRuntime();
-        const to =
-          typeof params?.to === "string" && params.to.trim()
-            ? params.to.trim()
-            : rt.config.toNumber;
-        if (!to) {
-          respond(false, { error: "to required" });
-          return;
-        }
-        const mode =
-          params?.mode === "notify" || params?.mode === "conversation" ? params.mode : undefined;
-        const result = await rt.manager.initiateCall(to, undefined, {
-          message,
-          mode,
-        });
-        if (!result.success) {
-          respond(false, { error: result.error || "initiate failed" });
-          return;
+    api.registerGatewayMethod(
+      "voicecall.initiate",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const message = typeof params?.message === "string" ? params.message.trim() : "";
+          if (!message) {
+            respond(false, { error: "message required" });
+            return;
+          }
+          const rt = await ensureRuntime();
+          const to =
+            typeof params?.to === "string" && params.to.trim()
+              ? params.to.trim()
+              : rt.config.toNumber;
+          if (!to) {
+            respond(false, { error: "to required" });
+            return;
+          }
+          const mode =
+            params?.mode === "notify" || params?.mode === "conversation" ? params.mode : undefined;
+          const result = await rt.manager.initiateCall(to, undefined, {
+            message,
+            mode,
+          });
+          if (!result.success) {
+            respond(false, { error: result.error || "initiate failed" });
+            return;
+          }
+          respond(true, { callId: result.callId, initiated: true });
+        } catch (err) {
+          sendError(respond, err);
         }
-        respond(true, { callId: result.callId, initiated: true });
-      } catch (err) {
-        sendError(respond, err);
-      }
-    });
+      },
+    );
 
-    api.registerGatewayMethod("voicecall.continue", async ({ params, respond }) => {
-      try {
-        const callId = typeof params?.callId === "string" ? params.callId.trim() : "";
-        const message = typeof params?.message === "string" ? params.message.trim() : "";
-        if (!callId || !message) {
-          respond(false, { error: "callId and message required" });
-          return;
-        }
-        const rt = await ensureRuntime();
-        const result = await rt.manager.continueCall(callId, message);
-        if (!result.success) {
-          respond(false, { error: result.error || "continue failed" });
-          return;
+    api.registerGatewayMethod(
+      "voicecall.continue",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const callId = typeof params?.callId === "string" ? params.callId.trim() : "";
+          const message = typeof params?.message === "string" ? params.message.trim() : "";
+          if (!callId || !message) {
+            respond(false, { error: "callId and message required" });
+            return;
+          }
+          const rt = await ensureRuntime();
+          const result = await rt.manager.continueCall(callId, message);
+          if (!result.success) {
+            respond(false, { error: result.error || "continue failed" });
+            return;
+          }
+          respond(true, { success: true, transcript: result.transcript });
+        } catch (err) {
+          sendError(respond, err);
         }
-        respond(true, { success: true, transcript: result.transcript });
-      } catch (err) {
-        sendError(respond, err);
-      }
-    });
+      },
+    );
 
-    api.registerGatewayMethod("voicecall.speak", async ({ params, respond }) => {
-      try {
-        const callId = typeof params?.callId === "string" ? params.callId.trim() : "";
-        const message = typeof params?.message === "string" ? params.message.trim() : "";
-        if (!callId || !message) {
-          respond(false, { error: "callId and message required" });
-          return;
-        }
-        const rt = await ensureRuntime();
-        const result = await rt.manager.speak(callId, message);
-        if (!result.success) {
-          respond(false, { error: result.error || "speak failed" });
-          return;
+    api.registerGatewayMethod(
+      "voicecall.speak",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const callId = typeof params?.callId === "string" ? params.callId.trim() : "";
+          const message = typeof params?.message === "string" ? params.message.trim() : "";
+          if (!callId || !message) {
+            respond(false, { error: "callId and message required" });
+            return;
+          }
+          const rt = await ensureRuntime();
+          const result = await rt.manager.speak(callId, message);
+          if (!result.success) {
+            respond(false, { error: result.error || "speak failed" });
+            return;
+          }
+          respond(true, { success: true });
+        } catch (err) {
+          sendError(respond, err);
         }
-        respond(true, { success: true });
-      } catch (err) {
-        sendError(respond, err);
-      }
-    });
+      },
+    );
 
-    api.registerGatewayMethod("voicecall.end", async ({ params, respond }) => {
-      try {
-        const callId = typeof params?.callId === "string" ? params.callId.trim() : "";
-        if (!callId) {
-          respond(false, { error: "callId required" });
-          return;
-        }
-        const rt = await ensureRuntime();
-        const result = await rt.manager.endCall(callId);
-        if (!result.success) {
-          respond(false, { error: result.error || "end failed" });
-          return;
+    api.registerGatewayMethod(
+      "voicecall.end",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const callId = typeof params?.callId === "string" ? params.callId.trim() : "";
+          if (!callId) {
+            respond(false, { error: "callId required" });
+            return;
+          }
+          const rt = await ensureRuntime();
+          const result = await rt.manager.endCall(callId);
+          if (!result.success) {
+            respond(false, { error: result.error || "end failed" });
+            return;
+          }
+          respond(true, { success: true });
+        } catch (err) {
+          sendError(respond, err);
         }
-        respond(true, { success: true });
-      } catch (err) {
-        sendError(respond, err);
-      }
-    });
+      },
+    );
 
-    api.registerGatewayMethod("voicecall.status", async ({ params, respond }) => {
-      try {
-        const raw =
-          typeof params?.callId === "string"
-            ? params.callId.trim()
-            : typeof params?.sid === "string"
-              ? params.sid.trim()
-              : "";
-        if (!raw) {
-          respond(false, { error: "callId required" });
-          return;
-        }
-        const rt = await ensureRuntime();
-        const call = rt.manager.getCall(raw) || rt.manager.getCallByProviderCallId(raw);
-        if (!call) {
-          respond(true, { found: false });
-          return;
+    api.registerGatewayMethod(
+      "voicecall.status",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const raw =
+            typeof params?.callId === "string"
+              ? params.callId.trim()
+              : typeof params?.sid === "string"
+                ? params.sid.trim()
+                : "";
+          if (!raw) {
+            respond(false, { error: "callId required" });
+            return;
+          }
+          const rt = await ensureRuntime();
+          const call = rt.manager.getCall(raw) || rt.manager.getCallByProviderCallId(raw);
+          if (!call) {
+            respond(true, { found: false });
+            return;
+          }
+          respond(true, { found: true, call });
+        } catch (err) {
+          sendError(respond, err);
         }
-        respond(true, { found: true, call });
-      } catch (err) {
-        sendError(respond, err);
-      }
-    });
+      },
+    );
 
-    api.registerGatewayMethod("voicecall.start", async ({ params, respond }) => {
-      try {
-        const to = typeof params?.to === "string" ? params.to.trim() : "";
-        const message = typeof params?.message === "string" ? params.message.trim() : "";
-        if (!to) {
-          respond(false, { error: "to required" });
-          return;
-        }
-        const rt = await ensureRuntime();
-        const result = await rt.manager.initiateCall(to, undefined, {
-          message: message || undefined,
-        });
-        if (!result.success) {
-          respond(false, { error: result.error || "initiate failed" });
-          return;
+    api.registerGatewayMethod(
+      "voicecall.start",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const to = typeof params?.to === "string" ? params.to.trim() : "";
+          const message = typeof params?.message === "string" ? params.message.trim() : "";
+          if (!to) {
+            respond(false, { error: "to required" });
+            return;
+          }
+          const rt = await ensureRuntime();
+          const result = await rt.manager.initiateCall(to, undefined, {
+            message: message || undefined,
+          });
+          if (!result.success) {
+            respond(false, { error: result.error || "initiate failed" });
+            return;
+          }
+          respond(true, { callId: result.callId, initiated: true });
+        } catch (err) {
+          sendError(respond, err);
         }
-        respond(true, { callId: result.callId, initiated: true });
-      } catch (err) {
-        sendError(respond, err);
-      }
-    });
+      },
+    );
 
     api.registerTool({
       name: "voice_call",
@@ -332,7 +351,7 @@ const voiceCallPlugin = {
       parameters: VoiceCallToolSchema,
       async execute(_toolCallId, params) {
         const json = (payload: unknown) => ({
-          content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+          content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }],
           details: payload,
         });
 

package/package.json

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

package/src/cli.ts

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { sleep } from "openclaw/plugin-sdk";
 import type { VoiceCallConfig } from "./config.js";
 import type { VoiceCallRuntime } from "./runtime.js";
 import { resolveUserPath } from "./utils.js";
@@ -40,10 +41,6 @@ function resolveDefaultStorePath(config: VoiceCallConfig): string {
   return path.join(base, "calls.jsonl");
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 export function registerVoiceCallCli(params: {
   program: Command;
   config: VoiceCallConfig;

package/src/response-generator.ts

@@ -146,7 +146,7 @@ export async function generateVoiceResponse(
 
     const text = texts.join(" ") || null;
 
-    if (!text && result.meta.aborted) {
+    if (!text && result.meta?.aborted) {
       return { text: null, error: "Response generation was aborted" };
     }
 

package/src/runtime.ts

@@ -30,7 +30,7 @@ type Logger = {
   info: (message: string) => void;
   warn: (message: string) => void;
   error: (message: string) => void;
-  debug: (message: string) => void;
+  debug?: (message: string) => void;
 };
 
 function isLoopbackBind(bind: string | undefined): boolean {

package/src/webhook.ts

@@ -296,23 +296,48 @@ export class VoiceCallWebhookServer {
   }
 
   /**
-   * Read request body as string.
+   * Read request body as string with timeout protection.
    */
-  private readBody(req: http.IncomingMessage, maxBytes: number): Promise<string> {
+  private readBody(
+    req: http.IncomingMessage,
+    maxBytes: number,
+    timeoutMs = 30_000,
+  ): Promise<string> {
     return new Promise((resolve, reject) => {
+      let done = false;
+      const finish = (fn: () => void) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        clearTimeout(timer);
+        fn();
+      };
+
+      const timer = setTimeout(() => {
+        finish(() => {
+          const err = new Error("Request body timeout");
+          req.destroy(err);
+          reject(err);
+        });
+      }, timeoutMs);
+
       const chunks: Buffer[] = [];
       let totalBytes = 0;
       req.on("data", (chunk: Buffer) => {
         totalBytes += chunk.length;
         if (totalBytes > maxBytes) {
-          req.destroy();
-          reject(new Error("PayloadTooLarge"));
+          finish(() => {
+            req.destroy();
+            reject(new Error("PayloadTooLarge"));
+          });
           return;
         }
         chunks.push(chunk);
       });
-      req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-      req.on("error", reject);
+      req.on("end", () => finish(() => resolve(Buffer.concat(chunks).toString("utf-8"))));
+      req.on("error", (err) => finish(() => reject(err)));
+      req.on("close", () => finish(() => reject(new Error("Connection closed"))));
     });
   }