@openclaw/voice-call 2026.7.2-beta.7 → 2026.7.34

package/dist/.setup/config-compat-CYRE-SSo.mjs

@@ -0,0 +1,156 @@
+import { t as VoiceCallConfigSchema } from "./config-BBpso-fA.mjs";
+import { asOptionalRecord, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/voice-call/src/config-compat.ts
+/** Version where legacy voice-call config shape support is removed. */
+const VOICE_CALL_LEGACY_CONFIG_REMOVAL_VERSION = "2026.6.0";
+const asObject = asOptionalRecord;
+const getString = readStringField;
+/** Read finite numeric config values. */
+function getNumber(obj, key) {
+	const value = obj?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Merge legacy provider-specific values into the canonical providers map. */
+function mergeProviderConfig(providersValue, providerId, compatValues) {
+	if (Object.keys(compatValues).length === 0) return asObject(providersValue);
+	const providers = asObject(providersValue) ?? {};
+	const existing = asObject(providers[providerId]) ?? {};
+	return {
+		...providers,
+		[providerId]: {
+			...existing,
+			...compatValues
+		}
+	};
+}
+/** Collect legacy voice-call config keys that should be migrated. */
+function collectVoiceCallLegacyConfigIssues(value) {
+	const raw = asObject(value) ?? {};
+	const realtime = asObject(raw.realtime);
+	const realtimeAgentContext = asObject(realtime?.agentContext);
+	const twilio = asObject(raw.twilio);
+	const streaming = asObject(raw.streaming);
+	const issues = [];
+	if (raw.provider === "log") issues.push({
+		path: "provider",
+		replacement: "provider",
+		message: "Replace provider \"log\" with \"mock\"."
+	});
+	if (typeof twilio?.from === "string") issues.push({
+		path: "twilio.from",
+		replacement: "fromNumber",
+		message: "Move twilio.from to fromNumber."
+	});
+	if (typeof streaming?.sttProvider === "string") issues.push({
+		path: "streaming.sttProvider",
+		replacement: "streaming.provider",
+		message: "Move streaming.sttProvider to streaming.provider."
+	});
+	if (typeof streaming?.openaiApiKey === "string") issues.push({
+		path: "streaming.openaiApiKey",
+		replacement: "streaming.providers.openai.apiKey",
+		message: "Move streaming.openaiApiKey to streaming.providers.openai.apiKey."
+	});
+	if (typeof streaming?.sttModel === "string") issues.push({
+		path: "streaming.sttModel",
+		replacement: "streaming.providers.openai.model",
+		message: "Move streaming.sttModel to streaming.providers.openai.model."
+	});
+	if (typeof streaming?.silenceDurationMs === "number") issues.push({
+		path: "streaming.silenceDurationMs",
+		replacement: "streaming.providers.openai.silenceDurationMs",
+		message: "Move streaming.silenceDurationMs to streaming.providers.openai.silenceDurationMs."
+	});
+	if (typeof streaming?.vadThreshold === "number") issues.push({
+		path: "streaming.vadThreshold",
+		replacement: "streaming.providers.openai.vadThreshold",
+		message: "Move streaming.vadThreshold to streaming.providers.openai.vadThreshold."
+	});
+	if (realtimeAgentContext && Object.hasOwn(realtimeAgentContext, "includeSystemPrompt")) issues.push({
+		path: "realtime.agentContext.includeSystemPrompt",
+		replacement: "realtime.agentContext",
+		message: "Remove realtime.agentContext.includeSystemPrompt; realtime context now uses the generated agent prompt."
+	});
+	return issues;
+}
+/** Format runtime warnings for legacy voice-call config keys. */
+function formatVoiceCallLegacyConfigWarnings(params) {
+	const issues = collectVoiceCallLegacyConfigIssues(params.value);
+	if (issues.length === 0) return [];
+	return [`[voice-call] legacy config keys detected under ${params.configPathPrefix}; runtime loading will not rewrite them, and support for the legacy shape will be removed in ${VOICE_CALL_LEGACY_CONFIG_REMOVAL_VERSION}. Run "${params.doctorFixCommand}".`, ...issues.map((issue) => `[voice-call] ${params.configPathPrefix}.${issue.path}: ${issue.message}`)];
+}
+/** Migrate legacy voice-call config input to the current canonical shape. */
+function migrateVoiceCallLegacyConfigInput(params) {
+	const raw = asObject(params.value) ?? {};
+	const realtime = asObject(raw.realtime);
+	const realtimeAgentContext = asObject(realtime?.agentContext);
+	const twilio = asObject(raw.twilio);
+	const streaming = asObject(raw.streaming);
+	const configPathPrefix = params.configPathPrefix ?? "plugins.entries.voice-call.config";
+	const issues = collectVoiceCallLegacyConfigIssues(raw);
+	const legacyStreamingOpenAICompat = {};
+	const streamingOpenAIApiKey = getString(streaming, "openaiApiKey");
+	if (streamingOpenAIApiKey) legacyStreamingOpenAICompat.apiKey = streamingOpenAIApiKey;
+	const streamingSttModel = getString(streaming, "sttModel");
+	if (streamingSttModel) legacyStreamingOpenAICompat.model = streamingSttModel;
+	const streamingSilenceDurationMs = getNumber(streaming, "silenceDurationMs");
+	if (streamingSilenceDurationMs !== void 0) legacyStreamingOpenAICompat.silenceDurationMs = streamingSilenceDurationMs;
+	const streamingVadThreshold = getNumber(streaming, "vadThreshold");
+	if (streamingVadThreshold !== void 0) legacyStreamingOpenAICompat.vadThreshold = streamingVadThreshold;
+	const streamingProvider = getString(streaming, "provider");
+	const legacyStreamingProvider = getString(streaming, "sttProvider");
+	const normalizedStreaming = streaming ? {
+		...streaming,
+		provider: streamingProvider ?? legacyStreamingProvider,
+		providers: mergeProviderConfig(streaming.providers, "openai", legacyStreamingOpenAICompat)
+	} : void 0;
+	if (normalizedStreaming) {
+		delete normalizedStreaming.sttProvider;
+		delete normalizedStreaming.openaiApiKey;
+		delete normalizedStreaming.sttModel;
+		delete normalizedStreaming.silenceDurationMs;
+		delete normalizedStreaming.vadThreshold;
+	}
+	const normalizedTwilio = twilio ? { ...twilio } : void 0;
+	if (normalizedTwilio) delete normalizedTwilio.from;
+	const normalizedRealtimeAgentContext = realtimeAgentContext ? { ...realtimeAgentContext } : void 0;
+	if (normalizedRealtimeAgentContext) delete normalizedRealtimeAgentContext.includeSystemPrompt;
+	const normalizedRealtime = realtime ? {
+		...realtime,
+		agentContext: normalizedRealtimeAgentContext ?? realtime.agentContext
+	} : void 0;
+	const config = {
+		...raw,
+		provider: raw.provider === "log" ? "mock" : raw.provider,
+		fromNumber: raw.fromNumber ?? (typeof twilio?.from === "string" ? twilio.from : void 0),
+		twilio: normalizedTwilio,
+		streaming: normalizedStreaming,
+		realtime: normalizedRealtime
+	};
+	const changes = [];
+	if (raw.provider === "log") changes.push(`Moved ${configPathPrefix}.provider "log" → "mock".`);
+	if (typeof twilio?.from === "string" && typeof raw.fromNumber !== "string") changes.push(`Moved ${configPathPrefix}.twilio.from → ${configPathPrefix}.fromNumber.`);
+	if (typeof streaming?.sttProvider === "string") changes.push(`Moved ${configPathPrefix}.streaming.sttProvider → ${configPathPrefix}.streaming.provider.`);
+	if (typeof streaming?.openaiApiKey === "string") changes.push(`Moved ${configPathPrefix}.streaming.openaiApiKey → ${configPathPrefix}.streaming.providers.openai.apiKey.`);
+	if (typeof streaming?.sttModel === "string") changes.push(`Moved ${configPathPrefix}.streaming.sttModel → ${configPathPrefix}.streaming.providers.openai.model.`);
+	if (getNumber(streaming, "silenceDurationMs") !== void 0) changes.push(`Moved ${configPathPrefix}.streaming.silenceDurationMs → ${configPathPrefix}.streaming.providers.openai.silenceDurationMs.`);
+	else if (typeof streaming?.silenceDurationMs === "number") changes.push(`Removed invalid ${configPathPrefix}.streaming.silenceDurationMs.`);
+	if (getNumber(streaming, "vadThreshold") !== void 0) changes.push(`Moved ${configPathPrefix}.streaming.vadThreshold → ${configPathPrefix}.streaming.providers.openai.vadThreshold.`);
+	else if (typeof streaming?.vadThreshold === "number") changes.push(`Removed invalid ${configPathPrefix}.streaming.vadThreshold.`);
+	if (realtimeAgentContext && Object.hasOwn(realtimeAgentContext, "includeSystemPrompt")) changes.push(`Removed ${configPathPrefix}.realtime.agentContext.includeSystemPrompt.`);
+	return {
+		config,
+		changes,
+		issues
+	};
+}
+/** Normalize legacy voice-call config input without returning migration metadata. */
+function normalizeVoiceCallLegacyConfigInput(value) {
+	return migrateVoiceCallLegacyConfigInput({ value }).config;
+}
+/** Parse voice-call plugin config after applying legacy normalization. */
+function parseVoiceCallPluginConfig(value) {
+	return VoiceCallConfigSchema.parse(normalizeVoiceCallLegacyConfigInput(value));
+}
+//#endregion
+export { parseVoiceCallPluginConfig as i, migrateVoiceCallLegacyConfigInput as n, normalizeVoiceCallLegacyConfigInput as r, formatVoiceCallLegacyConfigWarnings as t };

package/dist/{guarded-json-api-DS9sZa3C.js → .setup/guarded-json-api-BukKSVNW.mjs}

@@ -1,14 +1,12 @@
-import { fetchWithSsrFGuard } from "./runtime-api.js";
-import "./api.js";
-import { n as normalizeProxyIp, s as getHeader } from "./runtime-entry-D0UJiLfi.js";
-import { n as markWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-aaP79dI8.js";
+import { fetchWithSsrFGuard } from "../runtime-api.js";
+import "../api.js";
+import { n as normalizeProxyIp, o as getHeader } from "./runtime-entry-CH-CV0Sf.mjs";
+import { n as markWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-g3cDA5wr.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
-import { isIP } from "node:net";
-import { readResponseTextPrefix, readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 //#region extensions/voice-call/src/webhook-security.ts
 const twilioReplayCache = createWebhookReplayCache();
 const plivoReplayCache = createWebhookReplayCache();
@@ -30,7 +28,8 @@ function createSkippedVerificationReplayKey(provider, ctx) {
 function validateTwilioSignature(authToken, signature, url, params) {
 	if (!signature) return false;
 	const dataToSign = buildTwilioDataToSign(url, params);
-	return safeEqualSecret(signature, crypto.createHmac("sha1", authToken).update(dataToSign).digest("base64"));
+	const expectedSignature = crypto.createHmac("sha1", authToken).update(dataToSign).digest("base64");
+	return safeEqualSecret(signature, expectedSignature);
 }
 function buildTwilioDataToSign(url, params) {
 	let dataToSign = url;
@@ -55,24 +54,16 @@ function isValidHostname(hostname) {
 */
 function extractHostname(hostHeader) {
 	if (!hostHeader) return null;
+	let hostname;
 	if (hostHeader.startsWith("[")) {
 		const endBracket = hostHeader.indexOf("]");
 		if (endBracket === -1) return null;
-		const suffix = hostHeader.slice(endBracket + 1);
-		if (suffix && !/^:\d+$/u.test(suffix)) return null;
-		const hostname = hostHeader.slice(1, endBracket);
-		if (isIP(hostname) !== 6) return null;
-		try {
-			const parsedHostname = new URL(`https://[${hostname}]/`).hostname;
-			if (!parsedHostname.startsWith("[") || !parsedHostname.endsWith("]")) return null;
-			return normalizeLowercaseStringOrEmpty(parsedHostname.slice(1, -1));
-		} catch {
-			return null;
-		}
+		hostname = hostHeader.slice(1, endBracket);
+		return normalizeLowercaseStringOrEmpty(hostname);
 	}
 	if (hostHeader.includes("@")) return null;
-	const hostname = hostHeader.split(":").at(0);
-	if (!hostname || !isValidHostname(hostname)) return null;
+	hostname = hostHeader.split(":")[0];
+	if (!isValidHostname(hostname)) return null;
 	return normalizeLowercaseStringOrEmpty(hostname);
 }
 function extractHostnameFromHeader(headerValue) {
@@ -89,9 +80,6 @@ function normalizeAllowedHosts(allowedHosts) {
 	}
 	return normalized.size > 0 ? normalized : null;
 }
-function formatHostnameForUrl(hostname) {
-	return isIP(hostname) === 6 ? `[${hostname}]` : hostname;
-}
 /**
 * Reconstruct the public webhook URL from request headers.
 *
@@ -161,13 +149,15 @@ function reconstructWebhookUrl(ctx, options) {
 		const parsed = new URL(ctx.url);
 		path = parsed.pathname + parsed.search;
 	} catch {}
-	return `${proto}://${formatHostnameForUrl(host)}${path}`;
+	return `${proto}://${host}${path}`;
 }
 function buildTwilioVerificationUrl(ctx, publicUrl, urlOptions) {
 	if (!publicUrl) return reconstructWebhookUrl(ctx, urlOptions);
 	try {
 		const base = new URL(publicUrl);
-		base.search = new URL(ctx.url).search;
+		const requestUrl = new URL(ctx.url);
+		base.pathname = requestUrl.pathname;
+		base.search = requestUrl.search;
 		return base.toString();
 	} catch {
 		return publicUrl;
@@ -270,8 +260,8 @@ function verifyTelnyxWebhook(ctx, publicKey, options) {
 		ok: false,
 		reason: "Missing signature or timestamp header"
 	};
-	const eventTimeSec = /^(?:0|[1-9]\d*)$/.test(timestamp) ? Number(timestamp) : void 0;
-	if (eventTimeSec === void 0 || !Number.isSafeInteger(eventTimeSec)) return {
+	const eventTimeSec = Number.parseInt(timestamp, 10);
+	if (!Number.isFinite(eventTimeSec)) return {
 		ok: false,
 		reason: "Invalid timestamp header"
 	};
@@ -284,7 +274,7 @@ function verifyTelnyxWebhook(ctx, publicKey, options) {
 			ok: false,
 			reason: "Invalid signature"
 		};
-		const maxSkewMs = options?.maxSkewMs ?? 300 * 1e3;
+		const maxSkewMs = options?.maxSkewMs ?? 3e5;
 		const eventTimeMs = eventTimeSec * 1e3;
 		if (Math.abs(Date.now() - eventTimeMs) > maxSkewMs) return {
 			ok: false,
@@ -393,7 +383,9 @@ function createPlivoV3ReplayKey(params) {
 }
 function validatePlivoV2Signature(params) {
 	const baseUrl = getBaseUrlNoQuery(params.url);
-	return safeEqualSecret(normalizeSignatureBase64(crypto.createHmac("sha256", params.authToken).update(baseUrl + params.nonce).digest("base64")), normalizeSignatureBase64(params.signature));
+	const expected = normalizeSignatureBase64(crypto.createHmac("sha256", params.authToken).update(baseUrl + params.nonce).digest("base64"));
+	const provided = normalizeSignatureBase64(params.signature);
+	return safeEqualSecret(expected, provided);
 }
 function toParamMapFromSearchParams(sp) {
 	const map = {};
@@ -405,18 +397,16 @@ function toParamMapFromSearchParams(sp) {
 }
 function sortedQueryString(params) {
 	const parts = [];
-	const entries = Object.entries(params).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-	for (const [key, entryValues] of entries) {
-		const values = [...entryValues].toSorted();
+	for (const key of Object.keys(params).toSorted()) {
+		const values = [...params[key]].toSorted();
 		for (const value of values) parts.push(`${key}=${value}`);
 	}
 	return parts.join("&");
 }
 function sortedParamsString(params) {
 	const parts = [];
-	const entries = Object.entries(params).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-	for (const [key, entryValues] of entries) {
-		const values = [...entryValues].toSorted();
+	for (const key of Object.keys(params).toSorted()) {
+		const values = [...params[key]].toSorted();
 		for (const value of values) parts.push(`${key}${value}`);
 	}
 	return parts.join("");
@@ -474,6 +464,7 @@ function verifyPlivoWebhook(ctx, authToken, options) {
 	if (options?.publicUrl) try {
 		const req = new URL(reconstructed);
 		const base = new URL(options.publicUrl);
+		base.pathname = req.pathname;
 		base.search = req.search;
 		verificationUrl = base.toString();
 	} catch {
@@ -546,8 +537,8 @@ function verifyPlivoWebhook(ctx, authToken, options) {
 }
 //#endregion
 //#region extensions/voice-call/src/providers/shared/response-body.ts
-const PROVIDER_JSON_RESPONSE_MAX_BYTES = 1 * 1024 * 1024;
-const PROVIDER_ERROR_RESPONSE_MAX_BYTES = 8 * 1024;
+const PROVIDER_JSON_RESPONSE_MAX_BYTES = 1048576;
+const PROVIDER_ERROR_RESPONSE_MAX_BYTES = 8192;
 const TRUNCATED_SUFFIX = "... [truncated]";
 async function cancelProviderResponseBody(response) {
 	await response.body?.cancel().catch(() => void 0);
@@ -556,12 +547,35 @@ function appendTruncatedSuffix(text) {
 	return `${text.trimEnd()}${TRUNCATED_SUFFIX}`;
 }
 async function readProviderResponseTextWithLimit(params) {
-	if (params.truncateOnLimit) {
-		const prefix = await readResponseTextPrefix(params.response, params.maxBytes);
-		return prefix.truncated ? appendTruncatedSuffix(prefix.text) : prefix.text;
+	if (!params.response.body) return "";
+	const reader = params.response.body.getReader();
+	const decoder = new TextDecoder();
+	let totalBytes = 0;
+	let text = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) return text + decoder.decode();
+			if (!value?.byteLength) continue;
+			const remainingBytes = params.maxBytes - totalBytes;
+			if (value.byteLength > remainingBytes) {
+				if (params.truncateOnLimit) {
+					const clipped = remainingBytes > 0 ? value.slice(0, remainingBytes) : void 0;
+					if (clipped) text += decoder.decode(clipped, { stream: true });
+					await reader.cancel().catch(() => void 0);
+					return appendTruncatedSuffix(text + decoder.decode());
+				}
+				await reader.cancel().catch(() => void 0);
+				throw new Error(`provider response body too large: ${totalBytes + value.byteLength} bytes (limit: ${params.maxBytes} bytes)`);
+			}
+			text += decoder.decode(value, { stream: true });
+			totalBytes += value.byteLength;
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
 	}
-	const body = await readResponseWithLimit(params.response, params.maxBytes, { onOverflow: ({ size, maxBytes }) => /* @__PURE__ */ new Error(`provider response body too large: ${size} bytes (limit: ${maxBytes} bytes)`) });
-	return new TextDecoder().decode(body);
 }
 async function readProviderJsonResponseText(response) {
 	return await readProviderResponseTextWithLimit({

package/dist/{mock-YsvBTX-7.js → .setup/mock-DY4yTqR2.mjs}

@@ -1,4 +1,4 @@
-import { n as markWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-aaP79dI8.js";
+import { n as markWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-g3cDA5wr.mjs";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/mock.ts

package/dist/{plivo-vZ--Wqxv.js → .setup/plivo-DFHh72MH.mjs}

@@ -1,5 +1,5 @@
-import { _ as escapeXml, s as getHeader } from "./runtime-entry-D0UJiLfi.js";
-import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-DS9sZa3C.js";
+import { g as escapeXml, o as getHeader } from "./runtime-entry-CH-CV0Sf.mjs";
+import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-BukKSVNW.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/plivo.ts
@@ -371,6 +371,7 @@ var PlivoProvider = class PlivoProvider {
 		try {
 			if (this.options.publicUrl) {
 				const base = new URL(this.options.publicUrl);
+				base.pathname = new URL(ctx.url).pathname;
 				return `${base.origin}${base.pathname}`;
 			}
 			const u = new URL(reconstructWebhookUrl(ctx, {