@openclaw/voice-call 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{runtime-entry-DSgyqIwE.js → runtime-entry-CQtitvRd.js}

@@ -8,6 +8,7 @@ import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveExpiresAtMsFromDuration
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES, assertRealtimeVoiceAgentConsultModelSelectionUnlocked, buildRealtimeVoiceAgentConsultPolicyInstructions, consultRealtimeVoiceAgent, convertPcmToMulaw8k, createTalkSessionController, recordTalkObservabilityEvent, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow, resolveRealtimeVoiceFastContextConsult } from "openclaw/plugin-sdk/realtime-voice";
 import { mergeDeep } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -23,13 +24,13 @@ import path from "node:path";
 import os from "node:os";
 import { root } from "openclaw/plugin-sdk/security-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
 import { spawn } from "node:child_process";
 import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import http from "node:http";
 import { URL as URL$1 } from "node:url";
 import { resolveConfiguredCapabilityProvider } from "openclaw/plugin-sdk/provider-selection-runtime";
 import { WebSocket, WebSocketServer } from "ws";
+import { canonicalizeBase64 } from "openclaw/plugin-sdk/media-runtime";
 //#region extensions/voice-call/src/realtime-defaults.ts
 /** Baseline instructions that keep realtime calls brief and route deep work to agent consult. */
 const DEFAULT_VOICE_CALL_REALTIME_INSTRUCTIONS = `You are OpenClaw's phone-call realtime voice interface. Keep spoken replies brief and natural. When a question needs deeper reasoning, current information, or tools, call ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} before answering.`;
@@ -405,7 +406,7 @@ const VoiceCallConfigSchema = z.object({
 	publicUrl: z.string().url().optional(),
 	/** Skip webhook signature verification (development only, NOT for production) */
 	skipSignatureVerification: z.boolean().default(false),
-	/** TTS override (deep-merges with core messages.tts) */
+	/** TTS override (deep-merges with core tts) */
 	tts: TtsConfigSchema,
 	/** Store path for call logs */
 	store: z.string().optional(),
@@ -1839,7 +1840,7 @@ async function buildRealtimeVoiceInstructions(params) {
 	if (consultGuidance) sections.push(consultGuidance);
 	const contextConfig = config.realtime.agentContext;
 	if (!contextConfig.enabled) return sections.filter(Boolean).join("\n\n");
-	const agentId = config.agentId ?? "main";
+	const { agentId } = params;
 	const capsule = [
 		"OpenClaw agent voice context:",
 		`- Agent id: ${agentId}`,
@@ -1913,26 +1914,26 @@ function chunkAudio(audio, chunkSize = 160) {
 /** Default timeout for one telephony synthesis request. */
 const TELEPHONY_DEFAULT_TTS_TIMEOUT_MS = 8e3;
 /** Create a TTS provider that honors voice-call overrides and converts PCM to mulaw. */
-function createTelephonyTtsProvider(params) {
+async function createTelephonyTtsProvider(params) {
 	const { coreConfig, ttsOverride, runtime, logger } = params;
-	const mergedConfig = applyTtsOverride(coreConfig, ttsOverride);
-	const ttsConfig = mergedConfig.messages?.tts;
-	const modelOverrides = resolveTelephonyModelOverridePolicy(readTelephonyModelOverrides(ttsConfig));
-	const providerConfigs = collectTelephonyProviderConfigs(ttsConfig);
-	const activeProvider = normalizeProviderId(ttsConfig?.provider);
+	const preparedConfig = await runtime.prepareTtsRequest({
+		cfg: coreConfig,
+		override: ttsOverride,
+		text: ""
+	});
 	return {
-		synthesisTimeoutMs: resolveTimerTimeoutMs(mergedConfig.messages?.tts?.timeoutMs, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS),
+		synthesisTimeoutMs: resolveTimerTimeoutMs(preparedConfig.cfg.tts?.timeoutMs, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS),
 		synthesizeForTelephony: async (text) => {
-			const directives = parseTtsDirectives(text, modelOverrides, {
-				cfg: mergedConfig,
-				providerConfigs,
-				preferredProviderId: activeProvider
+			const prepared = await runtime.prepareTtsRequest({
+				cfg: preparedConfig.cfg,
+				text
 			});
+			const directives = prepared.directives;
 			if (directives.warnings.length > 0) logger?.warn?.(`[voice-call] Ignored telephony TTS directive overrides (${directives.warnings.join("; ")})`);
 			const cleanText = directives.hasDirective ? directives.ttsText?.trim() || directives.cleanedText.trim() : text;
 			const result = await runtime.textToSpeechTelephony({
 				text: cleanText,
-				cfg: mergedConfig,
+				cfg: prepared.cfg,
 				overrides: directives.overrides
 			});
 			if (!result.success || !result.audioBuffer || !result.sampleRate) throw new Error(result.error ?? "TTS conversion failed");
@@ -1944,94 +1945,6 @@ function createTelephonyTtsProvider(params) {
 		}
 	};
 }
-/** Apply voice-call TTS overrides to core config without mutating the original object. */
-function applyTtsOverride(coreConfig, override) {
-	if (!override) return coreConfig;
-	const base = coreConfig.messages?.tts;
-	const merged = mergeTtsConfig(base, override);
-	if (!merged) return coreConfig;
-	return {
-		...coreConfig,
-		messages: {
-			...coreConfig.messages,
-			tts: merged
-		}
-	};
-}
-/** Merge core and voice-call TTS config, keeping undefined override fields out. */
-function mergeTtsConfig(base, override) {
-	if (!base && !override) return;
-	if (!override) return base;
-	if (!base) return override;
-	return mergeDeep(base, override);
-}
-/** Resolve directive override policy for telephony synthesis. */
-function resolveTelephonyModelOverridePolicy(overrides) {
-	if (!(overrides?.enabled ?? true)) return {
-		enabled: false,
-		allowText: false,
-		allowProvider: false,
-		allowVoice: false,
-		allowModelId: false,
-		allowVoiceSettings: false,
-		allowNormalization: false,
-		allowSeed: false
-	};
-	const allow = (value, defaultValue = true) => value ?? defaultValue;
-	return {
-		enabled: true,
-		allowText: allow(overrides?.allowText),
-		allowProvider: allow(overrides?.allowProvider, false),
-		allowVoice: allow(overrides?.allowVoice),
-		allowModelId: allow(overrides?.allowModelId),
-		allowVoiceSettings: allow(overrides?.allowVoiceSettings),
-		allowNormalization: allow(overrides?.allowNormalization),
-		allowSeed: allow(overrides?.allowSeed)
-	};
-}
-/** Read model override policy from TTS config when present. */
-function readTelephonyModelOverrides(ttsConfig) {
-	const value = ttsConfig?.modelOverrides;
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-/** Normalize provider ids for config lookup. */
-function normalizeProviderId(value) {
-	return typeof value === "string" ? value.trim().toLowerCase() || void 0 : void 0;
-}
-/** Coerce provider config objects while rejecting arrays and primitives. */
-function asProviderConfig(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-/** Collect named provider configs from canonical and legacy TTS config shapes. */
-function collectTelephonyProviderConfigs(ttsConfig) {
-	if (!ttsConfig) return {};
-	const entries = {};
-	const rawProviders = ttsConfig.providers && typeof ttsConfig.providers === "object" && !Array.isArray(ttsConfig.providers) ? ttsConfig.providers : {};
-	for (const [providerId, value] of Object.entries(rawProviders)) {
-		const normalized = normalizeProviderId(providerId) ?? providerId;
-		entries[normalized] = asProviderConfig(value);
-	}
-	const reservedKeys = /* @__PURE__ */ new Set([
-		"auto",
-		"enabled",
-		"maxTextLength",
-		"mode",
-		"modelOverrides",
-		"persona",
-		"personas",
-		"prefsPath",
-		"provider",
-		"providers",
-		"summaryModel",
-		"timeoutMs"
-	]);
-	for (const [key, value] of Object.entries(ttsConfig)) {
-		if (reservedKeys.has(key) || typeof value !== "object" || value === null || Array.isArray(value)) continue;
-		const normalized = normalizeProviderId(key) ?? key;
-		entries[normalized] ??= asProviderConfig(value);
-	}
-	return entries;
-}
 //#endregion
 //#region extensions/voice-call/src/bounded-child-output.ts
 const DEFAULT_MAX_OUTPUT_CHARS = 16384;
@@ -2159,6 +2072,30 @@ async function cleanupTailscaleExposure(config) {
 const NGROK_LOG_BUFFER_MAX_CHARS = 16384;
 const NGROK_ERROR_MARKER = "ERR_NGROK";
 const TUNNEL_COMMAND_OUTPUT_MAX_BYTES = 16384;
+const NGROK_STOP_GRACE_MS = 2e3;
+const NGROK_FORCE_KILL_WAIT_MS = 1e3;
+async function terminateNgrokProcess(proc, isClosed) {
+	if (isClosed()) return;
+	await new Promise((resolve) => {
+		let finished = false;
+		let forceKillWaitTimer;
+		const finish = () => {
+			if (finished) return;
+			finished = true;
+			if (forceKillTimer) clearTimeout(forceKillTimer);
+			if (forceKillWaitTimer) clearTimeout(forceKillWaitTimer);
+			proc.off("close", finish);
+			resolve();
+		};
+		proc.once("close", finish);
+		const forceKillTimer = setTimeout(() => {
+			forceKillWaitTimer = setTimeout(finish, NGROK_FORCE_KILL_WAIT_MS);
+			if (!isClosed()) proc.kill("SIGKILL");
+		}, NGROK_STOP_GRACE_MS);
+		proc.kill("SIGTERM");
+		if (isClosed()) finish();
+	});
+}
 function listenForChildStreamErrors(proc, onError) {
 	proc.stdout.on("error", (error) => onError("stdout", error));
 	proc.stderr.on("error", (error) => onError("stderr", error));
@@ -2194,23 +2131,25 @@ async function startNgrokTunnel(config) {
 			"pipe",
 			"pipe"
 		] });
-		let resolved = false;
-		let closed = false;
+		let startupSettled = false;
+		let childClosed = false;
 		let publicUrl = null;
 		let outputBuffer = "";
 		let stderrTail = "";
 		const timeout = setTimeout(() => {
-			if (!resolved) {
-				resolved = true;
-				proc.kill("SIGTERM");
-				reject(/* @__PURE__ */ new Error("ngrok startup timed out (30s)"));
+			if (!startupSettled) {
+				startupSettled = true;
+				terminateNgrokProcess(proc, () => childClosed).then(() => {
+					reject(/* @__PURE__ */ new Error("ngrok startup timed out (30s)"));
+				});
 			}
 		}, 3e4);
+		timeout.unref();
 		const rejectIfPending = (message, kill = false) => {
-			if (!resolved) {
-				resolved = true;
+			if (!startupSettled) {
+				startupSettled = true;
 				clearTimeout(timeout);
-				if (kill && !closed) proc.kill("SIGKILL");
+				if (kill && !childClosed) proc.kill("SIGKILL");
 				reject(new Error(message));
 			}
 		};
@@ -2219,8 +2158,8 @@ async function startNgrokTunnel(config) {
 				const log = JSON.parse(line);
 				if (log.msg === "started tunnel" && log.url) publicUrl = log.url;
 				if (log.addr && log.url && !publicUrl) publicUrl = log.url;
-				if (publicUrl && !resolved) {
-					resolved = true;
+				if (publicUrl && !startupSettled) {
+					startupSettled = true;
 					clearTimeout(timeout);
 					const fullUrl = publicUrl + config.path;
 					console.log(`[voice-call] ngrok tunnel active: ${fullUrl}`);
@@ -2228,38 +2167,22 @@ async function startNgrokTunnel(config) {
 						publicUrl: fullUrl,
 						provider: "ngrok",
 						stop: async () => {
-							if (closed) return;
-							await new Promise((res) => {
-								let finished = false;
-								const finish = () => {
-									if (finished) return;
-									finished = true;
-									clearTimeout(fallback);
-									proc.off("close", finish);
-									res();
-								};
-								if (closed) {
-									res();
-									return;
-								}
-								proc.once("close", finish);
-								const fallback = setTimeout(finish, 2e3);
-								proc.kill("SIGTERM");
-								if (closed) finish();
-							});
+							await terminateNgrokProcess(proc, () => childClosed);
 						}
 					});
 				}
 			} catch {}
 		};
-		proc.stdout.on("data", (data) => {
-			const lines = (outputBuffer + data.toString()).split("\n");
+		proc.stdout.setEncoding("utf8");
+		proc.stderr.setEncoding("utf8");
+		proc.stdout.on("data", (chunk) => {
+			const lines = (outputBuffer + chunk).split("\n");
 			outputBuffer = lines.pop() || "";
 			if (outputBuffer.length > NGROK_LOG_BUFFER_MAX_CHARS) outputBuffer = sliceUtf16Safe(outputBuffer, -16384);
 			for (const line of lines) if (line.trim()) processLine(line);
 		});
-		proc.stderr.on("data", (data) => {
-			const combined = stderrTail + data.toString();
+		proc.stderr.on("data", (chunk) => {
+			const combined = stderrTail + chunk;
 			if (combined.includes(NGROK_ERROR_MARKER)) rejectIfPending(`ngrok error: ${formatBoundedChildOutput(appendBoundedChildOutput(emptyBoundedChildOutput(), combined))}`, true);
 			stderrTail = sliceUtf16Safe(combined, -8);
 		});
@@ -2270,9 +2193,9 @@ async function startNgrokTunnel(config) {
 			rejectIfPending(`Failed to start ngrok: ${err.message}`);
 		});
 		proc.on("close", (code) => {
-			closed = true;
-			if (!resolved) {
-				resolved = true;
+			childClosed = true;
+			if (!startupSettled) {
+				startupSettled = true;
 				clearTimeout(timeout);
 				reject(/* @__PURE__ */ new Error(`ngrok exited unexpectedly with code ${code}`));
 			}
@@ -2446,6 +2369,11 @@ function getHeader(headers, name) {
 	return value;
 }
 //#endregion
+//#region extensions/voice-call/src/media-base64.ts
+function canonicalizeVoiceCallMediaBase64(payloadBase64) {
+	return canonicalizeBase64(payloadBase64.replaceAll("-", "+").replaceAll("_", "/"));
+}
+//#endregion
 //#region extensions/voice-call/src/media-stream.ts
 const DEFAULT_PRE_START_TIMEOUT_MS = 5e3;
 const DEFAULT_MAX_PENDING_CONNECTIONS = 32;
@@ -2560,7 +2488,9 @@ var MediaStreamHandler = class {
 						break;
 					case "media":
 						if (session && message.media?.payload) {
-							const audioBuffer = Buffer.from(message.media.payload, "base64");
+							const canonicalPayload = canonicalizeVoiceCallMediaBase64(message.media.payload);
+							if (!canonicalPayload) break;
+							const audioBuffer = Buffer.from(canonicalPayload, "base64");
 							const turnId = this.ensureActiveTurn(session);
 							this.emitTalkEvent(session, {
 								type: "input.audio.delta",
@@ -3141,7 +3071,7 @@ const WEBHOOK_BODY_TIMEOUT_MS = WEBHOOK_BODY_READ_DEFAULTS.preAuth.timeoutMs;
 const MISSING_REMOTE_ADDRESS_IN_FLIGHT_KEY = "__voice_call_no_remote__";
 const STREAM_DISCONNECT_HANGUP_GRACE_MS = 2e3;
 const loadRealtimeTranscriptionRuntime = createLazyRuntimeModule(() => import("./realtime-transcription.runtime-CbJAs5t_.js"));
-const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-Cdj8EuLg.js"));
+const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-z6M9229t.js"));
 function appendRecentTalkEventMetadata(call, event) {
 	const metadata = call.metadata ?? {};
 	const recent = Array.isArray(metadata.recentTalkEvents) ? metadata.recentTalkEvents.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)) : [];
@@ -3816,12 +3746,12 @@ const REALTIME_VOICE_CONSULT_SYSTEM_PROMPT = [
 	"Do not print secret values or dump environment variables; only check whether required configuration is present.",
 	"Be accurate, brief, and speakable."
 ].join(" ");
-const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-DMbLYwj4.js"));
-const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-BTKKlkLT.js"));
-const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-ByAIoPFp.js"));
+const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-BG56lL7z.js"));
+const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-B3FQ_P9x.js"));
+const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-B-KvPVji.js"));
 const loadMockProvider = createLazyRuntimeModule(() => import("./mock-YsvBTX-7.js"));
 const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.js"));
-const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-DJk-eYyf.js"));
+const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-hIVPEZxN.js"));
 function resolveVoiceCallConsultSessionKey(call) {
 	return resolveVoiceCallSessionKey({
 		config: call.config,
@@ -3946,7 +3876,8 @@ async function createRealtimeInstructionsResolver(params) {
 		baseInstructions: params.config.realtime.instructions,
 		config: genericConfig,
 		coreConfig: params.coreConfig,
-		agentRuntime: params.agentRuntime
+		agentRuntime: params.agentRuntime,
+		agentId: params.config.agentId
 	});
 	const entries = await Promise.all(listRealtimeAgentIds(params.config, params.coreConfig).map(async (agentId) => {
 		return [agentId, await buildRealtimeVoiceInstructions({
@@ -3956,7 +3887,8 @@ async function createRealtimeInstructionsResolver(params) {
 				agentId
 			},
 			coreConfig: params.coreConfig,
-			agentRuntime: params.agentRuntime
+			agentRuntime: params.agentRuntime,
+			agentId
 		})];
 	}));
 	const instructionsByAgentId = new Map(entries);
@@ -3974,8 +3906,13 @@ async function createVoiceCallRuntime(params) {
 		error: console.error,
 		debug: console.debug
 	};
-	const config = resolveVoiceCallConfig(rawConfig);
 	const cfg = fullConfig ?? coreConfig;
+	const unresolvedConfig = resolveVoiceCallConfig(rawConfig);
+	const configuredAgentId = unresolvedConfig.agentId ? normalizeAgentId(unresolvedConfig.agentId) : resolveDefaultAgentId(cfg);
+	const config = {
+		...unresolvedConfig,
+		agentId: configuredAgentId
+	};
 	if (!config.enabled) throw new Error("Voice call disabled. Enable the plugin entry in config.");
 	if (config.skipSignatureVerification) log.warn("[voice-call] SECURITY WARNING: skipSignatureVerification=true disables webhook signature verification (development only). Do not use in production.");
 	const validation = validateProviderConfig(config);
@@ -4101,8 +4038,8 @@ async function createVoiceCallRuntime(params) {
 		if (provider.name === "twilio" && config.streaming?.enabled) {
 			const twilioProvider = provider;
 			if (ttsRuntime?.textToSpeechTelephony) try {
-				const ttsProvider = createTelephonyTtsProvider({
-					coreConfig,
+				const ttsProvider = await createTelephonyTtsProvider({
+					coreConfig: cfg,
 					ttsOverride: config.tts,
 					runtime: ttsRuntime,
 					logger: log
@@ -4140,4 +4077,4 @@ async function createVoiceCallRuntime(params) {
 	}
 }
 //#endregion
-export { mapVoiceToPolly as _, normalizeProviderStatus as a, resolveVoiceCallSessionKey as b, cleanupTailscaleExposureRoute as c, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as d, chunkAudio as f, escapeXml as g, resolveUserPath as h, mapProviderStatusToEndReason as i, getTailscaleSelfInfo as l, resolveCallAgentId as m, normalizeProxyIp as n, getHeader as o, resolveVoiceResponseModel as p, isProviderStatusTerminal as r, resolveWebhookExposureStatus as s, createVoiceCallRuntime as t, setupTailscaleExposureRoute as u, VoiceCallConfigSchema as v, validateProviderConfig as x, resolveVoiceCallConfig as y };
+export { validateProviderConfig as S, escapeXml as _, normalizeProviderStatus as a, resolveVoiceCallConfig as b, resolveWebhookExposureStatus as c, setupTailscaleExposureRoute as d, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as f, resolveUserPath as g, resolveCallAgentId as h, mapProviderStatusToEndReason as i, cleanupTailscaleExposureRoute as l, resolveVoiceResponseModel as m, normalizeProxyIp as n, canonicalizeVoiceCallMediaBase64 as o, chunkAudio as p, isProviderStatusTerminal as r, getHeader as s, createVoiceCallRuntime as t, getTailscaleSelfInfo as u, mapVoiceToPolly as v, resolveVoiceCallSessionKey as x, VoiceCallConfigSchema as y };

package/dist/runtime-entry.js

@@ -1,2 +1,2 @@
-import { t as createVoiceCallRuntime } from "./runtime-entry-DSgyqIwE.js";
+import { t as createVoiceCallRuntime } from "./runtime-entry-CQtitvRd.js";
 export { createVoiceCallRuntime };

package/dist/{telnyx-DMbLYwj4.js → telnyx-BG56lL7z.js}

@@ -1,4 +1,4 @@
-import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-BKOgUU1q.js";
+import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-Dxhe25Zi.js";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/telnyx.ts
 function normalizeTelnyxDirection(direction) {

package/dist/{twilio-BTKKlkLT.js → twilio-B3FQ_P9x.js}

@@ -1,9 +1,10 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
 import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-4fkgz3UG.js";
-import { _ as mapVoiceToPolly, a as normalizeProviderStatus, f as chunkAudio, g as escapeXml, i as mapProviderStatusToEndReason, o as getHeader, r as isProviderStatusTerminal } from "./runtime-entry-DSgyqIwE.js";
-import { c as verifyTwilioWebhook, i as readProviderJsonResponseText, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-BKOgUU1q.js";
+import { _ as escapeXml, a as normalizeProviderStatus, i as mapProviderStatusToEndReason, p as chunkAudio, r as isProviderStatusTerminal, s as getHeader, v as mapVoiceToPolly } from "./runtime-entry-CQtitvRd.js";
+import { c as verifyTwilioWebhook, i as readProviderJsonResponseText, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-Dxhe25Zi.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -628,9 +629,12 @@ var TwilioProvider = class TwilioProvider {
 				chunkAttempts += 1;
 				if (sendAudioChunk(chunk).sent) chunkDelivered += 1;
 				const waitMs = nextChunkDueAt - Date.now();
-				if (waitMs > 0) await new Promise((resolve) => {
-					setTimeout(resolve, Math.ceil(waitMs));
-				});
+				if (waitMs > 0) try {
+					await sleepWithAbort(Math.ceil(waitMs), signal);
+				} catch (error) {
+					if (!signal.aborted) throw error;
+					break;
+				}
 				nextChunkDueAt += CHUNK_DELAY_MS;
 				if (signal.aborted) break;
 			}

package/node_modules/typebox/build/compile/validator.d.mts

@@ -1,14 +1,11 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type StaticDecode, type StaticEncode, type TProperties, type TSchema } from '../type/index.mjs';
-import { BuildResult, EvaluateResult } from '../schema/index.mjs';
 export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> {
     private readonly hasCodec;
     private readonly buildResult;
     private readonly evaluateResult;
-    /** Constructs a Validator with the given Context and Type. */
+    /** Constructs a Validator. */
     constructor(context: Context, type: Type);
-    /** Constructs a Validator with the given arguments. */
-    constructor(hasCodec: boolean, buildResult: BuildResult, evaluateResult: EvaluateResult);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
     /** Returns the Context for this validator. */

package/node_modules/typebox/build/guard/guard.d.mts

@@ -61,5 +61,5 @@ export declare function Keys(value: Record<PropertyKey, unknown>): string[];
 export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
 /** Returns the property values for the given object via `Object.values()` */
 export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
-/** Tests values for deep equality */
+/** Returns true if left and right values are structurally equal */
 export declare function IsDeepEqual(left: unknown, right: unknown): boolean;

package/node_modules/typebox/build/guard/guard.mjs

@@ -1,3 +1,4 @@
+// deno-fmt-ignore-file
 import * as String from './string.mjs';
 // --------------------------------------------------------------------------
 // Guards
@@ -203,7 +204,9 @@ function DeepEqualArray(left, right) {
     return IsArray(right) && IsEqual(left.length, right.length) &&
         left.every((_, index) => IsDeepEqual(left[index], right[index]));
 }
-/** Tests values for deep equality */
+/** Returns true if left and right values are structurally equal */
 export function IsDeepEqual(left, right) {
-    return (IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right));
+    return (IsArray(left) ? DeepEqualArray(left, right) :
+        IsObject(left) ? DeepEqualObject(left, right) :
+            IsEqual(left, right));
 }

package/node_modules/typebox/build/guard/string.mjs

@@ -5,6 +5,18 @@ function IsBetween(value, min, max) {
     return value >= min && value <= max;
 }
 // --------------------------------------------------------------------------
+// IsZeroWidthJoiner
+// --------------------------------------------------------------------------
+function IsZeroWidthJoiner(value) {
+    return (value === 0x200D);
+}
+// --------------------------------------------------------------------------
+// IsHighSurrogate
+// --------------------------------------------------------------------------
+function IsHighSurrogate(value) {
+    return IsBetween(value, 0xD800, 0xDBFF);
+}
+// --------------------------------------------------------------------------
 // IsRegionalIndicator
 // --------------------------------------------------------------------------
 function IsRegionalIndicator(value) {
@@ -72,10 +84,10 @@ function NextGraphemeClusterIndex(value, clusterStart) {
 // IsGraphemeCodePoint
 // --------------------------------------------------------------------------
 function IsGraphemeCodePoint(value) {
-    return (IsBetween(value, 0xD800, 0xDBFF) || // High surrogate
-        IsBetween(value, 0x0300, 0x036F) || // Combining diacritical marks
-        (value === 0x200D) // Zero-width joiner
-    );
+    return (IsHighSurrogate(value) ||
+        IsCombiningMark(value) ||
+        IsVariationSelector(value) ||
+        IsZeroWidthJoiner(value));
 }
 // --------------------------------------------------------------------------
 // GraphemeCount

package/node_modules/typebox/build/schema/engine/_functions.mjs

@@ -1,47 +1,66 @@
 // deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
 import { Hashing } from '../../system/hashing/index.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema } from './schema.mjs';
-const functions = new Map();
+const index = [0];
+const names = new Map;
+const funcs = new Map();
+// ------------------------------------------------------------------
+// CreateName
+// ------------------------------------------------------------------
+function NextName() {
+    return Hashing.Hash(index[0]++);
+}
+function CreateName(schema, href) {
+    if (!names.has(schema))
+        names.set(schema, new Map());
+    const hrefs = names.get(schema);
+    if (hrefs.has(href))
+        return hrefs.get(href);
+    const name = NextName();
+    hrefs.set(href, name);
+    return name;
+}
 // ------------------------------------------------------------------
 // CreateCallExpression
 // ------------------------------------------------------------------
-function CreateCallExpression(context, _schema, hash, value) {
+function CreateCallExpression(context, _schema, name, value) {
     return context.UseUnevaluated()
-        ? E.Call(`check_${hash}`, ['context', value])
-        : E.Call(`check_${hash}`, [value]);
+        ? E.Call(`check_${name}`, ['context', value])
+        : E.Call(`check_${name}`, [value]);
 }
 // ------------------------------------------------------------------
 // CreateFunctionExpression
 // ------------------------------------------------------------------
-function CreateFunctionExpression(stack, context, schema, hash) {
+function CreateFunctionExpression(stack, context, schema, name) {
     const expression = BuildSchema(stack, context, schema, 'value');
     return context.UseUnevaluated()
-        ? E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['context', 'value'], expression))
-        : E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['value'], expression));
+        ? E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['context', 'value'], expression))
+        : E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['value'], expression));
 }
 // ------------------------------------------------------------------
 // ResetFunctions
 // ------------------------------------------------------------------
 export function ResetFunctions() {
-    functions.clear();
+    index[0] = 0;
+    names.clear();
+    funcs.clear();
 }
 // ------------------------------------------------------------------
 // GetFunctions
 // ------------------------------------------------------------------
 export function GetFunctions() {
-    return [...functions.values()];
+    return [...funcs.values()];
 }
 // ------------------------------------------------------------------
 // CreateFunction
 // ------------------------------------------------------------------
 export function CreateFunction(stack, context, schema, value) {
-    const hash = Schema.IsSchemaObject(schema) ? Hashing.Hash({ __baseURL: stack.BaseURL().href, ...schema }) : Hashing.Hash(schema);
-    const call = CreateCallExpression(context, schema, hash, value);
-    if (functions.has(hash))
+    const name = CreateName(schema, stack.BaseURL().href);
+    const call = CreateCallExpression(context, schema, name, value);
+    if (funcs.has(name))
         return call;
-    functions.set(hash, '');
-    functions.set(hash, CreateFunctionExpression(stack, context, schema, hash));
+    funcs.set(name, '');
+    funcs.set(name, CreateFunctionExpression(stack, context, schema, name));
     return call;
 }

package/node_modules/typebox/build/type/action/readonly_object.d.mts

@@ -9,3 +9,8 @@ export declare function ReadonlyObjectDeferred<Type extends TSchema>(type: Type,
 export type TReadonlyObject<Type extends TSchema> = (TReadonlyObjectAction<Type>);
 /** This type is an alias for TypeScript's `Readonly<T>` utility type. It will make all properties of a TObject readonly or marks an TArray or TTuple as immutable `readonly T[]`. */
 export declare function ReadonlyObject<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReadonlyObject<Type>;
+/**
+ * This type has been renamed to ReadonlyObject.
+ * @deprecated
+*/
+export declare const ReadonlyType: typeof ReadonlyObject;

package/node_modules/typebox/build/type/action/readonly_object.mjs

@@ -9,3 +9,11 @@ export function ReadonlyObjectDeferred(type, options = {}) {
 export function ReadonlyObject(type, options = {}) {
     return ReadonlyObjectAction(type, options);
 }
+// ------------------------------------------------------------------
+// Alias
+// ------------------------------------------------------------------
+/**
+ * This type has been renamed to ReadonlyObject.
+ * @deprecated
+*/
+export const ReadonlyType = ReadonlyObject;

package/node_modules/typebox/build/typebox.d.mts

@@ -19,7 +19,7 @@ export { Omit, type TOmit, type TOmitDeferred } from './type/action/omit.mjs';
 export { Parameters, type TParameters, type TParametersDeferred } from './type/action/parameters.mjs';
 export { Partial, type TPartial, type TPartialDeferred } from './type/action/partial.mjs';
 export { Pick, type TPick, type TPickDeferred } from './type/action/pick.mjs';
-export { ReadonlyObject, type TReadonlyObject, type TReadonlyObjectDeferred } from './type/action/readonly_object.mjs';
+export { ReadonlyObject, ReadonlyType, type TReadonlyObject, type TReadonlyObjectDeferred } from './type/action/readonly_object.mjs';
 export { Required, type TRequired, type TRequiredDeferred } from './type/action/required.mjs';
 export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return_type.mjs';
 export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize.mjs';