@openclaw/voice-call 2026.3.2 → 2026.3.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2026.3.7
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.3.3
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
 ## 2026.3.2
 
 ### Changes

package/index.ts

@@ -1,5 +1,8 @@
 import { Type } from "@sinclair/typebox";
-import type { GatewayRequestHandlerOptions, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type {
+  GatewayRequestHandlerOptions,
+  OpenClawPluginApi,
+} from "openclaw/plugin-sdk/voice-call";
 import { registerVoiceCallCli } from "./src/cli.js";
 import {
   VoiceCallConfigSchema,
@@ -206,6 +209,23 @@ const voiceCallPlugin = {
       const rt = await ensureRuntime();
       return { rt, callId, message } as const;
     };
+    const initiateCallAndRespond = async (params: {
+      rt: VoiceCallRuntime;
+      respond: GatewayRequestHandlerOptions["respond"];
+      to: string;
+      message?: string;
+      mode?: "notify" | "conversation";
+    }) => {
+      const result = await params.rt.manager.initiateCall(params.to, undefined, {
+        message: params.message,
+        mode: params.mode,
+      });
+      if (!result.success) {
+        params.respond(false, { error: result.error || "initiate failed" });
+        return;
+      }
+      params.respond(true, { callId: result.callId, initiated: true });
+    };
 
     api.registerGatewayMethod(
       "voicecall.initiate",
@@ -227,15 +247,13 @@ const voiceCallPlugin = {
           }
           const mode =
             params?.mode === "notify" || params?.mode === "conversation" ? params.mode : undefined;
-          const result = await rt.manager.initiateCall(to, undefined, {
+          await initiateCallAndRespond({
+            rt,
+            respond,
+            to,
             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);
         }
@@ -344,14 +362,12 @@ const voiceCallPlugin = {
             return;
           }
           const rt = await ensureRuntime();
-          const result = await rt.manager.initiateCall(to, undefined, {
+          await initiateCallAndRespond({
+            rt,
+            respond,
+            to,
             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);
         }

package/openclaw.plugin.json

@@ -249,6 +249,10 @@
         "type": "integer",
         "minimum": 1
       },
+      "staleCallReaperSeconds": {
+        "type": "integer",
+        "minimum": 0
+      },
       "silenceTimeoutMs": {
         "type": "integer",
         "minimum": 1
@@ -313,6 +317,27 @@
           }
         }
       },
+      "webhookSecurity": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "allowedHosts": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "trustForwardingHeaders": {
+            "type": "boolean"
+          },
+          "trustedProxyIPs": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      },
       "streaming": {
         "type": "object",
         "additionalProperties": false,
@@ -341,6 +366,22 @@
           },
           "streamPath": {
             "type": "string"
+          },
+          "preStartTimeoutMs": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "maxPendingConnections": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "maxPendingConnectionsPerIp": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "maxConnections": {
+            "type": "integer",
+            "minimum": 1
           }
         }
       },

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.3.2",
+  "version": "2026.3.7",
   "description": "OpenClaw voice-call plugin",
   "type": "module",
   "dependencies": {
     "@sinclair/typebox": "0.34.48",
+    "commander": "^14.0.3",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },

package/src/cli.ts

@@ -2,7 +2,7 @@ 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 { sleep } from "openclaw/plugin-sdk/voice-call";
 import type { VoiceCallConfig } from "./config.js";
 import type { VoiceCallRuntime } from "./runtime.js";
 import { resolveUserPath } from "./utils.js";

package/src/config.test.ts

@@ -1,49 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { validateProviderConfig, resolveVoiceCallConfig, type VoiceCallConfig } from "./config.js";
+import {
+  validateProviderConfig,
+  normalizeVoiceCallConfig,
+  resolveVoiceCallConfig,
+  type VoiceCallConfig,
+} from "./config.js";
+import { createVoiceCallBaseConfig } from "./test-fixtures.js";
 
 function createBaseConfig(provider: "telnyx" | "twilio" | "plivo" | "mock"): VoiceCallConfig {
-  return {
-    enabled: true,
-    provider,
-    fromNumber: "+15550001234",
-    inboundPolicy: "disabled",
-    allowFrom: [],
-    outbound: { defaultMode: "notify", notifyHangupDelaySec: 3 },
-    maxDurationSeconds: 300,
-    staleCallReaperSeconds: 600,
-    silenceTimeoutMs: 800,
-    transcriptTimeoutMs: 180000,
-    ringTimeoutMs: 30000,
-    maxConcurrentCalls: 1,
-    serve: { port: 3334, bind: "127.0.0.1", path: "/voice/webhook" },
-    tailscale: { mode: "off", path: "/voice/webhook" },
-    tunnel: { provider: "none", allowNgrokFreeTierLoopbackBypass: false },
-    webhookSecurity: {
-      allowedHosts: [],
-      trustForwardingHeaders: false,
-      trustedProxyIPs: [],
-    },
-    streaming: {
-      enabled: false,
-      sttProvider: "openai-realtime",
-      sttModel: "gpt-4o-transcribe",
-      silenceDurationMs: 800,
-      vadThreshold: 0.5,
-      streamPath: "/voice/stream",
-      preStartTimeoutMs: 5000,
-      maxPendingConnections: 32,
-      maxPendingConnectionsPerIp: 4,
-      maxConnections: 128,
-    },
-    skipSignatureVerification: false,
-    stt: { provider: "openai", model: "whisper-1" },
-    tts: {
-      provider: "openai",
-      openai: { model: "gpt-4o-mini-tts", voice: "coral" },
-    },
-    responseModel: "openai/gpt-4o-mini",
-    responseTimeoutMs: 30000,
-  };
+  return createVoiceCallBaseConfig({ provider });
 }
 
 describe("validateProviderConfig", () => {
@@ -206,3 +171,48 @@ describe("validateProviderConfig", () => {
     });
   });
 });
+
+describe("normalizeVoiceCallConfig", () => {
+  it("fills nested runtime defaults from a partial config boundary", () => {
+    const normalized = normalizeVoiceCallConfig({
+      enabled: true,
+      provider: "mock",
+      streaming: {
+        enabled: true,
+        streamPath: "/custom-stream",
+      },
+    });
+
+    expect(normalized.serve.path).toBe("/voice/webhook");
+    expect(normalized.streaming.streamPath).toBe("/custom-stream");
+    expect(normalized.streaming.sttModel).toBe("gpt-4o-transcribe");
+    expect(normalized.tunnel.provider).toBe("none");
+    expect(normalized.webhookSecurity.allowedHosts).toEqual([]);
+  });
+
+  it("accepts partial nested TTS overrides and preserves nested objects", () => {
+    const normalized = normalizeVoiceCallConfig({
+      tts: {
+        provider: "elevenlabs",
+        elevenlabs: {
+          apiKey: {
+            source: "env",
+            provider: "elevenlabs",
+            id: "ELEVENLABS_API_KEY",
+          },
+          voiceSettings: {
+            speed: 1.1,
+          },
+        },
+      },
+    });
+
+    expect(normalized.tts?.provider).toBe("elevenlabs");
+    expect(normalized.tts?.elevenlabs?.apiKey).toEqual({
+      source: "env",
+      provider: "elevenlabs",
+      id: "ELEVENLABS_API_KEY",
+    });
+    expect(normalized.tts?.elevenlabs?.voiceSettings).toEqual({ speed: 1.1 });
+  });
+});

package/src/config.ts

@@ -3,8 +3,9 @@ import {
   TtsConfigSchema,
   TtsModeSchema,
   TtsProviderSchema,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/voice-call";
 import { z } from "zod";
+import { deepMergeDefined } from "./deep-merge.js";
 
 // -----------------------------------------------------------------------------
 // Phone Number Validation
@@ -350,17 +351,64 @@ export const VoiceCallConfigSchema = z
   .strict();
 
 export type VoiceCallConfig = z.infer<typeof VoiceCallConfigSchema>;
+type DeepPartial<T> =
+  T extends Array<infer U>
+    ? DeepPartial<U>[]
+    : T extends object
+      ? { [K in keyof T]?: DeepPartial<T[K]> }
+      : T;
+export type VoiceCallConfigInput = DeepPartial<VoiceCallConfig>;
 
 // -----------------------------------------------------------------------------
 // Configuration Helpers
 // -----------------------------------------------------------------------------
 
+const DEFAULT_VOICE_CALL_CONFIG = VoiceCallConfigSchema.parse({});
+
+function cloneDefaultVoiceCallConfig(): VoiceCallConfig {
+  return structuredClone(DEFAULT_VOICE_CALL_CONFIG);
+}
+
+function normalizeVoiceCallTtsConfig(
+  defaults: VoiceCallTtsConfig,
+  overrides: DeepPartial<NonNullable<VoiceCallTtsConfig>> | undefined,
+): VoiceCallTtsConfig {
+  if (!defaults && !overrides) {
+    return undefined;
+  }
+
+  return TtsConfigSchema.parse(deepMergeDefined(defaults ?? {}, overrides ?? {}));
+}
+
+export function normalizeVoiceCallConfig(config: VoiceCallConfigInput): VoiceCallConfig {
+  const defaults = cloneDefaultVoiceCallConfig();
+  return {
+    ...defaults,
+    ...config,
+    allowFrom: config.allowFrom ?? defaults.allowFrom,
+    outbound: { ...defaults.outbound, ...config.outbound },
+    serve: { ...defaults.serve, ...config.serve },
+    tailscale: { ...defaults.tailscale, ...config.tailscale },
+    tunnel: { ...defaults.tunnel, ...config.tunnel },
+    webhookSecurity: {
+      ...defaults.webhookSecurity,
+      ...config.webhookSecurity,
+      allowedHosts: config.webhookSecurity?.allowedHosts ?? defaults.webhookSecurity.allowedHosts,
+      trustedProxyIPs:
+        config.webhookSecurity?.trustedProxyIPs ?? defaults.webhookSecurity.trustedProxyIPs,
+    },
+    streaming: { ...defaults.streaming, ...config.streaming },
+    stt: { ...defaults.stt, ...config.stt },
+    tts: normalizeVoiceCallTtsConfig(defaults.tts, config.tts),
+  };
+}
+
 /**
  * Resolves the configuration by merging environment variables into missing fields.
  * Returns a new configuration object with environment variables applied.
  */
-export function resolveVoiceCallConfig(config: VoiceCallConfig): VoiceCallConfig {
-  const resolved = JSON.parse(JSON.stringify(config)) as VoiceCallConfig;
+export function resolveVoiceCallConfig(config: VoiceCallConfigInput): VoiceCallConfig {
+  const resolved = normalizeVoiceCallConfig(config);
 
   // Telnyx
   if (resolved.provider === "telnyx") {
@@ -405,7 +453,7 @@ export function resolveVoiceCallConfig(config: VoiceCallConfig): VoiceCallConfig
     resolved.webhookSecurity.trustForwardingHeaders ?? false;
   resolved.webhookSecurity.trustedProxyIPs = resolved.webhookSecurity.trustedProxyIPs ?? [];
 
-  return resolved;
+  return normalizeVoiceCallConfig(resolved);
 }
 
 /**

package/src/deep-merge.ts

@@ -0,0 +1,23 @@
+const BLOCKED_MERGE_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+
+export function deepMergeDefined(base: unknown, override: unknown): unknown {
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override === undefined ? base : override;
+  }
+
+  const result: Record<string, unknown> = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (BLOCKED_MERGE_KEYS.has(key) || value === undefined) {
+      continue;
+    }
+
+    const existing = result[key];
+    result[key] = key in result ? deepMergeDefined(existing, value) : value;
+  }
+
+  return result;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/src/providers/mock.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import type { WebhookContext } from "../types.js";
+import { MockProvider } from "./mock.js";
+
+function createWebhookContext(rawBody: string): WebhookContext {
+  return {
+    headers: {},
+    rawBody,
+    url: "http://localhost/voice/webhook",
+    method: "POST",
+    query: {},
+  };
+}
+
+describe("MockProvider", () => {
+  it("preserves explicit falsy event values", () => {
+    const provider = new MockProvider();
+    const result = provider.parseWebhookEvent(
+      createWebhookContext(
+        JSON.stringify({
+          events: [
+            {
+              id: "evt-error",
+              type: "call.error",
+              callId: "call-1",
+              timestamp: 0,
+              error: "",
+              retryable: false,
+            },
+            {
+              id: "evt-ended",
+              type: "call.ended",
+              callId: "call-2",
+              reason: "",
+            },
+            {
+              id: "evt-speech",
+              type: "call.speech",
+              callId: "call-3",
+              transcript: "",
+              isFinal: false,
+            },
+          ],
+        }),
+      ),
+    );
+
+    expect(result.events).toEqual([
+      {
+        id: "evt-error",
+        type: "call.error",
+        callId: "call-1",
+        providerCallId: undefined,
+        timestamp: 0,
+        error: "",
+        retryable: false,
+      },
+      {
+        id: "evt-ended",
+        type: "call.ended",
+        callId: "call-2",
+        providerCallId: undefined,
+        timestamp: expect.any(Number),
+        reason: "",
+      },
+      {
+        id: "evt-speech",
+        type: "call.speech",
+        callId: "call-3",
+        providerCallId: undefined,
+        timestamp: expect.any(Number),
+        transcript: "",
+        isFinal: false,
+        confidence: undefined,
+      },
+    ]);
+  });
+});

package/src/providers/mock.ts

@@ -65,10 +65,10 @@ export class MockProvider implements VoiceCallProvider {
     }
 
     const base = {
-      id: evt.id || crypto.randomUUID(),
+      id: evt.id ?? crypto.randomUUID(),
       callId: evt.callId,
       providerCallId: evt.providerCallId,
-      timestamp: evt.timestamp || Date.now(),
+      timestamp: evt.timestamp ?? Date.now(),
     };
 
     switch (evt.type) {
@@ -83,7 +83,7 @@ export class MockProvider implements VoiceCallProvider {
         return {
           ...base,
           type: evt.type,
-          text: payload.text || "",
+          text: payload.text ?? "",
         };
       }
 
@@ -98,7 +98,7 @@ export class MockProvider implements VoiceCallProvider {
         return {
           ...base,
           type: evt.type,
-          transcript: payload.transcript || "",
+          transcript: payload.transcript ?? "",
           isFinal: payload.isFinal ?? true,
           confidence: payload.confidence,
         };
@@ -109,7 +109,7 @@ export class MockProvider implements VoiceCallProvider {
         return {
           ...base,
           type: evt.type,
-          durationMs: payload.durationMs || 0,
+          durationMs: payload.durationMs ?? 0,
         };
       }
 
@@ -118,7 +118,7 @@ export class MockProvider implements VoiceCallProvider {
         return {
           ...base,
           type: evt.type,
-          digits: payload.digits || "",
+          digits: payload.digits ?? "",
         };
       }
 
@@ -127,7 +127,7 @@ export class MockProvider implements VoiceCallProvider {
         return {
           ...base,
           type: evt.type,
-          reason: payload.reason || "completed",
+          reason: payload.reason ?? "completed",
         };
       }
 
@@ -136,7 +136,7 @@ export class MockProvider implements VoiceCallProvider {
         return {
           ...base,
           type: evt.type,
-          error: payload.error || "unknown error",
+          error: payload.error ?? "unknown error",
           retryable: payload.retryable,
         };
       }

package/src/providers/shared/guarded-json-api.ts

@@ -1,4 +1,4 @@
-import { fetchWithSsrFGuard } from "openclaw/plugin-sdk";
+import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/voice-call";
 
 type GuardedJsonApiRequestParams = {
   url: string;

package/src/providers/stt-openai-realtime.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import type { RealtimeSTTConfig } from "./stt-openai-realtime.js";
+import { OpenAIRealtimeSTTProvider } from "./stt-openai-realtime.js";
+
+type ProviderInternals = {
+  vadThreshold: number;
+  silenceDurationMs: number;
+};
+
+function readProviderInternals(config: RealtimeSTTConfig): ProviderInternals {
+  const provider = new OpenAIRealtimeSTTProvider(config) as unknown as Record<string, unknown>;
+  return {
+    vadThreshold: provider["vadThreshold"] as number,
+    silenceDurationMs: provider["silenceDurationMs"] as number,
+  };
+}
+
+describe("OpenAIRealtimeSTTProvider constructor defaults", () => {
+  it("uses vadThreshold: 0 when explicitly configured (max sensitivity)", () => {
+    const provider = readProviderInternals({
+      apiKey: "sk-test", // pragma: allowlist secret
+      vadThreshold: 0,
+    });
+    expect(provider.vadThreshold).toBe(0);
+  });
+
+  it("uses silenceDurationMs: 0 when explicitly configured", () => {
+    const provider = readProviderInternals({
+      apiKey: "sk-test", // pragma: allowlist secret
+      silenceDurationMs: 0,
+    });
+    expect(provider.silenceDurationMs).toBe(0);
+  });
+
+  it("falls back to defaults when values are undefined", () => {
+    const provider = readProviderInternals({
+      apiKey: "sk-test", // pragma: allowlist secret
+    });
+    expect(provider.vadThreshold).toBe(0.5);
+    expect(provider.silenceDurationMs).toBe(800);
+  });
+});

package/src/providers/stt-openai-realtime.ts

@@ -62,8 +62,8 @@ export class OpenAIRealtimeSTTProvider {
     }
     this.apiKey = config.apiKey;
     this.model = config.model || "gpt-4o-transcribe";
-    this.silenceDurationMs = config.silenceDurationMs || 800;
-    this.vadThreshold = config.vadThreshold || 0.5;
+    this.silenceDurationMs = config.silenceDurationMs ?? 800;
+    this.vadThreshold = config.vadThreshold ?? 0.5;
   }
 
   /**

package/src/providers/tts-openai.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import type { OpenAITTSConfig } from "./tts-openai.js";
+import { OpenAITTSProvider } from "./tts-openai.js";
+
+type ProviderInternals = {
+  model: string;
+  voice: string;
+  speed: number;
+};
+
+function readProviderInternals(config: OpenAITTSConfig): ProviderInternals {
+  return new OpenAITTSProvider(config) as unknown as ProviderInternals;
+}
+
+describe("OpenAITTSProvider constructor defaults", () => {
+  it("uses speed: 0 when explicitly configured", () => {
+    const provider = readProviderInternals({
+      apiKey: "sk-test", // pragma: allowlist secret
+      speed: 0,
+    });
+
+    expect(provider.speed).toBe(0);
+  });
+
+  it("falls back to speed default when undefined", () => {
+    const provider = readProviderInternals({
+      apiKey: "sk-test", // pragma: allowlist secret
+    });
+
+    expect(provider.speed).toBe(1.0);
+  });
+
+  it("treats blank model and voice overrides as unset", () => {
+    const provider = readProviderInternals({
+      apiKey: "sk-test", // pragma: allowlist secret
+      model: "   ",
+      voice: "",
+    });
+
+    expect(provider.model).toBe("gpt-4o-mini-tts");
+    expect(provider.voice).toBe("coral");
+  });
+});

package/src/providers/tts-openai.ts

@@ -1,3 +1,5 @@
+import { pcmToMulaw } from "../telephony-audio.js";
+
 /**
  * OpenAI TTS Provider
  *
@@ -64,6 +66,11 @@ export const OPENAI_TTS_VOICES = [
 
 export type OpenAITTSVoice = (typeof OPENAI_TTS_VOICES)[number];
 
+function trimToUndefined(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
 /**
  * OpenAI TTS Provider for generating speech audio.
  */
@@ -75,13 +82,14 @@ export class OpenAITTSProvider {
   private instructions?: string;
 
   constructor(config: OpenAITTSConfig = {}) {
-    this.apiKey = config.apiKey || process.env.OPENAI_API_KEY || "";
+    this.apiKey =
+      trimToUndefined(config.apiKey) ?? trimToUndefined(process.env.OPENAI_API_KEY) ?? "";
     // Default to gpt-4o-mini-tts for intelligent realtime applications
-    this.model = config.model || "gpt-4o-mini-tts";
+    this.model = trimToUndefined(config.model) ?? "gpt-4o-mini-tts";
     // Default to coral - good balance of quality and natural tone
-    this.voice = (config.voice as OpenAITTSVoice) || "coral";
-    this.speed = config.speed || 1.0;
-    this.instructions = config.instructions;
+    this.voice = (trimToUndefined(config.voice) as OpenAITTSVoice | undefined) ?? "coral";
+    this.speed = config.speed ?? 1.0;
+    this.instructions = trimToUndefined(config.instructions);
 
     if (!this.apiKey) {
       throw new Error("OpenAI API key required (set OPENAI_API_KEY or pass apiKey)");
@@ -103,7 +111,7 @@ export class OpenAITTSProvider {
     };
 
     // Add instructions if using gpt-4o-mini-tts model
-    const effectiveInstructions = instructions || this.instructions;
+    const effectiveInstructions = trimToUndefined(instructions) ?? this.instructions;
     if (effectiveInstructions && this.model.includes("gpt-4o-mini-tts")) {
       body.instructions = effectiveInstructions;
     }
@@ -179,55 +187,6 @@ function clamp16(value: number): number {
   return Math.max(-32768, Math.min(32767, value));
 }
 
-/**
- * Convert 16-bit PCM to 8-bit mu-law.
- * Standard G.711 mu-law encoding for telephony.
- */
-function pcmToMulaw(pcm: Buffer): Buffer {
-  const samples = pcm.length / 2;
-  const mulaw = Buffer.alloc(samples);
-
-  for (let i = 0; i < samples; i++) {
-    const sample = pcm.readInt16LE(i * 2);
-    mulaw[i] = linearToMulaw(sample);
-  }
-
-  return mulaw;
-}
-
-/**
- * Convert a single 16-bit linear sample to 8-bit mu-law.
- * Implements ITU-T G.711 mu-law encoding.
- */
-function linearToMulaw(sample: number): number {
-  const BIAS = 132;
-  const CLIP = 32635;
-
-  // Get sign bit
-  const sign = sample < 0 ? 0x80 : 0;
-  if (sample < 0) {
-    sample = -sample;
-  }
-
-  // Clip to prevent overflow
-  if (sample > CLIP) {
-    sample = CLIP;
-  }
-
-  // Add bias and find segment
-  sample += BIAS;
-  let exponent = 7;
-  for (let expMask = 0x4000; (sample & expMask) === 0 && exponent > 0; exponent--, expMask >>= 1) {
-    // Find the segment (exponent)
-  }
-
-  // Extract mantissa bits
-  const mantissa = (sample >> (exponent + 3)) & 0x0f;
-
-  // Combine into mu-law byte (inverted for transmission)
-  return ~(sign | (exponent << 4) | mantissa) & 0xff;
-}
-
 /**
  * Convert 8-bit mu-law to 16-bit linear PCM.
  * Useful for decoding incoming audio.

package/src/runtime.test.ts

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { VoiceCallConfig } from "./config.js";
 import type { CoreConfig } from "./core-bridge.js";
+import { createVoiceCallBaseConfig } from "./test-fixtures.js";
 
 const mocks = vi.hoisted(() => ({
   resolveVoiceCallConfig: vi.fn(),
@@ -45,48 +46,7 @@ vi.mock("./webhook/tailscale.js", () => ({
 import { createVoiceCallRuntime } from "./runtime.js";
 
 function createBaseConfig(): VoiceCallConfig {
-  return {
-    enabled: true,
-    provider: "mock",
-    fromNumber: "+15550001234",
-    inboundPolicy: "disabled",
-    allowFrom: [],
-    outbound: { defaultMode: "notify", notifyHangupDelaySec: 3 },
-    maxDurationSeconds: 300,
-    staleCallReaperSeconds: 600,
-    silenceTimeoutMs: 800,
-    transcriptTimeoutMs: 180000,
-    ringTimeoutMs: 30000,
-    maxConcurrentCalls: 1,
-    serve: { port: 3334, bind: "127.0.0.1", path: "/voice/webhook" },
-    tailscale: { mode: "off", path: "/voice/webhook" },
-    tunnel: { provider: "ngrok", allowNgrokFreeTierLoopbackBypass: false },
-    webhookSecurity: {
-      allowedHosts: [],
-      trustForwardingHeaders: false,
-      trustedProxyIPs: [],
-    },
-    streaming: {
-      enabled: false,
-      sttProvider: "openai-realtime",
-      sttModel: "gpt-4o-transcribe",
-      silenceDurationMs: 800,
-      vadThreshold: 0.5,
-      streamPath: "/voice/stream",
-      preStartTimeoutMs: 5000,
-      maxPendingConnections: 32,
-      maxPendingConnectionsPerIp: 4,
-      maxConnections: 128,
-    },
-    skipSignatureVerification: false,
-    stt: { provider: "openai", model: "whisper-1" },
-    tts: {
-      provider: "openai",
-      openai: { model: "gpt-4o-mini-tts", voice: "coral" },
-    },
-    responseModel: "openai/gpt-4o-mini",
-    responseTimeoutMs: 30000,
-  };
+  return createVoiceCallBaseConfig({ tunnelProvider: "ngrok" });
 }
 
 describe("createVoiceCallRuntime lifecycle", () => {

package/src/telephony-tts.ts

@@ -1,5 +1,6 @@
 import type { VoiceCallTtsConfig } from "./config.js";
 import type { CoreConfig } from "./core-bridge.js";
+import { deepMergeDefined } from "./deep-merge.js";
 import { convertPcmToMulaw8k } from "./telephony-audio.js";
 
 export type TelephonyTtsRuntime = {
@@ -20,8 +21,6 @@ export type TelephonyTtsProvider = {
   synthesizeForTelephony: (text: string) => Promise<Buffer>;
 };
 
-const BLOCKED_MERGE_KEYS = new Set(["__proto__", "prototype", "constructor"]);
-
 export function createTelephonyTtsProvider(params: {
   coreConfig: CoreConfig;
   ttsOverride?: VoiceCallTtsConfig;
@@ -79,28 +78,5 @@ function mergeTtsConfig(
   if (!base) {
     return override;
   }
-  return deepMerge(base, override);
-}
-
-function deepMerge<T>(base: T, override: T): T {
-  if (!isPlainObject(base) || !isPlainObject(override)) {
-    return override;
-  }
-  const result: Record<string, unknown> = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (BLOCKED_MERGE_KEYS.has(key) || value === undefined) {
-      continue;
-    }
-    const existing = (base as Record<string, unknown>)[key];
-    if (isPlainObject(existing) && isPlainObject(value)) {
-      result[key] = deepMerge(existing, value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result as T;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  return deepMergeDefined(base, override) as VoiceCallTtsConfig;
 }

package/src/test-fixtures.ts

@@ -0,0 +1,52 @@
+import type { VoiceCallConfig } from "./config.js";
+
+export function createVoiceCallBaseConfig(params?: {
+  provider?: "telnyx" | "twilio" | "plivo" | "mock";
+  tunnelProvider?: "none" | "ngrok";
+}): VoiceCallConfig {
+  return {
+    enabled: true,
+    provider: params?.provider ?? "mock",
+    fromNumber: "+15550001234",
+    inboundPolicy: "disabled",
+    allowFrom: [],
+    outbound: { defaultMode: "notify", notifyHangupDelaySec: 3 },
+    maxDurationSeconds: 300,
+    staleCallReaperSeconds: 600,
+    silenceTimeoutMs: 800,
+    transcriptTimeoutMs: 180000,
+    ringTimeoutMs: 30000,
+    maxConcurrentCalls: 1,
+    serve: { port: 3334, bind: "127.0.0.1", path: "/voice/webhook" },
+    tailscale: { mode: "off", path: "/voice/webhook" },
+    tunnel: {
+      provider: params?.tunnelProvider ?? "none",
+      allowNgrokFreeTierLoopbackBypass: false,
+    },
+    webhookSecurity: {
+      allowedHosts: [],
+      trustForwardingHeaders: false,
+      trustedProxyIPs: [],
+    },
+    streaming: {
+      enabled: false,
+      sttProvider: "openai-realtime",
+      sttModel: "gpt-4o-transcribe",
+      silenceDurationMs: 800,
+      vadThreshold: 0.5,
+      streamPath: "/voice/stream",
+      preStartTimeoutMs: 5000,
+      maxPendingConnections: 32,
+      maxPendingConnectionsPerIp: 4,
+      maxConnections: 128,
+    },
+    skipSignatureVerification: false,
+    stt: { provider: "openai", model: "whisper-1" },
+    tts: {
+      provider: "openai",
+      openai: { model: "gpt-4o-mini-tts", voice: "coral" },
+    },
+    responseModel: "openai/gpt-4o-mini",
+    responseTimeoutMs: 30000,
+  };
+}

package/src/webhook.test.ts

@@ -274,6 +274,32 @@ describe("VoiceCallWebhookServer replay handling", () => {
   });
 });
 
+describe("VoiceCallWebhookServer response normalization", () => {
+  it("preserves explicit empty provider response bodies", async () => {
+    const responseProvider: VoiceCallProvider = {
+      ...provider,
+      parseWebhookEvent: () => ({
+        events: [],
+        statusCode: 204,
+        providerResponseBody: "",
+      }),
+    };
+    const { manager } = createManager([]);
+    const config = createConfig({ serve: { port: 0, bind: "127.0.0.1", path: "/voice/webhook" } });
+    const server = new VoiceCallWebhookServer(config, manager, responseProvider);
+
+    try {
+      const baseUrl = await server.start();
+      const response = await postWebhookForm(server, baseUrl, "CallSid=CA123&SpeechResult=hello");
+
+      expect(response.status).toBe(204);
+      expect(await response.text()).toBe("");
+    } finally {
+      await server.stop();
+    }
+  });
+});
+
 describe("VoiceCallWebhookServer start idempotency", () => {
   it("returns existing URL when start() is called twice without stop()", async () => {
     const { manager } = createManager([]);

package/src/webhook.ts

@@ -4,8 +4,8 @@ import {
   isRequestBodyLimitError,
   readRequestBodyWithLimit,
   requestBodyErrorToText,
-} from "openclaw/plugin-sdk";
-import type { VoiceCallConfig } from "./config.js";
+} from "openclaw/plugin-sdk/voice-call";
+import { normalizeVoiceCallConfig, type VoiceCallConfig } from "./config.js";
 import type { CoreConfig } from "./core-bridge.js";
 import type { CallManager } from "./manager.js";
 import type { MediaStreamConfig } from "./media-stream.js";
@@ -24,6 +24,26 @@ type WebhookResponsePayload = {
   headers?: Record<string, string>;
 };
 
+function buildRequestUrl(
+  requestUrl: string | undefined,
+  requestHost: string | undefined,
+  fallbackHost = "localhost",
+): URL {
+  return new URL(requestUrl ?? "/", `http://${requestHost ?? fallbackHost}`);
+}
+
+function normalizeWebhookResponse(parsed: {
+  statusCode?: number;
+  providerResponseHeaders?: Record<string, string>;
+  providerResponseBody?: string;
+}): WebhookResponsePayload {
+  return {
+    statusCode: parsed.statusCode ?? 200,
+    headers: parsed.providerResponseHeaders,
+    body: parsed.providerResponseBody ?? "OK",
+  };
+}
+
 /**
  * HTTP server for receiving voice call webhooks from providers.
  * Supports WebSocket upgrades for media streams when streaming is enabled.
@@ -46,13 +66,13 @@ export class VoiceCallWebhookServer {
     provider: VoiceCallProvider,
     coreConfig?: CoreConfig,
   ) {
-    this.config = config;
+    this.config = normalizeVoiceCallConfig(config);
     this.manager = manager;
     this.provider = provider;
     this.coreConfig = coreConfig ?? null;
 
     // Initialize media stream handler if streaming is enabled
-    if (config.streaming?.enabled) {
+    if (this.config.streaming.enabled) {
       this.initializeMediaStreaming();
     }
   }
@@ -68,7 +88,8 @@ export class VoiceCallWebhookServer {
    * Initialize media streaming with OpenAI Realtime STT.
    */
   private initializeMediaStreaming(): void {
-    const apiKey = this.config.streaming?.openaiApiKey || process.env.OPENAI_API_KEY;
+    const streaming = this.config.streaming;
+    const apiKey = streaming.openaiApiKey ?? process.env.OPENAI_API_KEY;
 
     if (!apiKey) {
       console.warn("[voice-call] Streaming enabled but no OpenAI API key found");
@@ -77,17 +98,17 @@ export class VoiceCallWebhookServer {
 
     const sttProvider = new OpenAIRealtimeSTTProvider({
       apiKey,
-      model: this.config.streaming?.sttModel,
-      silenceDurationMs: this.config.streaming?.silenceDurationMs,
-      vadThreshold: this.config.streaming?.vadThreshold,
+      model: streaming.sttModel,
+      silenceDurationMs: streaming.silenceDurationMs,
+      vadThreshold: streaming.vadThreshold,
     });
 
     const streamConfig: MediaStreamConfig = {
       sttProvider,
-      preStartTimeoutMs: this.config.streaming?.preStartTimeoutMs,
-      maxPendingConnections: this.config.streaming?.maxPendingConnections,
-      maxPendingConnectionsPerIp: this.config.streaming?.maxPendingConnectionsPerIp,
-      maxConnections: this.config.streaming?.maxConnections,
+      preStartTimeoutMs: streaming.preStartTimeoutMs,
+      maxPendingConnections: streaming.maxPendingConnections,
+      maxPendingConnectionsPerIp: streaming.maxPendingConnectionsPerIp,
+      maxConnections: streaming.maxConnections,
       shouldAcceptStream: ({ callId, token }) => {
         const call = this.manager.getCallByProviderCallId(callId);
         if (!call) {
@@ -190,7 +211,7 @@ export class VoiceCallWebhookServer {
    */
   async start(): Promise<string> {
     const { port, bind, path: webhookPath } = this.config.serve;
-    const streamPath = this.config.streaming?.streamPath || "/voice/stream";
+    const streamPath = this.config.streaming.streamPath;
 
     // Guard: if a server is already listening, return the existing URL.
     // This prevents EADDRINUSE when start() is called more than once on the
@@ -280,8 +301,7 @@ export class VoiceCallWebhookServer {
 
   private getUpgradePathname(request: http.IncomingMessage): string | null {
     try {
-      const host = request.headers.host || "localhost";
-      return new URL(request.url || "/", `http://${host}`).pathname;
+      return buildRequestUrl(request.url, request.headers.host).pathname;
     } catch {
       return null;
     }
@@ -322,7 +342,7 @@ export class VoiceCallWebhookServer {
     req: http.IncomingMessage,
     webhookPath: string,
   ): Promise<WebhookResponsePayload> {
-    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const url = buildRequestUrl(req.url, req.headers.host);
 
     if (url.pathname === "/voice/hold-music") {
       return {
@@ -360,7 +380,7 @@ export class VoiceCallWebhookServer {
     const ctx: WebhookContext = {
       headers: req.headers as Record<string, string | string[] | undefined>,
       rawBody: body,
-      url: `http://${req.headers.host}${req.url}`,
+      url: url.toString(),
       method: "POST",
       query: Object.fromEntries(url.searchParams),
       remoteAddress: req.socket.remoteAddress ?? undefined,
@@ -386,11 +406,7 @@ export class VoiceCallWebhookServer {
       this.processParsedEvents(parsed.events);
     }
 
-    return {
-      statusCode: parsed.statusCode || 200,
-      headers: parsed.providerResponseHeaders,
-      body: parsed.providerResponseBody || "OK",
-    };
+    return normalizeWebhookResponse(parsed);
   }
 
   private processParsedEvents(events: NormalizedEvent[]): void {