@openclaw/voice-call 2026.10.10 → 2026.11.5-beta.1

package/dist/.setup/{config-BxESUUSm.mjs → config-D_w9HzxP.mjs}

@@ -1,6 +1,8 @@
 import { TtsConfigSchema } from "../api.js";
 import { t as TWILIO_REGIONS } from "./twilio-region-DVg9p6JJ.mjs";
+import { MAX_TCP_PORT } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES, resolveRealtimeVoiceAgentConsultTools } from "openclaw/plugin-sdk/realtime-voice";
 import { z } from "zod";
 import { mergeDeep } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -8,7 +10,6 @@ import { buildSecretInputSchema, hasConfiguredSecretInput, normalizeResolvedSecr
 import { canonicalizeMainSessionAlias } from "openclaw/plugin-sdk/session-store-runtime";
 import { resolveSpeechProviderApiKey } from "openclaw/plugin-sdk/speech-core";
 import { normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
-import { MAX_TCP_PORT } from "openclaw/plugin-sdk/number-runtime";
 // extensions/voice-call/src/call-brief-schema.ts
 const text = (max) => z.string().trim().min(1).max(max);
 const CallBriefSchema = z.object({
@@ -279,7 +280,7 @@ const VoiceCallRealtimeConfigSchema = z.object({
 	/** Bounded agent persona/context injection for the fast realtime voice path. */
 	agentContext: VoiceCallRealtimeAgentContextConfigSchema.default(VoiceCallRealtimeAgentContextConfigSchema.parse({})),
 	/** Provider-owned raw config blobs keyed by provider id. */
-	providers: VoiceCallProvidersConfigSchema
+	providers: z.record(z.string(), z.object({ inputTranscriptionModel: z.string().optional().describe("Input transcription model or deployment name. Omit to keep the provider default.") }).catchall(z.unknown())).default({})
 }).strict();
 const VoiceCallStreamingConfigSchema = z.object({
 	/** Enable Twilio Media Streams for real-time transcription. */
@@ -325,7 +326,6 @@ const VoiceCallConfigSchema = z.object({
 	live: CallLiveConfigSchema,
 	callbacks: CallCallbacksConfigSchema,
 	voicemail: CallVoicemailConfigSchema,
-	/** Maximum call duration in seconds */
 	maxDurationSeconds: z.number().int().positive().default(300),
 	/**
 	* Maximum age of a call in seconds before it is automatically reaped.
@@ -364,7 +364,6 @@ const VoiceCallConfigSchema = z.object({
 	message: "Tailscale Funnel HTTPS port must be one of 443, 8443, 10000"
 });
 const TWILIO_AUTH_TOKEN_PATH = "plugins.entries.voice-call.config.twilio.authToken";
-const DEFAULT_VOICE_CALL_CONFIG = VoiceCallConfigSchema.parse({});
 function defaultRealtimeStreamPathForServePath(servePath) {
 	const normalized = normalizeWebhookPath(servePath);
 	if (normalized.endsWith("/webhook")) return `${normalized.slice(0, -8)}/stream/realtime`;
@@ -396,10 +395,6 @@ function resolveVoiceCallStreamExposurePaths(config, webhookPaths = {}) {
 	}
 	return exposurePaths;
 }
-function normalizeVoiceCallTtsConfig(defaults, overrides) {
-	if (!defaults && !overrides) return;
-	return TtsConfigSchema.parse(mergeDeep(defaults ?? {}, overrides ?? {}));
-}
 function resolveVoiceCallNumberRouteKey(config, phone) {
 	const routes = config.numbers;
 	if (phone && Object.hasOwn(routes, phone)) return phone;
@@ -419,20 +414,20 @@ function resolveVoiceCallEffectiveConfig(config, phoneOrRouteKey) {
 	if (!numberRouteKey) return { config };
 	const route = config.numbers[numberRouteKey];
 	if (!route) return { config };
+	const defaultTts = config.tts;
+	const routeTts = route.tts;
 	return {
 		numberRouteKey,
 		config: {
 			...config,
 			...route,
-			tts: normalizeVoiceCallTtsConfig(config.tts, route.tts)
+			tts: !defaultTts && !routeTts ? void 0 : TtsConfigSchema.parse(mergeDeep(defaultTts ?? {}, routeTts ?? {}))
 		}
 	};
 }
-function sanitizeVoiceCallProviderConfigs(value) {
-	return Object.fromEntries(Object.entries(value ?? {}).filter((entry) => entry[1] !== void 0));
-}
-function sanitizeVoiceCallNumberRoutes(value) {
-	return Object.fromEntries(Object.entries(value ?? {}).filter(([, route]) => route !== void 0).map(([key, route]) => [key, VoiceCallNumberRouteConfigSchema.parse(route)]));
+function definedConfigEntries(value) {
+	const entries = asOptionalRecord(value);
+	return entries ? Object.fromEntries(Object.entries(entries).filter(([, entry]) => entry !== void 0)) : value;
 }
 function resolveTwilioAuthToken(config) {
 	return normalizeResolvedSecretInputString({
@@ -440,110 +435,61 @@ function resolveTwilioAuthToken(config) {
 		path: TWILIO_AUTH_TOKEN_PATH
 	});
 }
-function normalizeVoiceCallConfig(config) {
-	const defaults = structuredClone(DEFAULT_VOICE_CALL_CONFIG);
-	const serve = {
-		...defaults.serve,
-		...config.serve
-	};
-	const streamingProvider = config.streaming?.provider;
-	const streamingProviders = sanitizeVoiceCallProviderConfigs(config.streaming?.providers ?? defaults.streaming.providers);
-	const realtimeProvider = config.realtime?.provider ?? defaults.realtime.provider;
-	const realtimeProviders = sanitizeVoiceCallProviderConfigs(config.realtime?.providers ?? defaults.realtime.providers);
-	const realtimeFastContext = {
-		...defaults.realtime.fastContext,
-		...config.realtime?.fastContext,
-		sources: config.realtime?.fastContext?.sources ?? defaults.realtime.fastContext.sources
-	};
-	const realtimeAgentContext = {
-		...defaults.realtime.agentContext,
-		...config.realtime?.agentContext,
-		files: config.realtime?.agentContext?.files ?? defaults.realtime.agentContext.files
-	};
-	return {
-		...defaults,
+function normalizeVoiceCallConfig(value) {
+	const config = asOptionalRecord(value);
+	if (!config) return VoiceCallConfigSchema.parse(value);
+	const streaming = asOptionalRecord(config.streaming);
+	const realtime = asOptionalRecord(config.realtime);
+	const normalized = VoiceCallConfigSchema.parse({
 		...config,
-		allowFrom: config.allowFrom ?? defaults.allowFrom,
-		numbers: sanitizeVoiceCallNumberRoutes(config.numbers ?? defaults.numbers),
-		outbound: {
-			...defaults.outbound,
-			...config.outbound
-		},
-		reports: CallReportsConfigSchema.parse(config.reports),
-		live: CallLiveConfigSchema.parse(config.live),
-		callbacks: CallCallbacksConfigSchema.parse(config.callbacks),
-		voicemail: CallVoicemailConfigSchema.parse(config.voicemail),
-		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,
-			provider: streamingProvider,
-			providers: streamingProviders
-		},
-		realtime: {
-			...defaults.realtime,
-			...config.realtime,
-			provider: realtimeProvider,
-			streamPath: config.realtime?.streamPath ?? defaultRealtimeStreamPathForServePath(serve.path ?? defaults.serve.path),
-			tools: config.realtime?.tools ?? defaults.realtime.tools,
-			consultThinkingLevel: VoiceCallRealtimeConsultThinkingLevelSchema.optional().parse(config.realtime?.consultThinkingLevel ?? defaults.realtime.consultThinkingLevel),
-			consultFastMode: config.realtime?.consultFastMode ?? defaults.realtime.consultFastMode,
-			fastContext: realtimeFastContext,
-			agentContext: realtimeAgentContext,
-			providers: realtimeProviders
-		},
-		tts: normalizeVoiceCallTtsConfig(defaults.tts, config.tts)
-	};
+		numbers: definedConfigEntries(config.numbers),
+		webhookSecurity: config.webhookSecurity === void 0 ? {} : config.webhookSecurity,
+		streaming: config.streaming === void 0 || streaming ? {
+			...streaming,
+			providers: definedConfigEntries(streaming?.providers)
+		} : config.streaming,
+		realtime: config.realtime === void 0 || realtime ? {
+			...realtime,
+			fastContext: realtime?.fastContext === void 0 ? {} : realtime.fastContext,
+			agentContext: realtime?.agentContext === void 0 ? {} : realtime.agentContext,
+			providers: definedConfigEntries(realtime?.providers)
+		} : config.realtime
+	});
+	normalized.realtime.streamPath ??= defaultRealtimeStreamPathForServePath(normalized.serve.path);
+	return normalized;
 }
 function resolveVoiceCallSessionKey(params) {
 	const explicit = params.explicitSessionKey?.trim();
-	if (explicit || params.config.sessionScope === "main") return resolveVoiceCallAgentSessionKey({
-		config: params.config,
-		sessionKey: explicit || "main",
-		coreSession: params.coreSession
-	});
+	if (explicit || params.config.sessionScope === "main") {
+		const sessionKey = (explicit || "main").trim();
+		if (!sessionKey) throw new Error("Voice Call session key cannot be empty");
+		const lower = sessionKey.toLowerCase();
+		const agentId = normalizeAgentId(params.config.agentId);
+		if (lower === "global" || lower === "unknown") return lower;
+		const parsedInput = parseAgentSessionKey(sessionKey);
+		let normalizedScopedKey;
+		if (parsedInput && normalizeAgentId(parsedInput.agentId) === parsedInput.agentId && parsedInput.agentId === agentId) normalizedScopedKey = `agent:${parsedInput.agentId}:${parsedInput.rest}`;
+		else {
+			const wrappedInput = parseAgentSessionKey(`agent:${agentId}:${sessionKey}`);
+			if (!wrappedInput) throw new Error("Voice Call session key could not be normalized");
+			normalizedScopedKey = `agent:${agentId}:${wrappedInput.rest}`;
+		}
+		return canonicalizeMainSessionAlias({
+			cfg: { session: params.coreSession },
+			agentId,
+			sessionKey: normalizedScopedKey
+		});
+	}
 	const prefix = `agent:${normalizeAgentId(params.config.agentId)}:voice`;
 	if (params.config.sessionScope === "per-call") return `${prefix}:call:${params.callId}`.toLowerCase();
 	const normalizedPhone = normalizePhoneNumber(params.phone);
 	return (normalizedPhone ? `${prefix}:${normalizedPhone}` : `${prefix}:${params.callId}`).toLowerCase();
 }
-/** Resolve persisted or integration-provided keys into the configured agent namespace. */
-function resolveVoiceCallAgentSessionKey(params) {
-	const sessionKey = params.sessionKey.trim();
-	if (!sessionKey) throw new Error("Voice Call session key cannot be empty");
-	const lower = sessionKey.toLowerCase();
-	const agentId = normalizeAgentId(params.config.agentId);
-	if (lower === "global" || lower === "unknown") return lower;
-	const parsedInput = parseAgentSessionKey(sessionKey);
-	let normalizedScopedKey;
-	if (parsedInput && normalizeAgentId(parsedInput.agentId) === parsedInput.agentId && parsedInput.agentId === agentId) normalizedScopedKey = `agent:${parsedInput.agentId}:${parsedInput.rest}`;
-	else {
-		const wrappedInput = parseAgentSessionKey(`agent:${agentId}:${sessionKey}`);
-		if (!wrappedInput) throw new Error("Voice Call session key could not be normalized");
-		normalizedScopedKey = `agent:${agentId}:${wrappedInput.rest}`;
-	}
-	return canonicalizeMainSessionAlias({
-		cfg: { session: params.coreSession },
-		agentId,
-		sessionKey: normalizedScopedKey
-	});
-}
 function resolveVoiceCallConfig(config) {
-	const resolved = normalizeVoiceCallConfig(config);
+	const resolved = {
+		...config,
+		tunnel: { ...config.tunnel }
+	};
 	if (resolved.provider === "telnyx") {
 		resolved.telnyx = resolved.telnyx ?? {};
 		resolved.telnyx.apiKey = resolved.telnyx.apiKey ?? resolveSpeechProviderApiKey(process.env.TELNYX_API_KEY);
@@ -561,10 +507,8 @@ function resolveVoiceCallConfig(config) {
 		resolved.plivo.authId = resolved.plivo.authId ?? resolveSpeechProviderApiKey(process.env.PLIVO_AUTH_ID);
 		resolved.plivo.authToken = resolved.plivo.authToken ?? resolveSpeechProviderApiKey(process.env.PLIVO_AUTH_TOKEN);
 	}
-	resolved.tunnel.allowNgrokFreeTierLoopbackBypass = resolved.tunnel.allowNgrokFreeTierLoopbackBypass ?? false;
 	resolved.tunnel.ngrokAuthToken = resolved.tunnel.ngrokAuthToken ?? resolveSpeechProviderApiKey(process.env.NGROK_AUTHTOKEN);
 	resolved.tunnel.ngrokDomain = resolved.tunnel.ngrokDomain ?? resolveSpeechProviderApiKey(process.env.NGROK_DOMAIN);
-	resolved.webhookSecurity.trustForwardingHeaders = resolved.webhookSecurity.trustForwardingHeaders ?? false;
 	return resolved;
 }
 function validateProviderConfig(config) {
@@ -600,4 +544,4 @@ function validateProviderConfig(config) {
 		errors
 	};
 }
-export { resolveVoiceCallEffectiveConfig as a, resolveVoiceCallSessionKey as c, REALTIME_VOICE_END_CALL_TOOL_NAME as d, resolveVoiceCallRealtimeTools as f, CallBriefSchema as g, normalizePhoneNumber as h, resolveVoiceCallConfig as i, resolveVoiceCallStreamExposurePaths as l, isAllowlistedCaller as m, normalizeVoiceCallConfig as n, resolveVoiceCallNumberRouteKeyForCall as o, DEFAULT_VOICEMAIL_HOLD_OPENING_MAX_MS as p, resolveTwilioAuthToken as r, resolveVoiceCallPublicPathPrefix as s, VoiceCallConfigSchema as t, validateProviderConfig as u };
+export { resolveVoiceCallNumberRouteKeyForCall as a, resolveVoiceCallStreamExposurePaths as c, resolveVoiceCallRealtimeTools as d, DEFAULT_VOICEMAIL_HOLD_OPENING_MAX_MS as f, CallBriefSchema as h, resolveVoiceCallEffectiveConfig as i, validateProviderConfig as l, normalizePhoneNumber as m, resolveTwilioAuthToken as n, resolveVoiceCallPublicPathPrefix as o, isAllowlistedCaller as p, resolveVoiceCallConfig as r, resolveVoiceCallSessionKey as s, normalizeVoiceCallConfig as t, REALTIME_VOICE_END_CALL_TOOL_NAME as u };

package/dist/.setup/{mock-BO3pptb-.mjs → mock-fux1a_i_.mjs}

@@ -1,6 +1,6 @@
-import { n as reserveWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-B0Eo3Ll5.mjs";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { n as reserveWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-DnlMxw4z.mjs";
 import crypto from "node:crypto";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 // extensions/voice-call/src/providers/mock.ts
 /**
 * Mock voice call provider for local testing.
@@ -83,8 +83,7 @@ var MockProvider = class {
 					...base,
 					type: evt.type,
 					transcript,
-					isFinal: evt.isFinal ?? true,
-					confidence: evt.confidence
+					isFinal: evt.isFinal ?? true
 				};
 			}
 			case "call.silence": return {

package/dist/.setup/{plivo-C5cLYAup.mjs → plivo-Cpxxx8BT.mjs}

@@ -1,16 +1,8 @@
-import { c as getHeader } from "./runtime-entry-CKPPin7r.mjs";
 import { t as escapeXml } from "./voice-mapping-CvuJ1B50.mjs";
-import { n as reconstructWebhookUrl, r as verifyPlivoWebhook, t as createCarrierApi } from "./carrier-api-BgJdQC-e.mjs";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { i as verifyPlivoWebhook, n as assertVoiceCallProviderSetting, r as reconstructWebhookUrl, t as createCarrierApi } from "./carrier-api-CZQtPnYQ.mjs";
 import crypto from "node:crypto";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 // extensions/voice-call/src/providers/plivo.ts
-function createPlivoRequestDedupeKey(ctx) {
-	const nonceV3 = getHeader(ctx.headers, "x-plivo-signature-v3-nonce");
-	if (nonceV3) return `plivo:v3:${nonceV3}`;
-	const nonceV2 = getHeader(ctx.headers, "x-plivo-signature-v2-nonce");
-	if (nonceV2) return `plivo:v2:${nonceV2}`;
-	return `plivo:fallback:${crypto.createHash("sha256").update(ctx.rawBody).digest("hex")}`;
-}
 var PlivoProvider = class PlivoProvider {
 	/**
 	* Release all process-local metadata owned by one Plivo call.
@@ -38,8 +30,8 @@ var PlivoProvider = class PlivoProvider {
 		this.callUuidToWebhookUrl = /* @__PURE__ */ new Map();
 		this.pendingSpeakByCallId = /* @__PURE__ */ new Map();
 		this.pendingListenByCallId = /* @__PURE__ */ new Map();
-		if (!config.authId) throw new Error("Plivo Auth ID is required");
-		if (!config.authToken) throw new Error("Plivo Auth Token is required");
+		assertVoiceCallProviderSetting(config.authId, "Plivo Auth ID is required");
+		assertVoiceCallProviderSetting(config.authToken, "Plivo Auth Token is required");
 		this.authToken = config.authToken;
 		this.options = options;
 		this.api = createCarrierApi("Plivo", `https://api.plivo.com/v1/Account/${config.authId}`, `Basic ${Buffer.from(`${config.authId}:${config.authToken}`).toString("base64")}`);
@@ -54,13 +46,7 @@ var PlivoProvider = class PlivoProvider {
 			remoteIP: ctx.remoteAddress
 		});
 		if (!result.ok) console.warn(`[plivo] Webhook verification failed: ${result.reason}`);
-		return {
-			ok: result.ok,
-			reason: result.reason,
-			isReplay: result.isReplay,
-			verifiedRequestKey: result.verifiedRequestKey,
-			releaseReplay: result.releaseReplay
-		};
+		return result;
 	}
 	parseWebhookEvent(ctx, options) {
 		const flow = normalizeOptionalString(ctx.query?.flow) ?? "";
@@ -86,8 +72,7 @@ var PlivoProvider = class PlivoProvider {
 				actionUrl
 			}) : pendingSpeak ? PlivoProvider.xmlKeepAlive(`  <Speak language="${escapeXml(language || "en-US")}">${escapeXml(pendingSpeak.text)}</Speak>\n`) : PlivoProvider.xmlKeepAlive();
 		} else {
-			const dedupeKey = options?.verifiedRequestKey ?? createPlivoRequestDedupeKey(ctx);
-			event = this.normalizeEvent(parsed, callId, dedupeKey);
+			event = this.normalizeEvent(parsed, callId, options?.verifiedRequestKey);
 			providerResponseBody = flow === "answer" || flow === "getinput" ? PlivoProvider.xmlKeepAlive() : "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Response></Response>";
 		}
 		return {