@openclaw/voice-call 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{twilio-Bp3gfmUB.mjs → twilio-BWFNGyVx.mjs}

@@ -1,38 +1,23 @@
-import { fetchWithSsrFGuard } from "../api.js";
-import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-4fkgz3UG.mjs";
-import { a as normalizeProviderStatus, b as mapVoiceToPolly, h as chunkAudio, i as mapProviderStatusToEndReason, l as getHeader, r as isProviderStatusTerminal, y as escapeXml } from "./runtime-entry-BNOQRXii.mjs";
-import { a as readVoiceCallProviderJsonResponse, i as readProviderErrorResponseSnippet, l as verifyTwilioWebhook, n as readProviderCallStatus, r as cancelProviderResponseBody, t as guardedJsonApiRequest } from "./guarded-json-api-Bqc6QS8A.mjs";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-wBOx-8sz.mjs";
+import { a as normalizeProviderStatus, g as generateDtmfRedirectTwiml, i as mapProviderStatusToEndReason, r as isProviderStatusTerminal, s as getHeader } from "./runtime-entry-CbSKxSKk.mjs";
+import { n as mapVoiceToPolly, t as escapeXml } from "./voice-mapping-B_iAUkER.mjs";
+import { n as readProviderCallStatus, o as verifyTwilioWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-x55yqHvW.mjs";
+import { asNullableObjectRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
+import { safeParseJson } from "openclaw/plugin-sdk/text-utility-runtime";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 //#region extensions/voice-call/src/providers/twilio/api.ts
-const TWILIO_API_TIMEOUT_MS = 3e4;
-/** Parse Twilio JSON error responses without trusting response shape. */
-function parseTwilioApiError(text) {
-	try {
-		const parsed = JSON.parse(text);
-		if (!parsed || typeof parsed !== "object") return {};
-		const record = parsed;
-		return {
-			code: typeof record.code === "number" ? record.code : void 0,
-			message: typeof record.message === "string" ? record.message : void 0
-		};
-	} catch {
-		return {};
-	}
-}
-/** Error thrown for non-2xx Twilio REST API responses. */
 var TwilioApiError = class extends Error {
 	constructor(httpStatus, responseText) {
-		const parsed = parseTwilioApiError(responseText);
-		const detail = parsed.message ?? responseText;
+		const parsed = asNullableObjectRecord(safeParseJson(responseText));
+		const detail = typeof parsed?.message === "string" ? parsed.message : responseText;
 		super(`Twilio API error: ${httpStatus} ${detail}`);
 		this.name = "TwilioApiError";
 		this.httpStatus = httpStatus;
 		this.responseText = responseText;
-		this.twilioCode = parsed.code;
+		this.twilioCode = typeof parsed?.code === "number" ? parsed.code : void 0;
 	}
 };
 /** POST a form-encoded Twilio REST API request through the SSRF guard. */
@@ -42,95 +27,26 @@ async function twilioApiRequest(params) {
 		else if (typeof value === "string") acc.append(key, value);
 		return acc;
 	}, new URLSearchParams());
-	const requestUrl = `${params.baseUrl}${params.endpoint}`;
-	const allowedHostname = requireSupportedTwilioApiHostname(params.baseUrl);
-	const { response, release } = await fetchWithSsrFGuard({
-		url: requestUrl,
-		init: {
-			method: "POST",
-			headers: {
-				Authorization: `Basic ${Buffer.from(`${params.accountSid}:${params.authToken}`).toString("base64")}`,
-				"Content-Type": "application/x-www-form-urlencoded"
-			},
-			body: bodyParams
+	return guardedJsonApiRequest({
+		url: `${params.baseUrl}${params.endpoint}`,
+		method: "POST",
+		headers: {
+			Authorization: `Basic ${Buffer.from(`${params.accountSid}:${params.authToken}`).toString("base64")}`,
+			"Content-Type": "application/x-www-form-urlencoded"
 		},
-		policy: { allowedHostnames: [allowedHostname] },
-		timeoutMs: TWILIO_API_TIMEOUT_MS,
-		auditContext: "voice-call.twilio.api"
-	});
-	try {
-		if (!response.ok) {
-			if (params.allowNotFound && response.status === 404) {
-				await cancelProviderResponseBody(response);
-				return;
-			}
-			const errorText = await readProviderErrorResponseSnippet(response);
-			throw new TwilioApiError(response.status, errorText);
-		}
-		return await readVoiceCallProviderJsonResponse(response, "Twilio API returned malformed JSON.");
-	} finally {
-		await release();
-	}
-}
-//#endregion
-//#region extensions/voice-call/src/providers/twilio/twiml-policy.ts
-/** Read the Twilio request fields needed by TwiML decision logic. */
-function readTwimlRequestView(ctx) {
-	const params = new URLSearchParams(ctx.rawBody);
-	const type = normalizeOptionalString(ctx.query?.type);
-	const callIdFromQuery = normalizeOptionalString(ctx.query?.callId);
-	return {
-		callStatus: params.get("CallStatus"),
-		direction: params.get("Direction"),
-		isStatusCallback: type === "status",
-		callSid: params.get("CallSid") || void 0,
-		callIdFromQuery
-	};
-}
-/** Decide the TwiML response kind for a Twilio webhook request. */
-function decideTwimlResponse(input) {
-	if (input.callIdFromQuery && !input.isStatusCallback) {
-		if (input.hasStoredTwiml) return "stored";
-		if (input.direction?.startsWith("outbound")) return input.canStream ? "stream" : "pause";
-	}
-	if (input.isStatusCallback) return "empty";
-	if (input.direction === "inbound") {
-		if (input.hasActiveStreams) return "queue";
-		if (input.canStream && input.callSid) return "stream";
-		return "pause";
-	}
-	if (input.callStatus !== "in-progress") return "empty";
-	return input.canStream ? "stream" : "pause";
-}
-//#endregion
-//#region extensions/voice-call/src/providers/twilio/webhook.ts
-/** Verify a Twilio webhook and map SDK verification details to provider result fields. */
-function verifyTwilioProviderWebhook(params) {
-	const result = verifyTwilioWebhook(params.ctx, params.authToken, {
-		publicUrl: params.currentPublicUrl || void 0,
-		allowNgrokFreeTierLoopbackBypass: params.options.allowNgrokFreeTierLoopbackBypass ?? false,
-		skipVerification: params.options.skipVerification,
-		allowedHosts: params.options.webhookSecurity?.allowedHosts,
-		trustForwardingHeaders: params.options.webhookSecurity?.trustForwardingHeaders,
-		trustedProxyIPs: params.options.webhookSecurity?.trustedProxyIPs,
-		remoteIP: params.ctx.remoteAddress
+		body: bodyParams,
+		allowNotFound: params.allowNotFound,
+		allowedHostnames: [requireSupportedTwilioApiHostname(params.baseUrl)],
+		auditContext: "voice-call.twilio.api",
+		errorPrefix: "Twilio API error",
+		malformedJsonMessage: "Twilio API returned malformed JSON.",
+		createError: (status, text) => new TwilioApiError(status, text)
 	});
-	if (!result.ok) console.warn(`[twilio] Webhook verification failed: ${result.reason}`);
-	return {
-		ok: result.ok,
-		reason: result.reason,
-		isReplay: result.isReplay,
-		verifiedRequestKey: result.verifiedRequestKey,
-		releaseReplay: result.releaseReplay
-	};
 }
 //#endregion
 //#region extensions/voice-call/src/providers/twilio.ts
 const TWILIO_CALL_NOT_IN_PROGRESS_CODE = 21220;
 const TWILIO_CALL_UPDATE_RETRY_DELAYS_MS = [250, 750];
-function isTwilioCallNotInProgressError(err) {
-	return err instanceof TwilioApiError && err.twilioCode === TWILIO_CALL_NOT_IN_PROGRESS_CODE;
-}
 function createTwilioRequestDedupeKey(ctx, verifiedRequestKey) {
 	if (verifiedRequestKey) return verifiedRequestKey;
 	const signature = getHeader(ctx.headers, "x-twilio-signature") ?? "";
@@ -158,7 +74,6 @@ var TwilioProvider = class TwilioProvider {
 		this.callWebhookUrls.delete(providerCallId);
 		this.callStreamMap.delete(providerCallId);
 		this.streamAuthTokens.delete(providerCallId);
-		this.activeStreamCalls.delete(providerCallId);
 	}
 	constructor(config, options = {}) {
 		this.name = "twilio";
@@ -170,7 +85,6 @@ var TwilioProvider = class TwilioProvider {
 		this.callStreamMap = /* @__PURE__ */ new Map();
 		this.streamAuthTokens = /* @__PURE__ */ new Map();
 		this.twimlStorage = /* @__PURE__ */ new Map();
-		this.activeStreamCalls = /* @__PURE__ */ new Set();
 		if (!config.accountSid) throw new Error("Twilio Account SID is required");
 		if (!config.authToken) throw new Error("Twilio Auth Token is required");
 		this.accountSid = config.accountSid;
@@ -193,7 +107,6 @@ var TwilioProvider = class TwilioProvider {
 	}
 	registerCallStream(callSid, streamSid) {
 		this.callStreamMap.set(callSid, streamSid);
-		this.activeStreamCalls.add(callSid);
 	}
 	hasRegisteredStream(callSid, streamSid) {
 		const current = this.callStreamMap.get(callSid);
@@ -201,13 +114,8 @@ var TwilioProvider = class TwilioProvider {
 	}
 	unregisterCallStream(callSid, streamSid) {
 		const currentStreamSid = this.callStreamMap.get(callSid);
-		if (!currentStreamSid) {
-			if (!streamSid) this.activeStreamCalls.delete(callSid);
-			return;
-		}
 		if (streamSid && currentStreamSid !== streamSid) return;
 		this.callStreamMap.delete(callSid);
-		this.activeStreamCalls.delete(callSid);
 	}
 	isConversationStreamConnectEnabled() {
 		return Boolean(this.mediaStreamHandler && this.getStreamUrl());
@@ -217,10 +125,7 @@ var TwilioProvider = class TwilioProvider {
 		if (!expected || !token) return false;
 		return safeEqualSecret(expected, token);
 	}
-	/**
-	* Clear TTS queue for a call (barge-in).
-	* Used when user starts speaking to interrupt current TTS playback.
-	*/
+	/** Interrupt active playback and queued TTS on barge-in. */
 	clearTtsQueue(callSid, reason = "unspecified") {
 		const streamSid = this.callStreamMap.get(callSid);
 		if (!streamSid || !this.mediaStreamHandler) return;
@@ -240,7 +145,7 @@ var TwilioProvider = class TwilioProvider {
 		await retryAsync(() => this.apiRequest(`/Calls/${providerCallId}.json`, { Twiml: twiml }), {
 			attempts: TWILIO_CALL_UPDATE_RETRY_DELAYS_MS.length + 1,
 			minDelayMs: 0,
-			shouldRetry: isTwilioCallNotInProgressError,
+			shouldRetry: (err) => err instanceof TwilioApiError && err.twilioCode === TWILIO_CALL_NOT_IN_PROGRESS_CODE,
 			delayMs: ({ attempt }) => TWILIO_CALL_UPDATE_RETRY_DELAYS_MS[attempt - 1] ?? 0,
 			onRetry: ({ delayMs }) => {
 				console.warn(`[voice-call] Twilio ${operation} update hit call state race (21220); retrying in ${delayMs}ms`);
@@ -248,21 +153,24 @@ var TwilioProvider = class TwilioProvider {
 			sleep: (delayMs) => sleepWithAbort(delayMs)
 		});
 	}
-	/**
-	* Verify Twilio webhook signature using HMAC-SHA1.
-	*
-	* Handles reverse proxy scenarios (Tailscale, nginx, ngrok) by reconstructing
-	* the public URL from forwarding headers.
-	*
-	* @see https://www.twilio.com/docs/usage/webhooks/webhooks-security
-	*/
 	verifyWebhook(ctx) {
-		return verifyTwilioProviderWebhook({
-			ctx,
-			authToken: this.authToken,
-			currentPublicUrl: this.currentPublicUrl,
-			options: this.options
+		const result = verifyTwilioWebhook(ctx, this.authToken, {
+			publicUrl: this.currentPublicUrl || void 0,
+			allowNgrokFreeTierLoopbackBypass: this.options.allowNgrokFreeTierLoopbackBypass ?? false,
+			skipVerification: this.options.skipVerification,
+			allowedHosts: this.options.webhookSecurity?.allowedHosts,
+			trustForwardingHeaders: this.options.webhookSecurity?.trustForwardingHeaders,
+			trustedProxyIPs: this.options.webhookSecurity?.trustedProxyIPs,
+			remoteIP: ctx.remoteAddress
 		});
+		if (!result.ok) console.warn(`[twilio] Webhook verification failed: ${result.reason}`);
+		return {
+			ok: result.ok,
+			reason: result.reason,
+			isReplay: result.isReplay,
+			verifiedRequestKey: result.verifiedRequestKey,
+			releaseReplay: result.releaseReplay
+		};
 	}
 	parseWebhookEvent(ctx, options) {
 		try {
@@ -276,10 +184,9 @@ var TwilioProvider = class TwilioProvider {
 				turnToken: turnTokenFromQuery
 			});
 			if (event?.direction === "inbound" && event.type !== "call.ended" && event.providerCallId && this.currentPublicUrl && !this.callWebhookUrls.has(event.providerCallId)) this.callWebhookUrls.set(event.providerCallId, this.currentPublicUrl);
-			const twiml = this.generateTwimlResponse(ctx);
 			return {
 				events: event ? [event] : [],
-				providerResponseBody: twiml,
+				providerResponseBody: this.generateTwimlResponse(ctx),
 				providerResponseHeaders: { "Content-Type": "application/xml" },
 				statusCode: 200
 			};
@@ -368,45 +275,40 @@ var TwilioProvider = class TwilioProvider {
   <Enqueue waitUrl="/voice/hold-music">hold-queue</Enqueue>
 </Response>`;
 	}
-	/**
-	* Generate TwiML response for webhook.
-	* When a call is answered, connects to media stream for bidirectional audio.
-	*/
 	generateTwimlResponse(ctx) {
-		if (!ctx) return TwilioProvider.EMPTY_TWIML;
-		const view = readTwimlRequestView(ctx);
-		const storedTwiml = view.callIdFromQuery ? this.twimlStorage.get(view.callIdFromQuery) : void 0;
-		switch (decideTwimlResponse({
-			...view,
-			hasStoredTwiml: Boolean(storedTwiml),
-			hasActiveStreams: this.activeStreamCalls.size > 0,
-			canStream: Boolean(view.callSid && this.getStreamUrl())
-		})) {
-			case "stored":
-				if (view.callIdFromQuery) this.twimlStorage.delete(view.callIdFromQuery);
-				return storedTwiml ?? TwilioProvider.EMPTY_TWIML;
-			case "queue": return TwilioProvider.QUEUE_TWIML;
-			case "pause": return TwilioProvider.PAUSE_TWIML;
-			case "stream": {
-				const streamUrl = view.callSid ? this.getStreamUrlForCall(view.callSid) : null;
-				return streamUrl ? this.getStreamConnectXml(streamUrl) : TwilioProvider.PAUSE_TWIML;
-			}
-			default: return TwilioProvider.EMPTY_TWIML;
+		const params = new URLSearchParams(ctx.rawBody);
+		const isStatusCallback = normalizeOptionalString(ctx.query?.type) === "status";
+		const callId = normalizeOptionalString(ctx.query?.callId);
+		const callStatus = params.get("CallStatus");
+		const direction = params.get("Direction");
+		const callSid = params.get("CallSid") || void 0;
+		const storedTwiml = callId ? this.twimlStorage.get(callId) : void 0;
+		const streamUrl = callSid ? this.getStreamUrl() : null;
+		if (callId && !isStatusCallback && storedTwiml) {
+			this.twimlStorage.delete(callId);
+			return storedTwiml;
 		}
+		if (isStatusCallback) return TwilioProvider.EMPTY_TWIML;
+		if (direction === "inbound") {
+			if (this.callStreamMap.size > 0) return TwilioProvider.QUEUE_TWIML;
+		} else if (!(callId && direction?.startsWith("outbound")) && callStatus !== "in-progress") return TwilioProvider.EMPTY_TWIML;
+		if (!streamUrl || !callSid) return TwilioProvider.PAUSE_TWIML;
+		const url = new URL(streamUrl);
+		url.searchParams.set("token", this.getStreamAuthToken(callSid));
+		return this.getStreamConnectXml(url.toString());
 	}
 	consumeInitialTwiML(ctx) {
-		const view = readTwimlRequestView(ctx);
-		if (!view.callIdFromQuery || view.isStatusCallback) return null;
-		const storedTwiml = this.twimlStorage.get(view.callIdFromQuery);
+		const params = new URLSearchParams(ctx.rawBody);
+		const isStatusCallback = normalizeOptionalString(ctx.query?.type) === "status";
+		const callId = normalizeOptionalString(ctx.query?.callId);
+		const callSid = params.get("CallSid") || void 0;
+		if (!callId || isStatusCallback) return null;
+		const storedTwiml = this.twimlStorage.get(callId);
 		if (!storedTwiml) return null;
-		this.twimlStorage.delete(view.callIdFromQuery);
-		console.log(`[voice-call] Twilio initial TwiML consumed for call ${view.callIdFromQuery} (kind=pre-connect, callSid=${view.callSid ?? "unknown"})`);
+		this.twimlStorage.delete(callId);
+		console.log(`[voice-call] Twilio initial TwiML consumed for call ${callId} (kind=pre-connect, callSid=${callSid ?? "unknown"})`);
 		return storedTwiml;
 	}
-	/**
-	* Get the WebSocket URL for media streaming.
-	* Derives from the public URL origin + stream path.
-	*/
 	getStreamUrl() {
 		if (!this.currentPublicUrl || !this.options.streamPath) return null;
 		return `${new URL(this.currentPublicUrl).origin.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://")}${this.options.streamPath.startsWith("/") ? this.options.streamPath : `/${this.options.streamPath}`}`;
@@ -418,20 +320,6 @@ var TwilioProvider = class TwilioProvider {
 		this.streamAuthTokens.set(callSid, token);
 		return token;
 	}
-	getStreamUrlForCall(callSid) {
-		const baseUrl = this.getStreamUrl();
-		if (!baseUrl) return null;
-		const token = this.getStreamAuthToken(callSid);
-		const url = new URL(baseUrl);
-		url.searchParams.set("token", token);
-		return url.toString();
-	}
-	/**
-	* Generate TwiML to connect a call to a WebSocket media stream.
-	* This enables bidirectional audio streaming for real-time STT/TTS.
-	*
-	* @param streamUrl - WebSocket URL (wss://...) for the media stream
-	*/
 	getStreamConnectXml(streamUrl) {
 		const parsed = new URL(streamUrl);
 		const token = parsed.searchParams.get("token");
@@ -508,8 +396,7 @@ var TwilioProvider = class TwilioProvider {
 				throw err instanceof Error ? err : new Error(String(err));
 			}
 		}
-		const webhookUrl = this.callWebhookUrls.get(input.providerCallId);
-		if (!webhookUrl) throw new Error("Missing webhook URL for this call (provider state not initialized)");
+		const webhookUrl = this.requireCallWebhookUrl(input.providerCallId);
 		console.warn("[voice-call] Using TwiML <Say> fallback - telephony TTS not configured or media stream not active");
 		const twiml = `<?xml version="1.0" encoding="UTF-8"?>
 <Response>
@@ -521,14 +408,7 @@ var TwilioProvider = class TwilioProvider {
 		await this.updateLiveCallTwiml(input.providerCallId, twiml, "playTts");
 	}
 	async sendDtmf(input) {
-		const webhookUrl = this.callWebhookUrls.get(input.providerCallId);
-		if (!webhookUrl) throw new Error("Missing webhook URL for this call (provider state not initialized)");
-		const twiml = `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Play digits="${escapeXml(input.digits)}" />
-  <Redirect method="POST">${escapeXml(webhookUrl)}</Redirect>
-</Response>`;
-		await this.updateLiveCallTwiml(input.providerCallId, twiml, "sendDtmf");
+		await this.updateLiveCallTwiml(input.providerCallId, generateDtmfRedirectTwiml(input.digits, this.requireCallWebhookUrl(input.providerCallId)), "sendDtmf");
 	}
 	/**
 	* Play TTS via core TTS and Twilio Media Streams.
@@ -581,16 +461,14 @@ var TwilioProvider = class TwilioProvider {
 			}
 			if (muLawAudio.length === 0) throw new Error("Telephony TTS produced no audio");
 			let chunkAttempts = 0;
-			let chunkDelivered = 0;
 			let nextChunkDueAt = Date.now() + CHUNK_DELAY_MS;
-			for (const chunk of chunkAudio(muLawAudio, CHUNK_SIZE)) {
+			for (let offset = 0; offset < muLawAudio.length; offset += CHUNK_SIZE) {
 				if (signal.aborted) break;
 				chunkAttempts += 1;
-				if (!handler.sendAudio(streamSid, chunk)) {
+				if (!handler.sendAudio(streamSid, muLawAudio.subarray(offset, offset + CHUNK_SIZE))) {
 					handler.clearAudio(streamSid);
 					throw new Error(`Telephony stream playback failed: audio chunk ${chunkAttempts} not delivered`);
 				}
-				chunkDelivered += 1;
 				const waitMs = nextChunkDueAt - Date.now();
 				if (waitMs > 0) try {
 					await sleepWithAbort(Math.ceil(waitMs), signal);
@@ -602,15 +480,12 @@ var TwilioProvider = class TwilioProvider {
 				if (signal.aborted) break;
 			}
 			if (signal.aborted) return;
-			if (chunkAttempts === 0 || chunkDelivered !== chunkAttempts) throw new Error("Telephony stream playback failed: incomplete audio delivery");
 			const markName = `tts-${Date.now()}-${++this.playbackMarkSequence}`;
 			await handler.sendMarkAndWait(streamSid, markName, muLawAudio.length / 8, signal);
 		});
 	}
 	async startListening(input) {
-		const webhookUrl = this.callWebhookUrls.get(input.providerCallId);
-		if (!webhookUrl) throw new Error("Missing webhook URL for this call (provider state not initialized)");
-		const actionUrl = new URL(webhookUrl);
+		const actionUrl = new URL(this.requireCallWebhookUrl(input.providerCallId));
 		if (input.turnToken) actionUrl.searchParams.set("turnToken", input.turnToken);
 		const twiml = `<?xml version="1.0" encoding="UTF-8"?>
 <Response>
@@ -619,9 +494,11 @@ var TwilioProvider = class TwilioProvider {
 </Response>`;
 		await this.updateLiveCallTwiml(input.providerCallId, twiml, "startListening");
 	}
-	/**
-	* Stop listening - for Twilio this is a no-op as <Gather> auto-ends.
-	*/
+	requireCallWebhookUrl(providerCallId) {
+		const webhookUrl = this.callWebhookUrls.get(providerCallId);
+		if (!webhookUrl) throw new Error("Missing webhook URL for this call (provider state not initialized)");
+		return webhookUrl;
+	}
 	async stopListening(_input) {}
 	async getCallStatus(input) {
 		return readProviderCallStatus(() => guardedJsonApiRequest({

package/dist/.setup/{twilio-region-4fkgz3UG.mjs → twilio-region-wBOx-8sz.mjs}

@@ -10,11 +10,8 @@ const TWILIO_API_HOSTNAME_BY_REGION = {
 	au1: "api.sydney.au1.twilio.com"
 };
 const TWILIO_API_HOSTNAMES = new Set(Object.values(TWILIO_API_HOSTNAME_BY_REGION));
-function resolveTwilioApiHostname(region) {
-	return TWILIO_API_HOSTNAME_BY_REGION[region ?? "us1"];
-}
 function resolveTwilioApiBaseUrl(params) {
-	return `https://${resolveTwilioApiHostname(params.region)}/2010-04-01/Accounts/${params.accountSid}`;
+	return `https://${TWILIO_API_HOSTNAME_BY_REGION[params.region ?? "us1"]}/2010-04-01/Accounts/${params.accountSid}`;
 }
 function requireSupportedTwilioApiHostname(baseUrl) {
 	const hostname = new URL(baseUrl).hostname;

package/dist/.setup/voice-mapping-B_iAUkER.mjs

@@ -0,0 +1,31 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/voice-call/src/voice-mapping.ts
+/**
+* Escape XML special characters for TwiML and other XML responses.
+*/
+function escapeXml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+const OPENAI_TO_POLLY_MAP = /* @__PURE__ */ new Map([
+	["alloy", "Polly.Joanna"],
+	["echo", "Polly.Matthew"],
+	["fable", "Polly.Amy"],
+	["onyx", "Polly.Brian"],
+	["nova", "Polly.Salli"],
+	["shimmer", "Polly.Kimberly"]
+]);
+const DEFAULT_POLLY_VOICE = "Polly.Joanna";
+/**
+* Map OpenAI voice names to Twilio Polly equivalents.
+* Falls through if already a valid Polly/Google voice.
+*
+* @param voice - OpenAI voice name (alloy, echo, etc.) or Polly voice name
+* @returns Polly voice name suitable for Twilio TwiML
+*/
+function mapVoiceToPolly(voice) {
+	if (!voice) return DEFAULT_POLLY_VOICE;
+	if (voice.startsWith("Polly.") || voice.startsWith("Google.")) return voice;
+	return OPENAI_TO_POLLY_MAP.get(normalizeLowercaseStringOrEmpty(voice)) ?? DEFAULT_POLLY_VOICE;
+}
+//#endregion
+export { mapVoiceToPolly as n, escapeXml as t };

package/dist/.setup/{webhook-replay-CCQSoBNF.mjs → webhook-replay-B7RJNWNG.mjs}

@@ -1,4 +1,5 @@
 import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 //#region extensions/voice-call/src/webhook-replay.ts
 const REPLAY_WINDOW_MS = 6e5;
 const REPLAY_CACHE_MAX_ENTRIES = 1e4;
@@ -11,11 +12,7 @@ function createWebhookReplayCache() {
 }
 function pruneWebhookReplayCache(cache, now) {
 	for (const [key, reservation] of cache.seenUntil) if (!isFutureDateTimestampMs(reservation.expiresAt, { nowMs: now })) cache.seenUntil.delete(key);
-	while (cache.seenUntil.size > REPLAY_CACHE_MAX_ENTRIES) {
-		const oldest = cache.seenUntil.keys().next().value;
-		if (!oldest) break;
-		cache.seenUntil.delete(oldest);
-	}
+	pruneMapToMaxSize(cache.seenUntil, REPLAY_CACHE_MAX_ENTRIES);
 }
 function reserveWebhookReplay(cache, replayKey) {
 	const now = Date.now();