@openclaw/voice-call 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{runtime-entry-Cwb6vEQf.js → runtime-entry-kCq5Xjph.js}

@@ -1,24 +1,27 @@
 import { isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "./runtime-api.js";
 import "./api.js";
-import { a as resolveVoiceCallEffectiveConfig, c as validateProviderConfig, i as resolveVoiceCallConfig, n as normalizeVoiceCallConfig, o as resolveVoiceCallNumberRouteKeyForCall, r as resolveTwilioAuthToken, s as resolveVoiceCallSessionKey, u as deepMergeDefined } from "./config-DNtTB7Iw.js";
-import { c as getCallHistoryFromStore, d as persistCallRecord, h as TerminalStates, l as loadActiveCallsFromStore, m as setVoiceCallStateRuntime } from "./store-8M2m4Isq.js";
+import { a as resolveVoiceCallEffectiveConfig, c as validateProviderConfig, d as deepMergeDefined, i as resolveVoiceCallConfig, n as normalizeVoiceCallConfig, o as resolveVoiceCallNumberRouteKeyForCall, r as resolveTwilioAuthToken, s as resolveVoiceCallSessionKey } from "./config-CgigQDrF.js";
+import { c as findCallMatchesInStore, f as persistCallRecord, g as TerminalStates, h as setVoiceCallStateRuntime, l as getCallHistoryFromStore, u as loadActiveCallsFromStore } from "./store-DtewuuOb.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, buildRealtimeVoiceAgentConsultPolicyInstructions, consultRealtimeVoiceAgent, convertPcmToMulaw8k, createTalkSessionController, recordTalkObservabilityEvent, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow, resolveRealtimeVoiceFastContextConsult } from "openclaw/plugin-sdk/realtime-voice";
+import { WEBHOOK_BODY_READ_DEFAULTS, createWebhookInFlightLimiter, normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
 import { root } from "openclaw/plugin-sdk/security-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
 import { spawn } from "node:child_process";
 import http from "node:http";
 import { URL as URL$1 } from "node:url";
 import { resolveConfiguredCapabilityProvider } from "openclaw/plugin-sdk/provider-selection-runtime";
-import { WEBHOOK_BODY_READ_DEFAULTS, createWebhookInFlightLimiter } from "openclaw/plugin-sdk/webhook-ingress";
-import { WebSocket as WebSocket$1, WebSocketServer } from "ws";
+import { WebSocket, WebSocketServer } from "ws";
 //#region extensions/voice-call/src/allowlist.ts
 /** Normalize a phone number to digits only. */
 function normalizePhoneNumber(input) {
@@ -35,7 +38,7 @@ function isAllowlistedCaller(normalizedFrom, allowFrom) {
 }
 //#endregion
 //#region extensions/voice-call/src/manager/state.ts
-const ConversationStates = new Set(["speaking", "listening"]);
+const ConversationStates = /* @__PURE__ */ new Set(["speaking", "listening"]);
 const StateOrder = [
 	"initiated",
 	"ringing",
@@ -310,6 +313,7 @@ async function initiateCall(ctx, to, sessionKey, options) {
 	const mode = opts.mode ?? ctx.config.outbound.defaultMode;
 	const dtmfSequence = opts.dtmfSequence;
 	const requesterSessionKey = opts.requesterSessionKey?.trim();
+	const agentId = normalizeAgentId(opts.agentId ?? ctx.config.agentId);
 	if (dtmfSequence) {
 		const validationError = validateDtmfDigits(dtmfSequence);
 		if (validationError) return {
@@ -353,12 +357,16 @@ async function initiateCall(ctx, to, sessionKey, options) {
 		from,
 		to,
 		sessionKey: resolveVoiceCallSessionKey({
-			config: ctx.config,
+			config: {
+				...ctx.config,
+				agentId
+			},
 			callId,
 			phone: to,
 			explicitSessionKey: sessionKey,
 			coreSession: ctx.coreSession
 		}),
+		agentId,
 		startedAt: Date.now(),
 		transcript: [],
 		processedEventIds: [],
@@ -421,7 +429,7 @@ async function initiateCall(ctx, to, sessionKey, options) {
 		};
 	}
 }
-async function speak(ctx, callId, text) {
+async function speak(ctx, callId, text, options) {
 	const connected = requireConnectedCall(ctx, callId);
 	if (!connected.ok) return {
 		success: false,
@@ -441,11 +449,13 @@ async function speak(ctx, callId, text) {
 		persistCallRecord(ctx.storePath, call);
 		const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
 		const voice = resolvePreferredTtsVoice(resolveVoiceCallEffectiveConfig(ctx.config, numberRouteKey).config);
+		const playbackOptions = options?.listenAfterPlayback ? { listenAfterPlayback: true } : {};
 		await provider.playTts({
 			callId,
 			providerCallId,
 			text,
-			voice
+			voice,
+			...playbackOptions
 		});
 		addTranscriptEntry(call, "bot", text);
 		persistCallRecord(ctx.storePath, call);
@@ -676,6 +686,7 @@ function createWebhookCall(params) {
 			callId,
 			phone: params.direction === "outbound" ? params.to : params.from
 		}),
+		agentId: normalizeAgentId(effectiveConfig.agentId),
 		startedAt: Date.now(),
 		transcript: [],
 		processedEventIds: [],
@@ -712,7 +723,7 @@ function persistRejectedInboundCall(params) {
 }
 function processEvent(ctx, event) {
 	const dedupeKey = event.dedupeKey || event.id;
-	if (ctx.processedEventIds.has(dedupeKey)) return;
+	if (ctx.processedEventIds.has(dedupeKey)) return { kind: "ignored" };
 	let call = findCall({
 		activeCalls: ctx.activeCalls,
 		providerCallIdMap: ctx.providerCallIdMap,
@@ -725,10 +736,10 @@ function processEvent(ctx, event) {
 			const pid = providerCallId;
 			if (!ctx.provider) {
 				console.warn(`[voice-call] Inbound call rejected by policy but no provider to hang up (providerCallId: ${pid}, from: ${event.from}); call will time out on provider side.`);
-				return;
+				return { kind: "ignored" };
 			}
 			ctx.processedEventIds.add(dedupeKey);
-			if (ctx.rejectedProviderCallIds.has(pid)) return;
+			if (ctx.rejectedProviderCallIds.has(pid)) return { kind: "ignored" };
 			ctx.rejectedProviderCallIds.add(pid);
 			const callId = event.callId ?? pid;
 			persistRejectedInboundCall({
@@ -747,7 +758,7 @@ function processEvent(ctx, event) {
 				const message = formatErrorMessage(err);
 				console.warn(`[voice-call] Failed to reject inbound call ${pid}:`, message);
 			});
-			return;
+			return { kind: "processed" };
 		}
 		call = createWebhookCall({
 			ctx,
@@ -758,7 +769,7 @@ function processEvent(ctx, event) {
 		});
 		event.callId = call.callId;
 	}
-	if (!call) return;
+	if (!call) return { kind: "ignored" };
 	if (event.providerCallId && event.providerCallId !== call.providerCallId) {
 		const previousProviderCallId = call.providerCallId;
 		call.providerCallId = event.providerCallId;
@@ -771,6 +782,7 @@ function processEvent(ctx, event) {
 		ctx.processedEventIds.add(dedupeKey);
 		call.processedEventIds.push(dedupeKey);
 	}
+	let result = { kind: "processed" };
 	switch (event.type) {
 		case "call.initiated":
 			transitionState(call, "initiated");
@@ -814,6 +826,7 @@ function processEvent(ctx, event) {
 			transitionState(call, "active");
 			break;
 		case "call.speaking":
+		case "call.assistant-speech":
 			ensureMaxDurationTimerForLiveCall({
 				ctx,
 				call,
@@ -823,6 +836,7 @@ function processEvent(ctx, event) {
 				}
 			});
 			transitionState(call, "speaking");
+			if (event.type === "call.assistant-speech" && event.transcript.trim()) addTranscriptEntry(call, "bot", event.transcript);
 			break;
 		case "call.speech":
 			if (event.isFinal) {
@@ -830,9 +844,16 @@ function processEvent(ctx, event) {
 				const resolved = resolveTranscriptWaiter(ctx, call.callId, event.transcript, event.turnToken);
 				if (hadWaiter && !resolved) {
 					console.warn(`[voice-call] Ignoring speech event with mismatched turn token for ${call.callId}`);
+					result = { kind: "ignored" };
 					break;
 				}
 				addTranscriptEntry(call, "user", event.transcript);
+				result = {
+					kind: "final-speech",
+					call,
+					transcript: event.transcript,
+					waiterResolved: resolved
+				};
 			}
 			ensureMaxDurationTimerForLiveCall({
 				ctx,
@@ -853,7 +874,7 @@ function processEvent(ctx, event) {
 				endReason: event.reason,
 				endedAt: event.timestamp
 			});
-			return;
+			return { kind: "processed" };
 		case "call.error":
 			if (!event.retryable) {
 				finalizeCall({
@@ -863,11 +884,12 @@ function processEvent(ctx, event) {
 					endedAt: event.timestamp,
 					transcriptRejectReason: `Call error: ${event.error}`
 				});
-				return;
+				return { kind: "processed" };
 			}
 			break;
 	}
 	persistCallRecord(ctx.storePath, call);
+	return result;
 }
 //#endregion
 //#region extensions/voice-call/src/utils.ts
@@ -1052,8 +1074,8 @@ var CallManager = class {
 	/**
 	* Speak to user in an active call.
 	*/
-	async speak(callId, text) {
-		return speak(this.getContext(), callId, text);
+	async speak(callId, text, options) {
+		return speak(this.getContext(), callId, text, options);
 	}
 	/**
 	* Send DTMF digits to an active call.
@@ -1104,7 +1126,7 @@ var CallManager = class {
 	* Process a webhook event.
 	*/
 	processEvent(event) {
-		processEvent(this.getContext(), event);
+		return processEvent(this.getContext(), event);
 	}
 	shouldDeferConversationInitialMessageUntilStreamConnect() {
 		if (!this.provider || this.provider.name !== "twilio" || !this.config.streaming.enabled) return false;
@@ -1146,6 +1168,13 @@ var CallManager = class {
 	getActiveCalls() {
 		return Array.from(this.activeCalls.values());
 	}
+	/** Resolve a status record from active state or the retained event store. */
+	async getCallFromMemoryOrStore(callId) {
+		const active = this.getCall(callId) ?? this.getCallByProviderCallId(callId);
+		if (active) return active;
+		const persisted = await findCallMatchesInStore(this.storePath, callId);
+		return persisted.byCallId ?? persisted.byProviderCallId;
+	}
 	/**
 	* Get call history (from persisted logs).
 	*/
@@ -1158,7 +1187,7 @@ var CallManager = class {
 /** Limit injected context while preserving an explicit truncation marker. */
 function limitText(text, maxChars) {
 	if (text.length <= maxChars) return text;
-	return `${text.slice(0, Math.max(0, maxChars - 32)).trimEnd()}\n[truncated]`;
+	return `${truncateUtf16Safe(text, Math.max(0, maxChars - 32)).trimEnd()}\n[truncated]`;
 }
 /** Read configured workspace context files through the safe workspace root. */
 async function readWorkspaceVoiceContextFiles(params) {
@@ -1226,6 +1255,12 @@ async function resolveRealtimeFastContextConsult(params) {
 	});
 }
 //#endregion
+//#region extensions/voice-call/src/resolve-call-agent-id.ts
+/** Keep one agent owner for the full call, including legacy stored records. */
+function resolveCallAgentId(call, config) {
+	return normalizeAgentId(call.agentId ?? config.agentId);
+}
+//#endregion
 //#region extensions/voice-call/src/response-model.ts
 /** Resolve provider/model fields from explicit voice config or agent defaults. */
 function resolveVoiceResponseModel(params) {
@@ -1350,7 +1385,7 @@ function collectTelephonyProviderConfigs(ttsConfig) {
 		const normalized = normalizeProviderId(providerId) ?? providerId;
 		entries[normalized] = asProviderConfig(value);
 	}
-	const reservedKeys = new Set([
+	const reservedKeys = /* @__PURE__ */ new Set([
 		"auto",
 		"enabled",
 		"maxTextLength",
@@ -1434,6 +1469,13 @@ function runTailscaleCommand(args, timeoutMs = 2500) {
 			clearTimeout(timer);
 			resolve(result);
 		};
+		const timer = setTimeout(() => {
+			proc.kill("SIGKILL");
+			finish({
+				code: -1,
+				stdout: ""
+			});
+		}, timeoutMs);
 		proc.stdout.on("data", (data) => {
 			stdout = appendTailscaleCommandStdout(stdout, data);
 			if (stdout.exceeded) {
@@ -1444,13 +1486,13 @@ function runTailscaleCommand(args, timeoutMs = 2500) {
 				});
 			}
 		});
-		const timer = setTimeout(() => {
+		proc.stdout.on("error", () => {
 			proc.kill("SIGKILL");
 			finish({
 				code: -1,
 				stdout: ""
 			});
-		}, timeoutMs);
+		});
 		proc.on("error", () => {
 			finish({
 				code: -1,
@@ -1534,6 +1576,10 @@ async function cleanupTailscaleExposure(config) {
 //#endregion
 //#region extensions/voice-call/src/tunnel.ts
 const NGROK_LOG_BUFFER_MAX_CHARS = 16384;
+function listenForChildStreamErrors(proc, onError) {
+	proc.stdout.on("error", (error) => onError("stdout", error));
+	proc.stderr.on("error", (error) => onError("stderr", error));
+}
 /**
 * Start an ngrok tunnel to expose the local webhook server.
 *
@@ -1566,6 +1612,7 @@ async function startNgrokTunnel(config) {
 			"pipe"
 		] });
 		let resolved = false;
+		let closed = false;
 		let publicUrl = null;
 		let outputBuffer = "";
 		const timeout = setTimeout(() => {
@@ -1575,6 +1622,14 @@ async function startNgrokTunnel(config) {
 				reject(/* @__PURE__ */ new Error("ngrok startup timed out (30s)"));
 			}
 		}, 3e4);
+		const rejectIfPending = (message, kill = false) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timeout);
+				if (kill && !closed) proc.kill("SIGKILL");
+				reject(new Error(message));
+			}
+		};
 		const processLine = (line) => {
 			try {
 				const log = JSON.parse(line);
@@ -1589,10 +1644,24 @@ async function startNgrokTunnel(config) {
 						publicUrl: fullUrl,
 						provider: "ngrok",
 						stop: async () => {
-							proc.kill("SIGTERM");
+							if (closed) return;
 							await new Promise((res) => {
-								proc.on("close", () => res());
-								setTimeout(res, 2e3);
+								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();
 							});
 						}
 					});
@@ -1607,23 +1676,16 @@ async function startNgrokTunnel(config) {
 		});
 		proc.stderr.on("data", (data) => {
 			const msg = data.toString();
-			if (msg.includes("ERR_NGROK")) {
-				if (!resolved) {
-					resolved = true;
-					clearTimeout(timeout);
-					const output = appendBoundedChildOutput(emptyBoundedChildOutput(), msg);
-					reject(/* @__PURE__ */ new Error(`ngrok error: ${formatBoundedChildOutput(output)}`));
-				}
-			}
+			if (msg.includes("ERR_NGROK")) rejectIfPending(`ngrok error: ${formatBoundedChildOutput(appendBoundedChildOutput(emptyBoundedChildOutput(), msg))}`, true);
+		});
+		listenForChildStreamErrors(proc, (stream, error) => {
+			rejectIfPending(`ngrok ${stream} error: ${error.message}`, true);
 		});
 		proc.on("error", (err) => {
-			if (!resolved) {
-				resolved = true;
-				clearTimeout(timeout);
-				reject(/* @__PURE__ */ new Error(`Failed to start ngrok: ${err.message}`));
-			}
+			rejectIfPending(`Failed to start ngrok: ${err.message}`);
 		});
 		proc.on("close", (code) => {
+			closed = true;
 			if (!resolved) {
 				resolved = true;
 				clearTimeout(timeout);
@@ -1644,20 +1706,32 @@ async function runNgrokCommand(args) {
 		] });
 		let stdout = emptyBoundedChildOutput();
 		let stderr = emptyBoundedChildOutput();
+		let settled = false;
+		const rejectIfPending = (error, kill = false) => {
+			if (settled) return;
+			settled = true;
+			if (kill) proc.kill("SIGKILL");
+			reject(error);
+		};
 		proc.stdout.on("data", (data) => {
 			stdout = appendBoundedChildOutput(stdout, data.toString());
 		});
 		proc.stderr.on("data", (data) => {
 			stderr = appendBoundedChildOutput(stderr, data.toString());
 		});
+		listenForChildStreamErrors(proc, (stream, error) => {
+			rejectIfPending(/* @__PURE__ */ new Error(`ngrok command ${stream} error: ${error.message}`), true);
+		});
 		proc.on("close", (code) => {
+			if (settled) return;
+			settled = true;
 			if (code === 0) resolve(stdout.text);
 			else {
 				const output = stderr.text ? stderr : stdout;
 				reject(/* @__PURE__ */ new Error(`ngrok command failed: ${formatBoundedChildOutput(output)}`));
 			}
 		});
-		proc.on("error", reject);
+		proc.on("error", (error) => rejectIfPending(error));
 	});
 }
 /**
@@ -1681,11 +1755,18 @@ async function startTailscaleTunnel(config) {
 			"pipe",
 			"pipe"
 		] });
+		let resolved = false;
 		let stdout = emptyBoundedChildOutput();
 		let stderr = emptyBoundedChildOutput();
+		const rejectIfPending = (error, kill = false) => {
+			if (resolved) return;
+			resolved = true;
+			clearTimeout(timeout);
+			if (kill) proc.kill("SIGKILL");
+			reject(error);
+		};
 		const timeout = setTimeout(() => {
-			proc.kill("SIGKILL");
-			reject(/* @__PURE__ */ new Error(`Tailscale ${config.mode} timed out`));
+			rejectIfPending(/* @__PURE__ */ new Error(`Tailscale ${config.mode} timed out`), true);
 		}, 1e4);
 		proc.stdout.on("data", (data) => {
 			stdout = appendBoundedChildOutput(stdout, data.toString());
@@ -1693,8 +1774,13 @@ async function startTailscaleTunnel(config) {
 		proc.stderr.on("data", (data) => {
 			stderr = appendBoundedChildOutput(stderr, data.toString());
 		});
+		listenForChildStreamErrors(proc, (stream, error) => {
+			rejectIfPending(/* @__PURE__ */ new Error(`Tailscale ${config.mode} ${stream} error: ${error.message}`), true);
+		});
 		proc.on("close", (code) => {
 			clearTimeout(timeout);
+			if (resolved) return;
+			resolved = true;
 			if (code === 0) {
 				const publicUrl = `https://${dnsName}${path}`;
 				console.log(`[voice-call] Tailscale ${config.mode} active: ${publicUrl}`);
@@ -1712,8 +1798,7 @@ async function startTailscaleTunnel(config) {
 			}
 		});
 		proc.on("error", (err) => {
-			clearTimeout(timeout);
-			reject(err);
+			rejectIfPending(err);
 		});
 	});
 }
@@ -1735,6 +1820,10 @@ async function stopTailscaleTunnel(mode, path) {
 			clearTimeout(timeout);
 			resolve();
 		});
+		proc.on("error", () => {
+			clearTimeout(timeout);
+			resolve();
+		});
 	});
 }
 /**
@@ -1835,7 +1924,7 @@ const CLOSE_REASON_LOG_MAX_CHARS = 120;
 function sanitizeLogText(value, maxChars) {
 	const sanitized = value.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim();
 	if (sanitized.length <= maxChars) return sanitized;
-	return `${sanitized.slice(0, maxChars)}...`;
+	return `${truncateUtf16Safe(sanitized, maxChars)}...`;
 }
 function normalizeWsMessageData(data) {
 	if (Buffer.isBuffer(data)) return data;
@@ -2098,11 +2187,11 @@ var MediaStreamHandler = class {
 					error: error instanceof Error ? error.message : String(error)
 				}
 			});
-			if (this.sessions.get(session.streamSid) === session && session.ws.readyState === WebSocket$1.OPEN) session.ws.close(1011, "STT connection failed");
+			if (this.sessions.get(session.streamSid) === session && session.ws.readyState === WebSocket.OPEN) session.ws.close(1011, "STT connection failed");
 			else session.sttSession.close();
 			return;
 		}
-		if (this.sessions.get(session.streamSid) !== session || session.ws.readyState !== WebSocket$1.OPEN) {
+		if (this.sessions.get(session.streamSid) !== session || session.ws.readyState !== WebSocket.OPEN) {
 			session.sttSession.close();
 			return;
 		}
@@ -2198,7 +2287,7 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 	*/
 	getOpenSession(streamSid) {
 		const session = this.sessions.get(streamSid);
-		return session?.ws.readyState === WebSocket$1.OPEN ? session : void 0;
+		return session?.ws.readyState === WebSocket.OPEN ? session : void 0;
 	}
 	/**
 	* Send a message to a stream's WebSocket if available.
@@ -2212,7 +2301,7 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 		};
 		const readyState = session.ws.readyState;
 		const bufferedBeforeBytes = session.ws.bufferedAmount;
-		if (readyState !== WebSocket$1.OPEN) return {
+		if (readyState !== WebSocket.OPEN) return {
 			sent: false,
 			readyState,
 			bufferedBeforeBytes,
@@ -2463,20 +2552,33 @@ function normalizeProviderStatus(status) {
 }
 /** Map terminal provider status strings to OpenClaw end reasons. */
 function mapProviderStatusToEndReason(status) {
-	return TERMINAL_PROVIDER_STATUS_TO_END_REASON[normalizeProviderStatus(status)] ?? null;
+	const normalized = normalizeProviderStatus(status);
+	return TERMINAL_PROVIDER_STATUS_TO_END_REASON[normalized] ?? null;
 }
 /** Return true when a provider status is terminal. */
 function isProviderStatusTerminal(status) {
 	return mapProviderStatusToEndReason(status) !== null;
 }
 //#endregion
+//#region extensions/voice-call/src/proxy-ip.ts
+function normalizeProxyIp(value) {
+	const trimmed = value?.trim();
+	if (!trimmed) return;
+	const normalized = (trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed).toLowerCase();
+	if (normalized.startsWith("::ffff:")) {
+		const mappedIpv4 = normalized.slice(7);
+		if (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(mappedIpv4)) return mappedIpv4;
+	}
+	return normalized;
+}
+//#endregion
 //#region extensions/voice-call/src/webhook/stale-call-reaper.ts
 const CHECK_INTERVAL_MS = 3e4;
 /** States that indicate a live conversation with speech/transcription.
 * Inbound Twilio calls may never fire a call.answered event, so answeredAt
 * can be absent even while the call is actively transcribing. These states
 * prove the call is live and should not be reaped. */
-const LiveConversationStates = new Set(["speaking", "listening"]);
+const LiveConversationStates = /* @__PURE__ */ new Set(["speaking", "listening"]);
 /** Start a stale-call reaper and return its cleanup callback. */
 function startStaleCallReaper(params) {
 	const maxAgeSeconds = params.staleCallReaperSeconds;
@@ -2506,20 +2608,12 @@ 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 TRANSCRIPT_LOG_MAX_CHARS = 200;
-let realtimeTranscriptionRuntimePromise;
-let responseGeneratorModulePromise;
-function loadRealtimeTranscriptionRuntime() {
-	realtimeTranscriptionRuntimePromise ??= import("./realtime-transcription.runtime-CbJAs5t_.js");
-	return realtimeTranscriptionRuntimePromise;
-}
-function loadResponseGeneratorModule() {
-	responseGeneratorModulePromise ??= import("./response-generator-DOdrErIH.js");
-	return responseGeneratorModulePromise;
-}
+const loadRealtimeTranscriptionRuntime = createLazyRuntimeModule(() => import("./realtime-transcription.runtime-CbJAs5t_.js"));
+const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-PXuisI3L.js"));
 function sanitizeTranscriptForLog(value) {
 	const sanitized = value.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim();
 	if (sanitized.length <= TRANSCRIPT_LOG_MAX_CHARS) return sanitized;
-	return `${sanitized.slice(0, TRANSCRIPT_LOG_MAX_CHARS)}...`;
+	return `${truncateUtf16Safe(sanitized, TRANSCRIPT_LOG_MAX_CHARS)}...`;
 }
 function appendRecentTalkEventMetadata(call, event) {
 	const metadata = call.metadata ?? {};
@@ -2540,16 +2634,6 @@ function appendRecentTalkEventMetadata(call, event) {
 function buildRequestUrl(requestUrl) {
 	return new URL$1(requestUrl ?? "/", "http://localhost");
 }
-function normalizeProxyIp(value) {
-	const trimmed = value?.trim();
-	if (!trimmed) return;
-	const normalized = (trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed).toLowerCase();
-	if (normalized.startsWith("::ffff:")) {
-		const mappedIpv4 = normalized.slice(7);
-		if (/^\d{1,3}(?:\.\d{1,3}){3}$/.test(mappedIpv4)) return mappedIpv4;
-	}
-	return normalized;
-}
 function resolveForwardedClientIp(request, trustedProxyIPs) {
 	const normalizedTrustedProxyIps = new Set(trustedProxyIPs.map((ip) => normalizeProxyIp(ip)).filter((ip) => Boolean(ip)));
 	const forwardedFor = getHeader(request.headers, "x-forwarded-for");
@@ -2745,11 +2829,7 @@ var VoiceCallWebhookServer = class {
 					transcript,
 					isFinal: true
 				};
-				this.manager.processEvent(event);
-				const callMode = call.metadata?.mode;
-				if (call.direction === "inbound" || callMode === "conversation") this.handleInboundResponse(call.callId, transcript).catch((err) => {
-					console.warn(`[voice-call] Failed to auto-respond:`, err);
-				});
+				this.processEventWithAutoResponse(event);
 			},
 			onSpeechStart: (providerCallId) => {
 				if (this.provider.name !== "twilio") return;
@@ -2888,15 +2968,8 @@ var VoiceCallWebhookServer = class {
 			return null;
 		}
 	}
-	normalizeWebhookPathForMatch(pathname) {
-		const trimmed = pathname.trim();
-		if (!trimmed) return "/";
-		const prefixed = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-		if (prefixed === "/") return prefixed;
-		return prefixed.endsWith("/") ? prefixed.slice(0, -1) : prefixed;
-	}
 	isWebhookPathMatch(requestPath, configuredPath) {
-		return this.normalizeWebhookPathForMatch(requestPath) === this.normalizeWebhookPathForMatch(configuredPath);
+		return normalizeWebhookPath(requestPath) === normalizeWebhookPath(configuredPath);
 	}
 	/**
 	* Handle incoming HTTP request.
@@ -3091,8 +3164,8 @@ var VoiceCallWebhookServer = class {
 			const pathname = buildRequestUrl(req.url).pathname;
 			const pattern = this.realtimeHandler?.getStreamPathPattern();
 			if (!pattern) return false;
-			const normalizedPattern = this.normalizeWebhookPathForMatch(pattern);
-			const normalizedPathname = this.normalizeWebhookPathForMatch(pathname);
+			const normalizedPattern = normalizeWebhookPath(pattern);
+			const normalizedPathname = normalizeWebhookPath(pathname);
 			if (normalizedPattern === "/") return true;
 			return normalizedPathname === normalizedPattern || normalizedPathname.startsWith(`${normalizedPattern}/`);
 		} catch {
@@ -3119,11 +3192,20 @@ var VoiceCallWebhookServer = class {
 	}
 	processParsedEvents(events) {
 		for (const event of events) try {
-			this.manager.processEvent(event);
+			this.processEventWithAutoResponse(event);
 		} catch (err) {
 			console.error(`[voice-call] Error processing event ${event.type}:`, err);
 		}
 	}
+	processEventWithAutoResponse(event) {
+		const result = this.manager.processEvent(event);
+		if (result.kind !== "final-speech" || result.waiterResolved) return;
+		const callMode = result.call.metadata?.mode;
+		if (result.call.direction !== "inbound" && callMode !== "conversation") return;
+		this.handleInboundResponse(result.call.callId, result.transcript).catch((err) => {
+			console.warn(`[voice-call] Failed to auto-respond:`, err);
+		});
+	}
 	writeWebhookResponse(res, payload) {
 		res.statusCode = payload.statusCode;
 		if (payload.headers) for (const [key, value] of Object.entries(payload.headers)) res.setHeader(key, value);
@@ -3168,16 +3250,21 @@ var VoiceCallWebhookServer = class {
 				callId,
 				sessionKey: call.sessionKey,
 				from: call.from,
+				agentId: resolveCallAgentId(call, effectiveConfig),
 				transcript: call.transcript,
-				userMessage
+				userMessage,
+				onEarlyText: async (text) => {
+					console.log(`[voice-call] Early AI response: "${text}"`);
+					return (await this.manager.speak(callId, text, { listenAfterPlayback: true })).success;
+				}
 			});
 			if (result.error) {
 				console.error(`[voice-call] Response generation error: ${result.error}`);
 				return;
 			}
-			if (result.text) {
+			if (result.text && !result.deliveredEarly) {
 				console.log(`[voice-call] AI response: "${result.text}"`);
-				await this.manager.speak(callId, result.text);
+				await this.manager.speak(callId, result.text, { listenAfterPlayback: true });
 			}
 		} catch (err) {
 			console.error(`[voice-call] Auto-response error:`, err);
@@ -3194,36 +3281,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(" ");
-let telnyxProviderPromise;
-let twilioProviderPromise;
-let plivoProviderPromise;
-let mockProviderPromise;
-let realtimeVoiceRuntimePromise;
-let realtimeHandlerPromise;
-function loadTelnyxProvider() {
-	telnyxProviderPromise ??= import("./telnyx-LSKUJimK.js");
-	return telnyxProviderPromise;
-}
-function loadTwilioProvider() {
-	twilioProviderPromise ??= import("./twilio-GBk6YOP_.js");
-	return twilioProviderPromise;
-}
-function loadPlivoProvider() {
-	plivoProviderPromise ??= import("./plivo-sCM3Jvjh.js");
-	return plivoProviderPromise;
-}
-function loadMockProvider() {
-	mockProviderPromise ??= import("./mock-YAo3QDri.js");
-	return mockProviderPromise;
-}
-function loadRealtimeVoiceRuntime() {
-	realtimeVoiceRuntimePromise ??= import("./realtime-voice.runtime-vtdCOWg-.js");
-	return realtimeVoiceRuntimePromise;
-}
-function loadRealtimeHandler() {
-	realtimeHandlerPromise ??= import("./realtime-handler-DdViwdCW.js");
-	return realtimeHandlerPromise;
-}
+const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-DTHQGeaW.js"));
+const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-xNIXGJ-M.js"));
+const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-BnCuAGwj.js"));
+const loadMockProvider = createLazyRuntimeModule(() => import("./mock-YsvBTX-7.js"));
+const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.js"));
+const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-Bz-MNWtD.js"));
 function resolveVoiceCallConsultSessionKey(call) {
 	return resolveVoiceCallSessionKey({
 		config: call.config,
@@ -3290,7 +3353,8 @@ async function resolveProvider(config) {
 			const { TwilioProvider } = await loadTwilioProvider();
 			return new TwilioProvider({
 				accountSid: config.twilio?.accountSid,
-				authToken: resolveTwilioAuthToken(config)
+				authToken: resolveTwilioAuthToken(config),
+				region: config.twilio?.region
 			}, {
 				allowNgrokFreeTierLoopbackBypass,
 				publicUrl: config.publicUrl,
@@ -3326,6 +3390,47 @@ async function resolveRealtimeProvider(params) {
 		cfg: params.fullConfig
 	});
 }
+function listRealtimeAgentIds(config, coreConfig) {
+	const agentIds = /* @__PURE__ */ new Set([normalizeAgentId(config.agentId)]);
+	for (const agent of coreConfig.agents?.list ?? []) agentIds.add(normalizeAgentId(agent.id));
+	for (const route of Object.values(config.numbers)) if (route.agentId) agentIds.add(normalizeAgentId(route.agentId));
+	return [...agentIds];
+}
+async function createRealtimeInstructionsResolver(params) {
+	const genericConfig = {
+		...params.config,
+		realtime: {
+			...params.config.realtime,
+			agentContext: {
+				...params.config.realtime.agentContext,
+				enabled: false
+			}
+		}
+	};
+	const genericInstructions = await buildRealtimeVoiceInstructions({
+		baseInstructions: params.config.realtime.instructions,
+		config: genericConfig,
+		coreConfig: params.coreConfig,
+		agentRuntime: params.agentRuntime
+	});
+	const entries = await Promise.all(listRealtimeAgentIds(params.config, params.coreConfig).map(async (agentId) => {
+		return [agentId, await buildRealtimeVoiceInstructions({
+			baseInstructions: params.config.realtime.instructions,
+			config: {
+				...params.config,
+				agentId
+			},
+			coreConfig: params.coreConfig,
+			agentRuntime: params.agentRuntime
+		})];
+	}));
+	const instructionsByAgentId = new Map(entries);
+	return (call) => {
+		const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
+		const effectiveConfig = resolveVoiceCallEffectiveConfig(params.config, numberRouteKey).config;
+		return instructionsByAgentId.get(resolveCallAgentId(call, effectiveConfig)) ?? genericInstructions;
+	};
+}
 async function createVoiceCallRuntime(params) {
 	const { config: rawConfig, coreConfig, fullConfig, agentRuntime, stateRuntime, ttsRuntime, logger } = params;
 	const log = logger ?? {
@@ -3350,25 +3455,27 @@ async function createVoiceCallRuntime(params) {
 	const webhookServer = new VoiceCallWebhookServer(config, manager, provider, coreConfig, fullConfig ?? coreConfig, agentRuntime, log);
 	if (realtimeProvider) {
 		const { RealtimeCallHandler } = await loadRealtimeHandler();
-		const realtimeInstructions = await buildRealtimeVoiceInstructions({
-			baseInstructions: config.realtime.instructions,
+		const resolveRealtimeInstructions = await createRealtimeInstructionsResolver({
 			config,
-			coreConfig,
+			coreConfig: cfg,
 			agentRuntime
 		});
 		const realtimeHandler = new RealtimeCallHandler({
 			...config.realtime,
-			instructions: realtimeInstructions,
 			tools: resolveRealtimeVoiceAgentConsultTools(config.realtime.toolPolicy, config.realtime.tools)
-		}, manager, provider, realtimeProvider.provider, realtimeProvider.providerConfig, config.serve.path, cfg);
+		}, manager, provider, realtimeProvider.provider, realtimeProvider.providerConfig, config.serve.path, cfg, resolveRealtimeInstructions);
 		if (config.realtime.toolPolicy !== "none") realtimeHandler.registerToolHandler(REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, async (args, callId, handlerContext) => {
 			const call = manager.getCall(callId);
 			if (!call) return { error: `Call "${callId}" not found` };
-			const effectiveConfig = resolveVoiceCallEffectiveConfig(config, resolveVoiceCallNumberRouteKeyForCall(call)).config;
-			const agentId = effectiveConfig.agentId ?? "main";
+			const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
+			const effectiveConfig = resolveVoiceCallEffectiveConfig(config, numberRouteKey).config;
+			const agentId = resolveCallAgentId(call, effectiveConfig);
 			const sessionKey = resolveVoiceCallConsultSessionKey({
 				...call,
-				config: effectiveConfig,
+				config: {
+					...effectiveConfig,
+					agentId
+				},
 				coreSession: cfg.session
 			});
 			const requesterSessionKey = typeof call.metadata?.requesterSessionKey === "string" ? call.metadata.requesterSessionKey : void 0;
@@ -3487,4 +3594,4 @@ async function createVoiceCallRuntime(params) {
 	}
 }
 //#endregion
-export { getHeader as a, getTailscaleSelfInfo as c, chunkAudio as d, resolveVoiceResponseModel as f, mapVoiceToPolly as h, normalizeProviderStatus as i, setupTailscaleExposureRoute as l, escapeXml as m, isProviderStatusTerminal as n, resolveWebhookExposureStatus as o, resolveUserPath as p, mapProviderStatusToEndReason as r, cleanupTailscaleExposureRoute as s, createVoiceCallRuntime as t, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as u };
+export { mapVoiceToPolly as _, normalizeProviderStatus as a, 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 };