@openclaw/voice-call 2026.9.7 → 2026.10.1-beta.1

package/dist/.setup/{runtime-entry-BNOQRXii.mjs → runtime-entry-CbSKxSKk.mjs}

@@ -1,7 +1,7 @@
 import { isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, sendHttpRequestRejection } from "../api.js";
-import { a as resolveVoiceCallEffectiveConfig, c as resolveVoiceCallSessionKey, f as resolveVoiceCallRealtimeTools, i as resolveVoiceCallConfig, l as resolveVoiceCallStreamExposurePaths, m as normalizePhoneNumber, n as normalizeVoiceCallConfig, o as resolveVoiceCallNumberRouteKeyForCall, p as isAllowlistedCaller, r as resolveTwilioAuthToken, u as validateProviderConfig } from "./config-Ds7xoZbI.mjs";
-import { S as TerminalStates, _ as appendCallReplayKey, b as reserveRejectedProviderCall, d as findCallInStore, f as getCallHistoryFromStore, h as persistCallRecord, n as resolveDefaultVoiceCallStoreDir, p as loadActiveCallsFromStore, t as resolveUserPath, v as releaseRejectedProviderCall, x as setVoiceCallStateRuntime, y as rememberManagerReplayKey } from "./utils-B5pnM_Ij.mjs";
-import { createRequire } from "node:module";
+import { a as resolveVoiceCallEffectiveConfig, c as resolveVoiceCallSessionKey, f as resolveVoiceCallRealtimeTools, i as resolveVoiceCallConfig, l as resolveVoiceCallStreamExposurePaths, m as normalizePhoneNumber, n as normalizeVoiceCallConfig, o as resolveVoiceCallNumberRouteKeyForCall, p as isAllowlistedCaller, r as resolveTwilioAuthToken, u as validateProviderConfig } from "./config-CX9J-053.mjs";
+import { n as mapVoiceToPolly, t as escapeXml } from "./voice-mapping-B_iAUkER.mjs";
+import { r as resolveUserPath, t as resolveDefaultVoiceCallStoreDir } from "./store-path-Cfwff6j7.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
@@ -10,22 +10,80 @@ import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { listAgentIds, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, assertRealtimeVoiceAgentConsultModelSelectionUnlocked, buildRealtimeVoiceAgentConsultPolicyInstructions, consultRealtimeVoiceAgent, convertPcmToMulaw8k, createTalkSessionController, recordTalkObservabilityEvent, resolveRealtimeVoiceAgentConsultToolsAllow, resolveRealtimeVoiceFastContextConsult } from "openclaw/plugin-sdk/realtime-voice";
-import { WEBHOOK_BODY_READ_DEFAULTS, createWebhookInFlightLimiter, normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
+import { WEBHOOK_BODY_READ_DEFAULTS, createWebhookInFlightLimiter, normalizeWebhookPath, rawDataToString } from "openclaw/plugin-sdk/webhook-ingress";
+import { z } from "zod";
 import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import fs from "node:fs";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import crypto from "node:crypto";
+import crypto, { randomUUID } from "node:crypto";
 import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
-import path from "node:path";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import * as realtimeBootstrapSdk from "openclaw/plugin-sdk/realtime-bootstrap-context";
 import { spawn } from "node:child_process";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import http from "node:http";
 import { URL as URL$1 } from "node:url";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { resolveConfiguredCapabilityProvider } from "openclaw/plugin-sdk/provider-selection-runtime";
-import { rejectWebSocketUpgrade } from "openclaw/plugin-sdk/websocket-runtime";
+import { WebSocket, WebSocketServer, rejectWebSocketUpgrade } from "openclaw/plugin-sdk/websocket-runtime";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { canonicalizeBase64 } from "openclaw/plugin-sdk/media-runtime";
+//#region extensions/voice-call/src/types.ts
+const ProviderNameSchema = z.enum([
+	"telnyx",
+	"twilio",
+	"plivo",
+	"mock"
+]);
+const EndReasonSchema = z.enum([
+	"completed",
+	"hangup-user",
+	"hangup-bot",
+	"timeout",
+	"error",
+	"failed",
+	"no-answer",
+	"busy",
+	"voicemail"
+]);
+const CallStateSchema = z.enum([
+	"initiated",
+	"ringing",
+	"answered",
+	"active",
+	"speaking",
+	"listening",
+	...EndReasonSchema.options
+]);
+const TerminalStates = new Set(EndReasonSchema.options);
+const CallDirectionSchema = z.enum(["outbound", "inbound"]);
+const TranscriptEntrySchema = z.object({
+	timestamp: z.number(),
+	speaker: z.enum(["bot", "user"]),
+	text: z.string(),
+	isFinal: z.boolean().default(true)
+});
+const CallRecordSchema = z.object({
+	callId: z.string(),
+	providerCallId: z.string().optional(),
+	provider: ProviderNameSchema,
+	direction: CallDirectionSchema,
+	state: CallStateSchema,
+	from: z.string(),
+	to: z.string(),
+	sessionKey: z.string().optional(),
+	/** Agent selected when the call was created; optional only for retained history. */
+	agentId: z.string().optional(),
+	startedAt: z.number(),
+	answeredAt: z.number().optional(),
+	endedAt: z.number().optional(),
+	endReason: EndReasonSchema.optional(),
+	transcript: z.array(TranscriptEntrySchema).default([]),
+	processedEventIds: z.array(z.string()).default([]),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+//#endregion
 //#region extensions/voice-call/src/manager/state.ts
 const ConversationStates = /* @__PURE__ */ new Set(["speaking", "listening"]);
 const StateOrder = [
@@ -38,25 +96,15 @@ const StateOrder = [
 ];
 function transitionState(call, newState) {
 	if (call.state === newState || TerminalStates.has(call.state)) return;
-	if (TerminalStates.has(newState)) {
-		call.state = newState;
-		return;
-	}
-	if (ConversationStates.has(call.state) && ConversationStates.has(newState)) {
-		call.state = newState;
-		return;
-	}
-	const currentIndex = StateOrder.indexOf(call.state);
-	if (StateOrder.indexOf(newState) > currentIndex) call.state = newState;
+	if (TerminalStates.has(newState) || ConversationStates.has(call.state) && ConversationStates.has(newState) || StateOrder.indexOf(newState) > StateOrder.indexOf(call.state)) call.state = newState;
 }
 function addTranscriptEntry(call, speaker, text) {
-	const entry = {
+	call.transcript.push({
 		timestamp: Date.now(),
 		speaker,
 		text,
 		isFinal: true
-	};
-	call.transcript.push(entry);
+	});
 }
 /** Stage persisted changes without exposing uncommitted state through active-call getters. */
 function copyCallRecord(call) {
@@ -68,6 +116,303 @@ function copyCallRecord(call) {
 	};
 }
 //#endregion
+//#region extensions/voice-call/src/runtime-state.ts
+const { setRuntime: setVoiceCallStateRuntime, tryGetRuntime: getOptionalVoiceCallStateRuntime } = createPluginRuntimeStore({
+	pluginId: "voice-call-state",
+	errorMessage: "Voice Call state runtime not initialized"
+});
+//#endregion
+//#region extensions/voice-call/src/manager/replay-keys.ts
+/** Match the existing voice-call webhook replay-cache cardinality. */
+const MAX_MANAGER_REPLAY_KEYS = 1e4;
+function pruneOldestEntries(keys, maxEntries) {
+	while (keys.size > maxEntries) {
+		const oldest = keys.keys().next().value;
+		if (oldest === void 0) break;
+		keys.delete(oldest);
+	}
+}
+/** Remember one manager replay key without refreshing duplicate insertion order. */
+function rememberManagerReplayKey(keys, key, maxEntries = MAX_MANAGER_REPLAY_KEYS) {
+	keys.add(key);
+	pruneOldestEntries(keys, maxEntries);
+}
+/** Append one per-call replay key and retain only the newest bounded suffix. */
+function appendCallReplayKey(keys, key, maxEntries = 500) {
+	keys.push(key);
+	trimCallReplayKeys(keys, maxEntries);
+}
+/** Normalize restored or externally constructed call replay history in place. */
+function trimCallReplayKeys(keys, maxEntries = 500) {
+	const overflow = keys.length - maxEntries;
+	if (overflow > 0) keys.splice(0, overflow);
+}
+/**
+* Reserve one rejected provider call. The token prevents a stale failed
+* hangup from deleting a newer reservation after bounded eviction and reuse.
+*/
+function reserveRejectedProviderCall(calls, providerCallId, maxEntries = MAX_MANAGER_REPLAY_KEYS) {
+	if (calls.has(providerCallId)) return;
+	const reservation = Symbol(providerCallId);
+	calls.set(providerCallId, reservation);
+	pruneOldestEntries(calls, maxEntries);
+	return reservation;
+}
+/** Release a rejected-call reservation only when the failing attempt still owns it. */
+function releaseRejectedProviderCall(calls, providerCallId, reservation) {
+	if (calls.get(providerCallId) === reservation) calls.delete(providerCallId);
+}
+//#endregion
+//#region extensions/voice-call/src/manager/store.ts
+const CALL_RECORD_EVENTS_NAMESPACE = "call-record-events";
+const CALL_RECORD_EVENT_CHUNKS_NAMESPACE = "call-record-event-chunks";
+const MAX_CALL_RECORD_EVENTS = 1e3;
+/** Extra metadata entries retained so pruning can safely trim oldest rows. */
+const CALL_RECORD_EVENT_META_MAX_ENTRIES = 1100;
+const MAX_CHUNKS_PER_CALL_RECORD_EVENT = 48;
+const CALL_RECORD_CHUNK_MAX_ENTRIES = 48048;
+/** Raw UTF-8 bytes stored per call record chunk before base64 encoding. */
+const RAW_CALL_RECORD_CHUNK_BYTES = 48128;
+const CALL_RECORD_READ_BATCH_KEYS = 128;
+let callRecordEventSequence = 0;
+function createCallRecordStateStores(storePath, stateRuntime) {
+	const state = stateRuntime ?? getOptionalVoiceCallStateRuntime()?.state;
+	if (!state) throw new Error("Voice Call state runtime not initialized");
+	const env = {
+		...process.env,
+		OPENCLAW_STATE_DIR: storePath
+	};
+	return {
+		events: state.openKeyedStore({
+			namespace: CALL_RECORD_EVENTS_NAMESPACE,
+			maxEntries: CALL_RECORD_EVENT_META_MAX_ENTRIES,
+			env
+		}),
+		chunks: state.openKeyedStore({
+			namespace: CALL_RECORD_EVENT_CHUNKS_NAMESPACE,
+			maxEntries: CALL_RECORD_CHUNK_MAX_ENTRIES,
+			env
+		})
+	};
+}
+/** Open call stores and log failures instead of breaking restore paths. */
+function tryCreateCallRecordStateStores(storePath, stateRuntime) {
+	try {
+		return createCallRecordStateStores(storePath, stateRuntime);
+	} catch (err) {
+		console.error("[voice-call] Failed to open SQLite call record store:", err);
+		return null;
+	}
+}
+function buildChunkKey(eventKey, index) {
+	return `${eventKey}:chunk:${String(index).padStart(4, "0")}`;
+}
+/** Allocate monotonic ordering metadata for newly persisted call records. */
+function nextCallRecordOrder() {
+	const sequence = callRecordEventSequence;
+	callRecordEventSequence = (callRecordEventSequence + 1) % 1e6;
+	return {
+		persistedAt: Date.now(),
+		sequence
+	};
+}
+function parseEventKeySequence(key) {
+	const sequence = /^event:[^:]+:(\d+):/.exec(key)?.[1];
+	return sequence ? Number.parseInt(sequence, 10) : 0;
+}
+function countCallRecordChunks(call) {
+	return Math.max(1, Math.ceil(Buffer.byteLength(JSON.stringify(call), "utf8") / RAW_CALL_RECORD_CHUNK_BYTES));
+}
+/** Truncate oversized call records to fit the bounded plugin state chunk budget. */
+function prepareVoiceCallRecordForStorage(call) {
+	let boundedCall = call;
+	if (call.processedEventIds.length > 500) {
+		boundedCall = {
+			...call,
+			processedEventIds: [...call.processedEventIds]
+		};
+		trimCallReplayKeys(boundedCall.processedEventIds);
+	}
+	if (countCallRecordChunks(boundedCall) <= MAX_CHUNKS_PER_CALL_RECORD_EVENT) return boundedCall;
+	const transcriptEntries = boundedCall.transcript.length;
+	const metadata = {
+		...boundedCall.metadata,
+		voiceCallPersistence: {
+			transcriptTruncated: true,
+			originalTranscriptEntries: transcriptEntries
+		}
+	};
+	const candidateInputs = [
+		{
+			transcript: call.transcript.slice(-20),
+			metadata
+		},
+		{
+			transcript: [],
+			metadata
+		},
+		{
+			transcript: [],
+			metadata: { voiceCallPersistence: {
+				transcriptTruncated: true,
+				originalTranscriptEntries: transcriptEntries,
+				metadataTruncated: true
+			} }
+		}
+	];
+	for (const candidateInput of candidateInputs) {
+		const candidate = CallRecordSchema.parse({
+			...boundedCall,
+			...candidateInput
+		});
+		if (countCallRecordChunks(candidate) <= MAX_CHUNKS_PER_CALL_RECORD_EVENT) return candidate;
+	}
+	return boundedCall;
+}
+/** Encode one bounded record; chunks are produced only when requested by the writer. */
+function encodeCallRecordEvent(call) {
+	const serialized = JSON.stringify(prepareVoiceCallRecordForStorage(call));
+	const buffer = Buffer.from(serialized, "utf8");
+	const chunkCount = Math.max(1, Math.ceil(buffer.byteLength / RAW_CALL_RECORD_CHUNK_BYTES));
+	if (chunkCount > MAX_CHUNKS_PER_CALL_RECORD_EVENT) throw new Error(`voice-call record exceeds SQLite chunk limit (${chunkCount}/${MAX_CHUNKS_PER_CALL_RECORD_EVENT})`);
+	return {
+		meta: {
+			chunkCount,
+			byteLength: buffer.byteLength
+		},
+		chunk(index) {
+			return {
+				index,
+				dataBase64: buffer.subarray(index * RAW_CALL_RECORD_CHUNK_BYTES, (index + 1) * RAW_CALL_RECORD_CHUNK_BYTES).toString("base64")
+			};
+		}
+	};
+}
+async function pruneCallRecordEvents(stores) {
+	if (stores.events.count && await stores.events.count() <= 1e3) return;
+	const rows = await stores.events.entries();
+	if (rows.length <= 1e3) return;
+	const sorted = rows.toSorted((a, b) => a.createdAt - b.createdAt || a.key.localeCompare(b.key));
+	for (const row of sorted.slice(0, rows.length - MAX_CALL_RECORD_EVENTS)) {
+		const meta = await stores.events.lookup(row.key);
+		await stores.events.delete(row.key);
+		if (meta) for (let index = 0; index < meta.chunkCount; index += 1) await stores.chunks.delete(buildChunkKey(row.key, index));
+	}
+}
+function isValidCallRecordChunkCount(chunkCount) {
+	return Number.isSafeInteger(chunkCount) && chunkCount >= 1 && chunkCount <= MAX_CHUNKS_PER_CALL_RECORD_EVENT;
+}
+async function readCallRecordEvent(stores, eventKey, meta, records) {
+	if (!isValidCallRecordChunkCount(meta.chunkCount)) return null;
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const result = records?.[index];
+		if (result && !result.ok) throw result.error;
+		const chunk = records ? result?.value : await stores.chunks.lookup(buildChunkKey(eventKey, index));
+		if (!chunk || chunk.index !== index) return null;
+		chunks.push(Buffer.from(chunk.dataBase64, "base64"));
+	}
+	const serialized = Buffer.concat(chunks, meta.byteLength).toString("utf8");
+	try {
+		return CallRecordSchema.parse(JSON.parse(serialized));
+	} catch {
+		return null;
+	}
+}
+/** Read all persisted call records in stable persisted order. */
+async function readCallRecordEvents(stores) {
+	const entries = (await stores.events.entries()).toSorted((a, b) => a.createdAt - b.createdAt || a.key.localeCompare(b.key));
+	const sqliteCalls = [];
+	let batchEnd = 0;
+	let chunkOffset = 0;
+	let chunkRecords;
+	for (const [entryIndex, entry] of entries.entries()) {
+		if (entryIndex >= batchEnd && stores.chunks.lookupMany) {
+			const keys = [];
+			for (let next = entryIndex;; next++) {
+				const row = entries[next];
+				if (!row) break;
+				const chunkCount = row.value?.chunkCount;
+				if (!isValidCallRecordChunkCount(chunkCount) || keys.length + chunkCount > CALL_RECORD_READ_BATCH_KEYS) break;
+				for (let index = 0; index < chunkCount; index++) keys.push(buildChunkKey(row.key, index));
+				batchEnd = next + 1;
+			}
+			chunkRecords = keys.length > 0 ? await stores.chunks.lookupMany(keys) : void 0;
+			chunkOffset = 0;
+		}
+		const records = chunkRecords?.slice(chunkOffset, chunkOffset + entry.value.chunkCount);
+		const call = await readCallRecordEvent(stores, entry.key, entry.value, records);
+		if (chunkRecords) chunkOffset += entry.value.chunkCount;
+		if (call) sqliteCalls.push({
+			call,
+			persistedAt: entry.value.persistedAt ?? entry.createdAt,
+			sequence: entry.value.sequence ?? parseEventKeySequence(entry.key),
+			orderKey: entry.key
+		});
+	}
+	return sqliteCalls.toSorted((a, b) => a.persistedAt - b.persistedAt || a.sequence - b.sequence || a.orderKey.localeCompare(b.orderKey)).map((entry) => entry.call);
+}
+async function persistCallRecord(storePath, call, stateRuntime) {
+	try {
+		const stores = createCallRecordStateStores(storePath, stateRuntime);
+		const order = nextCallRecordOrder();
+		const eventKey = `event:${order.persistedAt.toString(36)}:${String(order.sequence).padStart(6, "0")}:${randomUUID()}`;
+		const encoded = encodeCallRecordEvent(call);
+		for (let index = 0; index < encoded.meta.chunkCount; index += 1) await stores.chunks.register(buildChunkKey(eventKey, index), encoded.chunk(index));
+		await stores.events.register(eventKey, {
+			...encoded.meta,
+			...order
+		});
+		await pruneCallRecordEvents(stores);
+	} catch (err) {
+		console.error("[voice-call] Failed to persist call record:", err);
+		throw err;
+	}
+}
+/** Restore nonterminal active calls and event indexes from persisted records. */
+async function loadActiveCallsFromStore(storePath, stateRuntime) {
+	const stores = tryCreateCallRecordStateStores(storePath, stateRuntime);
+	let calls = [];
+	try {
+		calls = stores ? await readCallRecordEvents(stores) : [];
+	} catch (err) {
+		console.error("[voice-call] Failed to read SQLite call records:", err);
+	}
+	const callMap = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		callMap.delete(call.callId);
+		callMap.set(call.callId, call);
+	}
+	const activeCalls = /* @__PURE__ */ new Map();
+	const processedEventIds = /* @__PURE__ */ new Set();
+	for (const [callId, call] of callMap) {
+		trimCallReplayKeys(call.processedEventIds);
+		for (const eventId of call.processedEventIds) rememberManagerReplayKey(processedEventIds, eventId);
+		if (TerminalStates.has(call.state)) continue;
+		activeCalls.set(callId, call);
+	}
+	return {
+		activeCalls,
+		processedEventIds
+	};
+}
+/** Resolve an internal ID or retained provider alias to its newest logical call snapshot. */
+async function findCallInStore(storePath, callId, stateRuntime) {
+	const calls = await readCallRecordEvents(createCallRecordStateStores(storePath, stateRuntime));
+	const match = calls.findLast((call) => call.callId === callId) ?? calls.findLast((call) => call.providerCallId === callId);
+	return match ? calls.findLast((call) => call.callId === match.callId) : void 0;
+}
+async function getCallHistoryFromStore(storePath, limit = 50, stateRuntime) {
+	if (limit <= 0) return [];
+	const stores = tryCreateCallRecordStateStores(storePath, stateRuntime);
+	if (stores) try {
+		return (await readCallRecordEvents(stores)).slice(-limit);
+	} catch (err) {
+		console.error("[voice-call] Failed to read SQLite call history:", err);
+	}
+	return [];
+}
+//#endregion
 //#region extensions/voice-call/src/manager/timer-delays.ts
 /** Convert seconds to a safe timeout delay in milliseconds. */
 function resolveVoiceCallSecondsTimerDelayMs(seconds, minMs = 1) {
@@ -151,17 +496,11 @@ function waitForFinalTranscript(ctx, callId, turnToken) {
 //#endregion
 //#region extensions/voice-call/src/manager/lifecycle.ts
 const log$1 = createSubsystemLogger("voice-call/lifecycle");
-/** Remove a provider-call mapping only when it still points at this call. */
-function removeProviderCallMapping(providerCallIdMap, call) {
-	if (!call.providerCallId) return;
-	if (providerCallIdMap.get(call.providerCallId) === call.callId) providerCallIdMap.delete(call.providerCallId);
-}
 /** Finalize under the manager mutation queue, publishing cleanup only after persistence. */
 async function finalizeCall(params) {
 	const { ctx, call, endReason } = params;
 	if (ctx.activeCalls.get(call.callId) !== call) return;
-	const previousState = call.state;
-	if (!TerminalStates.has(previousState)) {
+	if (!TerminalStates.has(call.state)) {
 		const next = copyCallRecord(params.preparedCall ?? call);
 		next.endedAt = params.endedAt ?? Date.now();
 		next.endReason = endReason;
@@ -178,7 +517,7 @@ async function finalizeCall(params) {
 	}
 	if (ctx.transcriptWaiters) rejectTranscriptWaiter({ transcriptWaiters: ctx.transcriptWaiters }, call.callId, params.transcriptRejectReason ?? `Call ended: ${endReason}`);
 	ctx.activeCalls.delete(call.callId);
-	removeProviderCallMapping(ctx.providerCallIdMap, call);
+	if (call.providerCallId && ctx.providerCallIdMap.get(call.providerCallId) === call.callId) ctx.providerCallIdMap.delete(call.providerCallId);
 }
 //#endregion
 //#region extensions/voice-call/src/manager/lookup.ts
@@ -200,52 +539,11 @@ function findCall(params) {
 }
 //#endregion
 //#region extensions/voice-call/src/tts-provider-voice.ts
-/** Read voice setting aliases from one provider-specific config block. */
-function resolveProviderVoiceSetting(providerConfig) {
-	if (!providerConfig || typeof providerConfig !== "object") return;
-	const candidate = providerConfig;
-	return normalizeOptionalString(candidate.speakerVoice) ?? normalizeOptionalString(candidate.speakerVoiceId) ?? normalizeOptionalString(candidate.voice) ?? normalizeOptionalString(candidate.voiceId);
-}
 /** Resolve the active provider's preferred voice id/name from voice-call TTS config. */
 function resolvePreferredTtsVoice(config) {
 	const providerId = config.tts?.provider;
-	if (!providerId) return;
-	return resolveProviderVoiceSetting(config.tts?.providers?.[providerId]);
-}
-//#endregion
-//#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;");
-}
-/**
-* Map of OpenAI voice names to similar Twilio Polly voices.
-*/
-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"]
-]);
-/**
-* Default Polly voice when no mapping is found.
-*/
-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;
+	const candidate = providerId ? config.tts?.providers?.[providerId] : void 0;
+	return normalizeOptionalString(candidate?.speakerVoice) ?? normalizeOptionalString(candidate?.speakerVoiceId) ?? normalizeOptionalString(candidate?.voice) ?? normalizeOptionalString(candidate?.voiceId);
 }
 //#endregion
 //#region extensions/voice-call/src/manager/mutations.ts
@@ -314,8 +612,7 @@ function isCurrentCall(ctx, call) {
 function validateDtmfDigits(digits) {
 	return /^[0-9*#wWpP,]+$/.test(digits) ? null : "digits may only contain digits, *, #, comma, w, p";
 }
-async function initiateCall(ctx, to, sessionKey, options) {
-	const opts = typeof options === "string" ? { message: options } : options ?? {};
+async function initiateCall(ctx, to, sessionKey, opts = {}) {
 	const initialMessage = opts.message;
 	const mode = opts.mode ?? ctx.config.outbound.defaultMode;
 	const dtmfSequence = opts.dtmfSequence;
@@ -350,7 +647,7 @@ async function initiateCall(ctx, to, sessionKey, options) {
 		error: `Maximum concurrent calls (${ctx.config.maxConcurrentCalls}) reached`
 	};
 	const callId = crypto.randomUUID();
-	const from = ctx.config.fromNumber || (ctx.provider?.name === "mock" ? "+15550000000" : void 0);
+	const from = ctx.config.fromNumber || (ctx.provider.name === "mock" ? "+15550000000" : void 0);
 	if (!from) return {
 		callId: "",
 		success: false,
@@ -483,13 +780,12 @@ async function speak(ctx, callId, text, options) {
 		});
 		const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
 		const voice = resolvePreferredTtsVoice(resolveVoiceCallEffectiveConfig(ctx.config, numberRouteKey).config);
-		const playbackOptions = options?.listenAfterPlayback ? { listenAfterPlayback: true } : {};
 		await provider.playTts({
 			callId,
 			providerCallId: call.providerCallId ?? providerCallId,
 			text,
 			voice,
-			...playbackOptions
+			...options?.listenAfterPlayback ? { listenAfterPlayback: true } : {}
 		});
 		if (!await updateCall(ctx, call, (next) => addTranscriptEntry(next, "bot", text))) return {
 			success: false,
@@ -506,10 +802,8 @@ async function speak(ctx, callId, text, options) {
 		};
 	}
 }
-function shouldStartListeningAfterInitialMessage(ctx) {
-	if (ctx.provider?.name !== "twilio") return true;
-	if (!ctx.config.streaming.enabled) return true;
-	return ctx.provider.isConversationStreamConnectEnabled?.() !== true;
+function hasConversationStreamConnect(provider, config) {
+	return provider?.name === "twilio" && config.streaming.enabled && provider.isConversationStreamConnectEnabled?.() === true;
 }
 async function sendDtmf(ctx, callId, digits) {
 	const validationError = validateDtmfDigits(digits);
@@ -595,7 +889,7 @@ async function speakInitialMessage(ctx, providerCallId) {
 				ctx.trackCallWork(work);
 			}, delayMs);
 			ctx.notifyHangupTimers.set(call.callId, timer);
-		} else if (mode === "conversation" && ctx.provider && shouldStartListeningAfterInitialMessage(ctx)) {
+		} else if (mode === "conversation" && ctx.provider && !hasConversationStreamConnect(ctx.provider, ctx.config)) {
 			if (!await updateCall(ctx, call, (next) => transitionState(next, "listening")) || !isCurrentCall(ctx, call)) return;
 			if (ctx.isStopping()) throw new Error("Voice Call manager is stopping");
 			await ctx.provider.startListening({
@@ -661,7 +955,7 @@ async function continueCall(ctx, callId, prompt) {
 			success: false,
 			error: "Call has ended"
 		};
-		console.log("[voice-call] continueCall latency call=" + call.callId + " totalMs=" + String(lastTurnLatencyMs) + " listenWaitMs=" + String(lastTurnListenWaitMs));
+		console.log(`[voice-call] continueCall latency call=${call.callId} totalMs=${lastTurnLatencyMs} listenWaitMs=${lastTurnListenWaitMs}`);
 		return {
 			success: true,
 			transcript
@@ -742,8 +1036,7 @@ function shouldAcceptInbound(config, from) {
 }
 async function createWebhookCall(params) {
 	const callId = crypto.randomUUID();
-	const effective = resolveVoiceCallEffectiveConfig(params.ctx.config, params.direction === "inbound" ? params.to : void 0);
-	const effectiveConfig = effective.config;
+	const { config: effectiveConfig, numberRouteKey } = resolveVoiceCallEffectiveConfig(params.ctx.config, params.direction === "inbound" ? params.to : void 0);
 	const callRecord = {
 		callId,
 		providerCallId: params.providerCallId,
@@ -764,7 +1057,7 @@ async function createWebhookCall(params) {
 		processedEventIds: [],
 		metadata: {
 			initialMessage: params.direction === "inbound" ? effectiveConfig.inboundGreeting || "Hello! How can I help you today?" : void 0,
-			...effective.numberRouteKey ? { numberRouteKey: effective.numberRouteKey } : {}
+			...numberRouteKey ? { numberRouteKey } : {}
 		}
 	};
 	await persistCallRecord(params.ctx.storePath, callRecord, params.ctx.stateRuntime);
@@ -820,9 +1113,8 @@ async function processEventInQueue(ctx, event) {
 	if (call && providerCallId && providerCallId !== call.providerCallId) {
 		if ((providerCallId === event.callId && retained ? retained : await findCallInStore(ctx.storePath, providerCallId, ctx.stateRuntime))?.callId === call.callId) providerCallId = call.providerCallId;
 	}
-	const eventDirection = event.direction === "inbound" || event.direction === "outbound" ? event.direction : void 0;
-	if (!call && providerCallId && eventDirection) {
-		if (eventDirection === "inbound" && !shouldAcceptInbound(ctx.config, event.from)) {
+	if (!call && providerCallId && event.direction) {
+		if (event.direction === "inbound" && !shouldAcceptInbound(ctx.config, event.from)) {
 			const pid = providerCallId;
 			if (!ctx.provider) {
 				log.warn(`Inbound call rejected by policy but no provider to hang up (providerCallId: ${pid}, caller=${redactIdentifier(event.from)}); call will time out on provider side.`);
@@ -855,7 +1147,7 @@ async function processEventInQueue(ctx, event) {
 		call = await createWebhookCall({
 			ctx,
 			providerCallId,
-			direction: eventDirection === "outbound" ? "outbound" : "inbound",
+			direction: event.direction,
 			from: event.from || "unknown",
 			to: event.to || ctx.config.fromNumber || "unknown"
 		});
@@ -866,7 +1158,7 @@ async function processEventInQueue(ctx, event) {
 		replayable: true
 	};
 	const activeCall = copyCallRecord(call);
-	const previousCall = { providerCallId: call.providerCallId };
+	const previousProviderCallId = call.providerCallId;
 	const shouldCommitReplayKey = !(event.type === "call.error" && event.retryable);
 	const effects = [];
 	let result = { kind: "processed" };
@@ -884,10 +1176,10 @@ async function processEventInQueue(ctx, event) {
 		}
 	};
 	const publishProviderCallId = (terminal = false) => {
-		if (!providerCallId || providerCallId === previousCall.providerCallId) return;
+		if (!providerCallId || providerCallId === previousProviderCallId) return;
 		if (!terminal) ctx.providerCallIdMap.set(providerCallId, activeCall.callId);
-		if (previousCall.providerCallId) {
-			if (ctx.providerCallIdMap.get(previousCall.providerCallId) === activeCall.callId) ctx.providerCallIdMap.delete(previousCall.providerCallId);
+		if (previousProviderCallId) {
+			if (ctx.providerCallIdMap.get(previousProviderCallId) === activeCall.callId) ctx.providerCallIdMap.delete(previousProviderCallId);
 		}
 	};
 	if (providerCallId && providerCallId !== activeCall.providerCallId) activeCall.providerCallId = providerCallId;
@@ -963,35 +1255,26 @@ async function processEventInQueue(ctx, event) {
 			break;
 		case "call.silence":
 		case "call.dtmf": break;
+		case "call.error":
 		case "call.ended":
+			if (event.type === "call.error" && event.retryable) {
+				result = {
+					kind: "processed",
+					replayable: true
+				};
+				break;
+			}
 			await finalizeCall({
 				ctx,
 				call,
 				preparedCall: activeCall,
-				endReason: event.reason,
-				endedAt: event.timestamp
+				endReason: event.type === "call.ended" ? event.reason : "error",
+				endedAt: event.timestamp,
+				transcriptRejectReason: event.type === "call.error" ? `Call error: ${event.error}` : void 0
 			});
 			publishProviderCallId(true);
 			rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
 			return { kind: "processed" };
-		case "call.error":
-			if (!event.retryable) {
-				await finalizeCall({
-					ctx,
-					call,
-					preparedCall: activeCall,
-					endReason: "error",
-					endedAt: event.timestamp,
-					transcriptRejectReason: `Call error: ${event.error}`
-				});
-				publishProviderCallId(true);
-				rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
-				return { kind: "processed" };
-			}
-			result = {
-				kind: "processed",
-				replayable: true
-			};
 	}
 	await persistCallRecord(ctx.storePath, activeCall, ctx.stateRuntime);
 	Object.assign(call, activeCall);
@@ -1001,19 +1284,25 @@ async function processEventInQueue(ctx, event) {
 	return result;
 }
 //#endregion
+//#region extensions/voice-call/src/resolve-call-agent-id.ts
+/** Setup and startup must resolve the same owner before provisioning telephony. */
+function resolveVoiceCallAgentId(config, coreConfig) {
+	return config.agentId ? normalizeAgentId(config.agentId) : resolveDefaultAgentId(coreConfig, {
+		surface: "Voice Call",
+		hint: "Set plugins.entries.voice-call.config.agentId to a configured agent ID."
+	});
+}
+function resolveCallAgentId(call) {
+	if (!call.agentId?.trim()) throw new Error("Voice Call has no recorded agent owner. Start a new call and hang up any remaining call with your provider; saved history is unchanged.");
+	return normalizeAgentId(call.agentId);
+}
+//#endregion
 //#region extensions/voice-call/src/manager.ts
 function markRestoredCallSkipped(call, endReason) {
 	call.endedAt = Date.now();
 	call.endReason = endReason;
 	call.state = endReason;
 }
-function incrementRestoreStatusCount(counts, status) {
-	const key = normalizeOptionalString(status) ?? "terminal";
-	counts.set(key, (counts.get(key) ?? 0) + 1);
-}
-function resolveRestoredMaxDurationAnchor(call) {
-	return call.answeredAt ?? (call.state === "speaking" || call.state === "listening" ? call.startedAt : void 0);
-}
 function resolveDefaultStoreBase(config, storePath) {
 	const rawOverride = storePath?.trim() || config.store?.trim();
 	if (rawOverride) return resolveUserPath(rawOverride);
@@ -1033,10 +1322,13 @@ var CallManager = class {
 	stop() {
 		if (this.stopPromise) return this.stopPromise;
 		this.closing = true;
-		for (const timers of [this.maxDurationTimers, this.notifyHangupTimers]) {
-			for (const timer of timers.values()) clearTimeout(timer);
-			timers.clear();
-		}
+		const clearTimers = () => {
+			for (const timers of [this.maxDurationTimers, this.notifyHangupTimers]) {
+				for (const timer of timers.values()) clearTimeout(timer);
+				timers.clear();
+			}
+		};
+		clearTimers();
 		for (const waiter of this.transcriptWaiters.values()) {
 			clearTimeout(waiter.timeout);
 			waiter.reject(/* @__PURE__ */ new Error("Voice Call runtime stopped"));
@@ -1048,10 +1340,7 @@ var CallManager = class {
 				const results = await Promise.allSettled(this.pendingWork);
 				for (const result of results) if (result.status === "rejected") failures.push(result.reason);
 			}
-			for (const timers of [this.maxDurationTimers, this.notifyHangupTimers]) {
-				for (const timer of timers.values()) clearTimeout(timer);
-				timers.clear();
-			}
+			clearTimers();
 			if (failures.length > 0) throw new AggregateError(failures, "Voice Call work failed during shutdown");
 		})();
 		return this.stopPromise;
@@ -1092,10 +1381,6 @@ var CallManager = class {
 		this.storePath = resolveDefaultStoreBase(config, storePath);
 		this.stateRuntime = stateRuntime;
 	}
-	/**
-	* Initialize the call manager with a provider.
-	* Verifies persisted calls with the provider and restarts timers.
-	*/
 	initialize(provider, webhookUrl) {
 		if (this.closing) return Promise.reject(/* @__PURE__ */ new Error("Voice Call manager is stopping"));
 		const pending = this.initializeFromStore(provider, webhookUrl);
@@ -1119,7 +1404,7 @@ var CallManager = class {
 		const timers = [];
 		let skippedAlreadyElapsedTimers = 0;
 		for (const [callId, call] of verified) {
-			const maxDurationAnchor = resolveRestoredMaxDurationAnchor(call);
+			const maxDurationAnchor = call.answeredAt ?? (call.state === "speaking" || call.state === "listening" ? call.startedAt : void 0);
 			if (maxDurationAnchor !== void 0 && !TerminalStates.has(call.state)) {
 				const elapsed = Date.now() - maxDurationAnchor;
 				const maxDurationMs = resolveVoiceCallSecondsTimerDelayMs(this.config.maxDurationSeconds);
@@ -1175,6 +1460,12 @@ var CallManager = class {
 		try {
 			for (const [callId, call] of candidates) {
 				if (this.closing) break;
+				try {
+					resolveCallAgentId(call);
+				} catch (error) {
+					console.warn(`[voice-call] Skipped restored call ${callId}: ${formatErrorMessage(error)}`);
+					continue;
+				}
 				if (!call.providerCallId) {
 					skippedNoProviderCallId += 1;
 					continue;
@@ -1195,7 +1486,8 @@ var CallManager = class {
 				}
 				const task = provider.getCallStatus({ providerCallId: call.providerCallId }).then(async (result) => {
 					if (result.isTerminal) {
-						incrementRestoreStatusCount(skippedTerminalStatuses, result.status);
+						const status = normalizeOptionalString(result.status) ?? "terminal";
+						skippedTerminalStatuses.set(status, (skippedTerminalStatuses.get(status) ?? 0) + 1);
 						markRestoredCallSkipped(call, "completed");
 						await persistCallRecord(this.storePath, call, this.stateRuntime);
 					} else if (result.isUnknown) {
@@ -1226,9 +1518,6 @@ var CallManager = class {
 		if (keptVerificationFailures > 0) console.log(`[voice-call] Kept ${keptVerificationFailures} restored call(s) after verification failure (relying on timer)`);
 		return verified;
 	}
-	getProvider() {
-		return this.provider;
-	}
 	async initiateCall(to, sessionKey, options) {
 		return this.runOperation(() => initiateCall(this.getContext(), to, sessionKey, options));
 	}
@@ -1238,15 +1527,9 @@ var CallManager = class {
 	async sendDtmf(callId, digits) {
 		return this.runOperation(() => sendDtmf(this.getContext(), callId, digits));
 	}
-	/**
-	* Speak the initial message for a call (called when media stream connects).
-	*/
 	async speakInitialMessage(providerCallId) {
 		return this.runOperation(() => speakInitialMessage(this.getContext(), providerCallId));
 	}
-	/**
-	* Continue call: speak prompt, then wait for user's final transcript.
-	*/
 	async continueCall(callId, prompt) {
 		return this.runOperation(() => continueCall(this.getContext(), callId, prompt));
 	}
@@ -1298,18 +1581,11 @@ var CallManager = class {
 	invalidateAutoResponse(call) {
 		this.autoResponseOwners.delete(call);
 	}
-	shouldDeferConversationInitialMessageUntilStreamConnect() {
-		if (!this.provider || this.provider.name !== "twilio" || !this.config.streaming.enabled) return false;
-		const streamAwareProvider = this.provider;
-		if (typeof streamAwareProvider.isConversationStreamConnectEnabled !== "function") return false;
-		return streamAwareProvider.isConversationStreamConnectEnabled();
-	}
 	maybeSpeakInitialMessageOnAnswered(call) {
 		if (!(normalizeOptionalString(call.metadata?.initialMessage) ?? "")) return;
 		const mode = call.metadata?.mode ?? "conversation";
 		if (mode === "conversation") {
-			if (this.config.realtime.enabled) return;
-			if (this.shouldDeferConversationInitialMessageUntilStreamConnect()) return;
+			if (this.config.realtime.enabled || hasConversationStreamConnect(this.provider, this.config)) return;
 		} else if (mode !== "notify") return;
 		if (!this.provider || !call.providerCallId) return;
 		this.speakInitialMessage(call.providerCallId).catch((err) => {
@@ -1370,19 +1646,6 @@ async function buildRealtimeVoiceInstructions(params) {
 	return sections.filter(Boolean).join("\n\n");
 }
 //#endregion
-//#region extensions/voice-call/src/resolve-call-agent-id.ts
-/** Setup and startup must resolve the same owner before provisioning telephony. */
-function resolveVoiceCallAgentId(config, coreConfig) {
-	return config.agentId ? normalizeAgentId(config.agentId) : resolveDefaultAgentId(coreConfig, {
-		surface: "Voice Call",
-		hint: "Set plugins.entries.voice-call.config.agentId to a configured agent ID."
-	});
-}
-/** 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) {
@@ -1395,16 +1658,7 @@ function resolveVoiceResponseModel(params) {
 	};
 }
 //#endregion
-//#region extensions/voice-call/src/telephony-audio.ts
-/**
-* Chunk audio buffer into 20ms frames for streaming (8kHz mono mu-law).
-*/
-function* chunkAudio(audio, chunkSize = 160) {
-	for (let i = 0; i < audio.length; i += chunkSize) yield audio.subarray(i, i + chunkSize);
-}
-//#endregion
 //#region extensions/voice-call/src/telephony-tts.ts
-/** Default timeout for one telephony synthesis request. */
 const TELEPHONY_DEFAULT_TTS_TIMEOUT_MS = 8e3;
 var UnsupportedTelephonyTtsOutputFormatError = class extends Error {
 	constructor(outputFormat, provider) {
@@ -1485,7 +1739,7 @@ function buildTailscaleExposureArgs(opts) {
 		opts.localUrl ?? "off"
 	];
 }
-async function runTailscaleCommand(args, timeoutMs = 2500) {
+async function runTailscaleCommand(args) {
 	try {
 		const result = await runCommandWithTimeout(["tailscale", ...args], {
 			killProcessTree: true,
@@ -1495,7 +1749,7 @@ async function runTailscaleCommand(args, timeoutMs = 2500) {
 			},
 			outputCapture: "head",
 			terminateOnOutputLimit: { stdout: true },
-			timeoutMs
+			timeoutMs: 2500
 		});
 		if (result.termination !== "exit" || result.outputLimitExceeded) return {
 			code: -1,
@@ -1621,20 +1875,7 @@ async function terminateNgrokProcess(proc, isClosed) {
 		if (isClosed()) finish();
 	});
 }
-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.
-*
-* Uses the ngrok CLI which must be installed: https://ngrok.com/download
-*
-* @example
-* const tunnel = await startNgrokTunnel({ port: 3334, path: '/voice/webhook' });
-* console.log('Public URL:', tunnel.publicUrl);
-* // Later: await tunnel.stop();
-*/
+/** Start an ngrok CLI tunnel and retain its child until the tunnel is stopped. */
 async function startNgrokTunnel(config) {
 	const args = [
 		"http",
@@ -1644,7 +1885,7 @@ async function startNgrokTunnel(config) {
 		"--log-format",
 		"json"
 	];
-	if (config.domain) args.push("--domain", config.domain);
+	if (config.ngrokDomain) args.push("--domain", config.ngrokDomain);
 	return new Promise((resolve, reject) => {
 		const proc = spawn("ngrok", args, {
 			stdio: [
@@ -1652,9 +1893,9 @@ async function startNgrokTunnel(config) {
 				"pipe",
 				"pipe"
 			],
-			...config.authToken ? { env: {
+			...config.ngrokAuthToken ? { env: {
 				...process.env,
-				NGROK_AUTHTOKEN: config.authToken
+				NGROK_AUTHTOKEN: config.ngrokAuthToken
 			} } : {}
 		});
 		let startupSettled = false;
@@ -1712,7 +1953,7 @@ async function startNgrokTunnel(config) {
 			if (combined.includes(NGROK_ERROR_MARKER)) rejectIfPending(`ngrok error: ${formatBoundedChildOutput(combined)}`, true);
 			stderrTail = sliceUtf16Safe(combined, -8);
 		});
-		listenForChildStreamErrors(proc, (stream, error) => {
+		for (const stream of ["stdout", "stderr"]) proc[stream].on("error", (error) => {
 			rejectIfPending(`ngrok ${stream} error: ${error.message}`, true);
 		});
 		proc.on("error", (err) => {
@@ -1728,53 +1969,42 @@ async function startNgrokTunnel(config) {
 		});
 	});
 }
-async function startTailscaleTunnel(config) {
-	const path = config.path.startsWith("/") ? config.path : `/${config.path}`;
-	const routes = [{
-		publicPath: path,
-		localPath: path
-	}, ...config.streamPaths ?? []].map(({ publicPath, localPath }) => {
-		const normalizedPublicPath = publicPath.startsWith("/") ? publicPath : `/${publicPath}`;
-		const normalizedLocalPath = localPath.startsWith("/") ? localPath : `/${localPath}`;
-		return {
-			path: normalizedPublicPath,
-			localUrl: `http://127.0.0.1:${config.port}${normalizedLocalPath}`
-		};
-	});
-	const publicUrl = await setupTailscaleExposureRoutes({
-		mode: config.mode,
-		port: config.tailscalePort,
-		routes
-	});
-	if (!publicUrl) throw new Error(`Tailscale ${config.mode} failed`);
-	return {
-		publicUrl,
-		provider: `tailscale-${config.mode}`,
-		stop: async () => {
-			for (const route of routes) await cleanupTailscaleExposureRoute({
-				mode: config.mode,
-				port: config.tailscalePort,
-				path: route.path
-			});
-		}
-	};
-}
 async function startTunnel(config) {
 	switch (config.provider) {
-		case "ngrok": return startNgrokTunnel({
-			port: config.port,
-			path: config.path,
-			authToken: config.ngrokAuthToken,
-			domain: config.ngrokDomain
-		});
+		case "ngrok": return startNgrokTunnel(config);
 		case "tailscale-serve":
-		case "tailscale-funnel": return startTailscaleTunnel({
-			mode: config.provider === "tailscale-serve" ? "serve" : "funnel",
-			port: config.port,
-			tailscalePort: config.tailscalePort ?? 443,
-			path: config.path,
-			streamPaths: config.streamPaths
-		});
+		case "tailscale-funnel": {
+			const mode = config.provider === "tailscale-serve" ? "serve" : "funnel";
+			const tailscalePort = config.tailscalePort ?? 443;
+			const routes = [{
+				publicPath: config.path,
+				localPath: config.path
+			}, ...config.streamPaths ?? []].map(({ publicPath, localPath }) => {
+				const normalizedPublicPath = publicPath.startsWith("/") ? publicPath : `/${publicPath}`;
+				const normalizedLocalPath = localPath.startsWith("/") ? localPath : `/${localPath}`;
+				return {
+					path: normalizedPublicPath,
+					localUrl: `http://127.0.0.1:${config.port}${normalizedLocalPath}`
+				};
+			});
+			const publicUrl = await setupTailscaleExposureRoutes({
+				mode,
+				port: tailscalePort,
+				routes
+			});
+			if (!publicUrl) throw new Error(`Tailscale ${mode} failed`);
+			return {
+				publicUrl,
+				provider: `tailscale-${mode}`,
+				stop: async () => {
+					for (const route of routes) await cleanupTailscaleExposureRoute({
+						mode,
+						port: tailscalePort,
+						path: route.path
+					});
+				}
+			};
+		}
 		default: return null;
 	}
 }
@@ -1843,10 +2073,6 @@ function canonicalizeVoiceCallMediaBase64(payloadBase64) {
 	return canonicalizeBase64(payloadBase64.replaceAll("-", "+").replaceAll("_", "/"));
 }
 //#endregion
-//#region extensions/voice-call/src/websocket.ts
-const require = createRequire(import.meta.url);
-const { WebSocket, WebSocketServer } = require(path.join(path.dirname(require.resolve("ws/package.json")), "index.js"));
-//#endregion
 //#region extensions/voice-call/src/media-stream.ts
 const DEFAULT_PRE_START_TIMEOUT_MS = 5e3;
 const DEFAULT_MAX_PENDING_CONNECTIONS = 32;
@@ -1863,24 +2089,17 @@ function sanitizeLogText(value, maxChars) {
 	if (sanitized.length <= maxChars) return sanitized;
 	return `${truncateUtf16Safe(sanitized, maxChars)}...`;
 }
-function normalizeWsMessageData(data) {
-	if (Buffer.isBuffer(data)) return data;
-	if (Array.isArray(data)) return Buffer.concat(data);
-	return Buffer.from(data);
-}
 function parseTwilioMediaMessage(data) {
-	const raw = normalizeWsMessageData(data);
+	const raw = rawDataToString(data);
 	try {
-		return JSON.parse(raw.toString("utf8"));
+		return JSON.parse(raw);
 	} catch (cause) {
 		throw new Error("Twilio media stream message was malformed JSON", { cause });
 	}
 }
-/**
-* Manages WebSocket connections for Twilio media streams.
-*/
 var MediaStreamHandler = class {
 	constructor(config) {
+		this.config = config;
 		this.wss = null;
 		this.closePromise = null;
 		this.closing = false;
@@ -1889,22 +2108,17 @@ var MediaStreamHandler = class {
 		this.pendingByIp = /* @__PURE__ */ new Map();
 		this.inflightUpgrades = 0;
 		this.ttsQueues = /* @__PURE__ */ new Map();
-		this.ttsPlaying = /* @__PURE__ */ new Map();
 		this.ttsActiveControllers = /* @__PURE__ */ new Map();
 		this.pendingPlaybackMarks = /* @__PURE__ */ new Map();
 		this.ignoredPlaybackMarks = /* @__PURE__ */ new Map();
-		this.config = config;
 		this.preStartTimeoutMs = resolveTimerTimeoutMs(config.preStartTimeoutMs, DEFAULT_PRE_START_TIMEOUT_MS);
 		this.maxPendingConnections = config.maxPendingConnections ?? DEFAULT_MAX_PENDING_CONNECTIONS;
 		this.maxPendingConnectionsPerIp = config.maxPendingConnectionsPerIp ?? DEFAULT_MAX_PENDING_CONNECTIONS_PER_IP;
 		this.maxConnections = config.maxConnections ?? DEFAULT_MAX_CONNECTIONS;
 	}
-	/**
-	* Handle WebSocket upgrade for media stream connections.
-	*/
 	handleUpgrade(request, socket, head) {
 		if (this.closing) {
-			this.rejectUpgrade(socket, 503, "Media stream handler is shutting down");
+			this.rejectUpgrade(socket, "Media stream handler is shutting down");
 			return;
 		}
 		if (!this.wss) {
@@ -1916,8 +2130,8 @@ var MediaStreamHandler = class {
 				this.handleConnection(ws, req);
 			});
 		}
-		if (this.getCurrentConnectionCount() >= this.maxConnections) {
-			this.rejectUpgrade(socket, 503, "Too many media stream connections");
+		if (this.wss.clients.size + this.inflightUpgrades >= this.maxConnections) {
+			this.rejectUpgrade(socket, "Too many media stream connections");
 			return;
 		}
 		this.inflightUpgrades += 1;
@@ -1936,15 +2150,11 @@ var MediaStreamHandler = class {
 		socket.once("close", handleUpgradeAbort);
 		try {
 			this.wss.handleUpgrade(request, socket, head, (ws) => {
-				socket.removeListener("error", handleUpgradeAbort);
-				socket.removeListener("close", handleUpgradeAbort);
-				releaseUpgradeReservation();
+				handleUpgradeAbort();
 				this.wss?.emit("connection", ws, request);
 			});
 		} catch (error) {
-			socket.removeListener("error", handleUpgradeAbort);
-			socket.removeListener("close", handleUpgradeAbort);
-			releaseUpgradeReservation();
+			handleUpgradeAbort();
 			throw error;
 		}
 	}
@@ -1965,9 +2175,6 @@ var MediaStreamHandler = class {
 		});
 		return this.closePromise;
 	}
-	/**
-	* Handle new WebSocket connection from Twilio.
-	*/
 	async handleConnection(ws, _request) {
 		let session = null;
 		const streamToken = this.getStreamToken(_request);
@@ -2032,9 +2239,6 @@ var MediaStreamHandler = class {
 			console.error("[MediaStream] WebSocket error:", error);
 		});
 	}
-	/**
-	* Handle stream start event.
-	*/
 	handleStart(ws, message, streamToken) {
 		const streamSid = message.streamSid || "";
 		const callSid = message.start?.callSid || "";
@@ -2172,9 +2376,6 @@ var MediaStreamHandler = class {
 		});
 		this.config.onTranscriptionReady?.(session.callId, session.streamSid);
 	}
-	/**
-	* Handle stream stop event.
-	*/
 	handleStop(session) {
 		console.log(`[MediaStream] Stream stopped: ${session.streamSid}`);
 		this.clearTtsState(session.streamSid);
@@ -2203,9 +2404,6 @@ var MediaStreamHandler = class {
 		if (resolvedIp) return resolvedIp;
 		return request.socket.remoteAddress || "unknown";
 	}
-	getCurrentConnectionCount() {
-		return this.wss ? this.wss.clients.size + this.inflightUpgrades : this.inflightUpgrades;
-	}
 	registerPendingConnection(ws, ip) {
 		if (this.pendingConnections.size >= this.maxPendingConnections) {
 			console.warn("[MediaStream] Rejecting connection: pending connection limit reached");
@@ -2241,25 +2439,19 @@ var MediaStreamHandler = class {
 		}
 		this.pendingByIp.set(pending.ip, current - 1);
 	}
-	rejectUpgrade(socket, statusCode, message) {
-		const statusText = statusCode === 429 ? "Too Many Requests" : "Service Unavailable";
+	rejectUpgrade(socket, message) {
 		const body = `${message}\n`;
-		socket.write(`HTTP/1.1 ${statusCode} ${statusText}\r\nConnection: close\r
+		socket.write(`HTTP/1.1 503 Service Unavailable\r
+Connection: close\r
 Content-Type: text/plain; charset=utf-8\r
 Content-Length: ${Buffer.byteLength(body)}\r\n\r
 ` + body);
 		socket.destroy();
 	}
-	/**
-	* Get an active session with an open WebSocket, or undefined if unavailable.
-	*/
 	getOpenSession(streamSid) {
 		const session = this.sessions.get(streamSid);
 		return session?.ws.readyState === WebSocket.OPEN ? session : void 0;
 	}
-	/**
-	* Send a message to a stream's WebSocket if available.
-	*/
 	sendToStream(streamSid, message) {
 		const session = this.getOpenSession(streamSid);
 		if (!session) return false;
@@ -2299,9 +2491,6 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 			media: { payload: muLawAudio.toString("base64") }
 		});
 	}
-	/**
-	* Send a mark event to track audio playback position.
-	*/
 	sendMark(streamSid, name) {
 		return this.sendToStream(streamSid, {
 			event: "mark",
@@ -2312,7 +2501,8 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 	/** Send a completion mark and wait until Twilio reports that buffered playback reached it. */
 	async sendMarkAndWait(streamSid, name, audioDurationMs, signal) {
 		signal.throwIfAborted();
-		const marks = this.getPendingPlaybackMarks(streamSid);
+		const marks = this.pendingPlaybackMarks.get(streamSid) ?? /* @__PURE__ */ new Map();
+		this.pendingPlaybackMarks.set(streamSid, marks);
 		if (marks.has(name)) throw new Error(`Telephony playback mark is already pending: ${name}`);
 		this.ignoredPlaybackMarks.get(streamSid)?.delete(name);
 		let pending;
@@ -2342,9 +2532,6 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 		if (!this.sendMark(streamSid, name)) pending.settle(/* @__PURE__ */ new Error("Telephony stream playback failed: completion mark not delivered"));
 		return acknowledgement;
 	}
-	/**
-	* Clear audio buffer (interrupt playback).
-	*/
 	clearAudio(streamSid) {
 		this.invalidatePlaybackMarks(streamSid);
 		return this.sendToStream(streamSid, {
@@ -2357,30 +2544,21 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 	* Only one TTS operation plays at a time per stream to prevent overlap.
 	*/
 	async queueTts(streamSid, playFn) {
-		const queue = this.getTtsQueue(streamSid);
+		const queue = this.ttsQueues.get(streamSid) ?? [];
+		this.ttsQueues.set(streamSid, queue);
 		if (queue.length >= MAX_PENDING_TTS_OPERATIONS_PER_STREAM) throw new Error(`Telephony TTS queue is full for stream; maxPending=${MAX_PENDING_TTS_OPERATIONS_PER_STREAM}`);
-		let resolveEntry;
-		let rejectEntry;
-		const promise = new Promise((resolve, reject) => {
-			resolveEntry = resolve;
-			rejectEntry = reject;
-		});
+		const { promise, resolve, reject } = createDeferred();
 		queue.push({
 			playFn,
 			controller: new AbortController(),
-			resolve: resolveEntry,
-			reject: rejectEntry
+			resolve,
+			reject
 		});
-		if (!this.ttsPlaying.get(streamSid)) this.processQueue(streamSid);
+		if (!this.ttsActiveControllers.has(streamSid)) this.processQueue(streamSid);
 		return promise;
 	}
-	/**
-	* Clear TTS queue and interrupt current playback (barge-in).
-	*/
 	clearTtsQueue(streamSid, _reason = "unspecified") {
-		const queue = this.ttsQueues.get(streamSid);
-		if (queue) this.resolveQueuedTtsEntries(queue);
-		this.ttsActiveControllers.get(streamSid)?.abort();
+		this.abortTtsPlayback(streamSid);
 		const session = this.sessions.get(streamSid);
 		if (session?.talk.activeTurnId) {
 			const cancelled = session.talk.cancelTurn({ payload: {
@@ -2392,20 +2570,6 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 		}
 		this.clearAudio(streamSid);
 	}
-	getTtsQueue(streamSid) {
-		const existing = this.ttsQueues.get(streamSid);
-		if (existing) return existing;
-		const queue = [];
-		this.ttsQueues.set(streamSid, queue);
-		return queue;
-	}
-	getPendingPlaybackMarks(streamSid) {
-		const existing = this.pendingPlaybackMarks.get(streamSid);
-		if (existing) return existing;
-		const marks = /* @__PURE__ */ new Map();
-		this.pendingPlaybackMarks.set(streamSid, marks);
-		return marks;
-	}
 	acknowledgePlaybackMark(streamSid, name) {
 		const ignored = this.ignoredPlaybackMarks.get(streamSid);
 		if (ignored?.delete(name)) {
@@ -2429,16 +2593,10 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 		}
 		this.ignoredPlaybackMarks.set(streamSid, ignored);
 	}
-	/**
-	* Process the TTS queue for a stream.
-	* Uses iterative approach to avoid stack accumulation from recursion.
-	*/
 	async processQueue(streamSid) {
-		this.ttsPlaying.set(streamSid, true);
 		while (true) {
 			const queue = this.ttsQueues.get(streamSid);
 			if (!queue || queue.length === 0) {
-				this.ttsPlaying.delete(streamSid);
 				this.ttsActiveControllers.delete(streamSid);
 				this.ttsQueues.delete(streamSid);
 				return;
@@ -2518,21 +2676,18 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 		return turn.turnId;
 	}
 	clearTtsState(streamSid) {
-		const queue = this.ttsQueues.get(streamSid);
-		if (queue) this.resolveQueuedTtsEntries(queue);
-		this.ttsActiveControllers.get(streamSid)?.abort();
+		this.abortTtsPlayback(streamSid);
 		this.ttsActiveControllers.delete(streamSid);
-		this.ttsPlaying.delete(streamSid);
 		this.ttsQueues.delete(streamSid);
 		this.invalidatePlaybackMarks(streamSid);
 		this.ignoredPlaybackMarks.delete(streamSid);
 	}
-	resolveQueuedTtsEntries(queue) {
-		const pending = queue.splice(0);
-		for (const entry of pending) {
+	abortTtsPlayback(streamSid) {
+		for (const entry of this.ttsQueues.get(streamSid)?.splice(0) ?? []) {
 			entry.controller.abort();
 			entry.resolve();
 		}
+		this.ttsActiveControllers.get(streamSid)?.abort();
 	}
 };
 //#endregion
@@ -2577,33 +2732,38 @@ const CHECK_INTERVAL_MS = 3e4;
 * can be absent even while the call is actively transcribing. These states
 * prove the call is live and should not be reaped. */
 const LiveConversationStates = /* @__PURE__ */ new Set(["speaking", "listening"]);
-/** Start a stale-call reaper and return its cleanup callback. */
+/** Stop joins provider hangups before the call manager can close. */
 function startStaleCallReaper(params) {
 	const maxAgeSeconds = params.staleCallReaperSeconds;
 	if (!maxAgeSeconds || maxAgeSeconds <= 0) return null;
 	const maxAgeMs = maxAgeSeconds * 1e3;
-	const callsBeingReaped = /* @__PURE__ */ new Set();
-	const interval = setInterval(() => {
+	const reap = async () => {
 		const now = Date.now();
+		const hangups = [];
 		for (const call of params.manager.getActiveCalls()) {
 			if (call.answeredAt || TerminalStates.has(call.state) || LiveConversationStates.has(call.state)) continue;
 			const age = now - call.startedAt;
-			if (age > maxAgeMs && !callsBeingReaped.has(call.callId)) {
-				callsBeingReaped.add(call.callId);
+			if (age > maxAgeMs) {
 				console.log(`[voice-call] Reaping stale call ${call.callId} (age: ${Math.round(age / 1e3)}s, state: ${call.state})`);
-				params.manager.endCall(call.callId).then((result) => {
+				const operation = params.manager.endCall(call.callId).then((result) => {
 					if (!result.success) console.warn(`[voice-call] Reaper failed to end call ${call.callId}: ${result.error ?? "unknown error"}`);
 				}).catch((err) => {
 					console.warn(`[voice-call] Reaper failed to end call ${call.callId}:`, err);
-				}).finally(() => {
-					callsBeingReaped.delete(call.callId);
 				});
+				hangups.push(operation);
 			}
 		}
-	}, CHECK_INTERVAL_MS);
-	return () => {
-		clearInterval(interval);
+		await Promise.allSettled(hangups);
 	};
+	if (params.scheduler.signal.aborted) return null;
+	const scheduler = params.scheduler.scope();
+	scheduler.schedule({
+		id: "stale-call-reaper",
+		delayMs: CHECK_INTERVAL_MS,
+		everyMs: CHECK_INTERVAL_MS,
+		run: reap
+	});
+	return () => scheduler.stop();
 }
 //#endregion
 //#region extensions/voice-call/src/webhook/stream-disconnect-grace.ts
@@ -2650,7 +2810,7 @@ const MAX_WEBHOOK_BODY_BYTES = WEBHOOK_BODY_READ_DEFAULTS.preAuth.maxBytes;
 const WEBHOOK_BODY_TIMEOUT_MS = WEBHOOK_BODY_READ_DEFAULTS.preAuth.timeoutMs;
 const MISSING_REMOTE_ADDRESS_IN_FLIGHT_KEY = "__voice_call_no_remote__";
 const loadRealtimeTranscriptionRuntime = createLazyRuntimeModule(() => import("./realtime-transcription.runtime-CbJAs5t_.mjs"));
-const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-BzKrJMEb.mjs"));
+const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-DAhbXEta.mjs"));
 function appendRecentTalkEventMetadata(metadata, event) {
 	const previous = metadata ?? {};
 	const recent = Array.isArray(previous.recentTalkEvents) ? previous.recentTalkEvents.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)) : [];
@@ -2670,13 +2830,11 @@ function appendRecentTalkEventMetadata(metadata, event) {
 function buildRequestUrl(requestUrl) {
 	return new URL$1(requestUrl ?? "/", "http://localhost");
 }
-function resolveForwardedClientIp(request, trustedProxyIPs) {
-	const normalizedTrustedProxyIps = new Set(trustedProxyIPs.map((ip) => normalizeProxyIp(ip)).filter((ip) => Boolean(ip)));
+function resolveForwardedClientIp(request, normalizedTrustedProxyIps) {
 	const forwardedFor = getHeader(request.headers, "x-forwarded-for");
 	if (forwardedFor) {
 		const forwardedIps = normalizeStringEntries(forwardedFor.split(","));
 		if (forwardedIps.length > 0) {
-			if (normalizedTrustedProxyIps.size === 0) return forwardedIps[0];
 			for (let index = forwardedIps.length - 1; index >= 0; index -= 1) {
 				const hop = forwardedIps[index];
 				if (!normalizedTrustedProxyIps.has(normalizeProxyIp(hop) ?? "")) return hop;
@@ -2717,12 +2875,14 @@ function cloneWebhookResponsePayload(payload) {
 		body: payload.body
 	};
 }
-/**
-* HTTP server for receiving voice call webhooks from providers.
-* Supports WebSocket upgrades for media streams when streaming is enabled.
-*/
 var VoiceCallWebhookServer = class {
-	constructor(config, manager, provider, coreConfig, fullConfig, agentRuntime, logger) {
+	constructor(scheduler, config, manager, provider, coreConfig, fullConfig, agentRuntime, logger) {
+		this.scheduler = scheduler;
+		this.manager = manager;
+		this.provider = provider;
+		this.coreConfig = coreConfig;
+		this.fullConfig = fullConfig;
+		this.agentRuntime = agentRuntime;
 		this.server = null;
 		this.listeningUrl = null;
 		this.startPromise = null;
@@ -2735,18 +2895,12 @@ var VoiceCallWebhookServer = class {
 		this.replayResponses = /* @__PURE__ */ new Map();
 		this.replayResponseCacheCalls = 0;
 		this.config = normalizeVoiceCallConfig(config);
-		this.manager = manager;
-		this.provider = provider;
-		this.coreConfig = coreConfig ?? null;
-		this.fullConfig = fullConfig ?? null;
-		this.agentRuntime = agentRuntime ?? null;
-		this.logger = logger ?? {
+		const rawLogger = logger ?? {
 			info: console.log,
 			warn: console.warn,
 			error: console.error,
 			debug: console.debug
 		};
-		const rawLogger = this.logger;
 		const rawDebug = rawLogger.debug;
 		this.logger = {
 			info: (msg) => rawLogger.info(`[voice-call] ${msg}`),
@@ -2791,14 +2945,13 @@ var VoiceCallWebhookServer = class {
 		const normalizedRemoteIp = normalizeProxyIp(remoteIp);
 		const fromTrustedProxy = normalizedTrustedProxyIps.size > 0 && normalizedRemoteIp !== void 0 && normalizedTrustedProxyIps.has(normalizedRemoteIp);
 		if (this.config.webhookSecurity.trustForwardingHeaders && fromTrustedProxy) {
-			const forwardedIp = resolveForwardedClientIp(request, trustedProxyIPs);
+			const forwardedIp = resolveForwardedClientIp(request, normalizedTrustedProxyIps);
 			if (forwardedIp) return forwardedIp;
 		}
 		return remoteIp;
 	}
 	shouldSuppressBargeInForInitialMessage(call) {
-		if (!call || call.direction !== "outbound") return false;
-		if (call.state !== "speaking") return false;
+		if (!call || call.direction !== "outbound" || call.state !== "speaking") return false;
 		if ((call.metadata?.mode ?? "conversation") !== "conversation") return false;
 		return (normalizeOptionalString(call.metadata?.initialMessage) ?? "").length > 0;
 	}
@@ -2820,9 +2973,6 @@ var VoiceCallWebhookServer = class {
 		current.provider.clearTtsQueue(providerCallId);
 		return generation;
 	}
-	/**
-	* Initialize media streaming with the selected realtime transcription provider.
-	*/
 	async initializeMediaStreaming() {
 		const streaming = this.config.streaming;
 		const pluginConfig = this.fullConfig ?? this.coreConfig ?? void 0;
@@ -2940,10 +3090,6 @@ var VoiceCallWebhookServer = class {
 		this.mediaStreamHandler = new MediaStreamHandler(streamConfig);
 		this.logger.info("Media streaming initialized");
 	}
-	/**
-	* Start the webhook server.
-	* Idempotent: returns immediately if the server is already listening.
-	*/
 	async start() {
 		if (this.stopPromise) await this.stopPromise;
 		const { port, bind, path: webhookPath } = this.config.serve;
@@ -2988,6 +3134,7 @@ var VoiceCallWebhookServer = class {
 				}
 				resolve(url);
 				this.stopStaleCallReaper = startStaleCallReaper({
+					scheduler: this.scheduler,
 					manager: this.manager,
 					staleCallReaperSeconds: this.config.staleCallReaperSeconds
 				});
@@ -3013,13 +3160,12 @@ var VoiceCallWebhookServer = class {
 		});
 		this.startPromise = null;
 		this.streamDisconnectGrace.close();
-		if (this.stopStaleCallReaper) {
-			this.stopStaleCallReaper();
-			this.stopStaleCallReaper = null;
-		}
+		const reaperStopped = this.stopStaleCallReaper?.();
+		this.stopStaleCallReaper = null;
 		this.webhookInFlightLimiter.clear();
 		this.stopPromise = (async () => {
 			const results = await Promise.allSettled([
+				reaperStopped,
 				serverClosePromise,
 				this.mediaStreamHandler?.close(serverClosePromise) ?? Promise.resolve(),
 				this.realtimeHandler?.close(serverClosePromise) ?? Promise.resolve()
@@ -3049,9 +3195,6 @@ var VoiceCallWebhookServer = class {
 			return null;
 		}
 	}
-	isWebhookPathMatch(requestPath, configuredPath) {
-		return normalizeWebhookPath(requestPath) === normalizeWebhookPath(configuredPath);
-	}
 	async handleRequest(req, res, webhookPath) {
 		const payload = await this.runWebhookPipeline(req, webhookPath, res);
 		if (payload) this.writeWebhookResponse(res, payload);
@@ -3067,7 +3210,7 @@ var VoiceCallWebhookServer = class {
   <Play loop="0">https://s3.amazonaws.com/com.twilio.music.classical/BusyStrings.mp3</Play>
 </Response>`
 		};
-		if (!this.isWebhookPathMatch(url.pathname, webhookPath)) return {
+		if (normalizeWebhookPath(url.pathname) !== normalizeWebhookPath(webhookPath)) return {
 			statusCode: 404,
 			body: "Not Found"
 		};
@@ -3075,9 +3218,9 @@ var VoiceCallWebhookServer = class {
 			statusCode: 405,
 			body: "Method Not Allowed"
 		};
-		const headerGate = this.verifyPreAuthWebhookHeaders(req.headers);
-		if (!headerGate.ok) {
-			this.logger.warn(`Webhook rejected before body read: ${headerGate.reason}`);
+		const headerRejection = this.verifyPreAuthWebhookHeaders(req.headers);
+		if (headerRejection) {
+			this.logger.warn(`Webhook rejected before body read: ${headerRejection}`);
 			return {
 				statusCode: 401,
 				body: "Unauthorized"
@@ -3178,11 +3321,7 @@ var VoiceCallWebhookServer = class {
 		if (now !== void 0) {
 			for (const [key, entry] of this.replayResponses) if (entry.expiresAt <= now) this.replayResponses.delete(key);
 		}
-		while (this.replayResponses.size > WEBHOOK_REPLAY_RESPONSE_MAX_ENTRIES) {
-			const oldest = this.replayResponses.keys().next().value;
-			if (!oldest) break;
-			this.replayResponses.delete(oldest);
-		}
+		pruneMapToMaxSize(this.replayResponses, WEBHOOK_REPLAY_RESPONSE_MAX_ENTRIES);
 	}
 	async getCachedReplayResponse(key) {
 		const now = asDateTimestampMs(Date.now());
@@ -3218,33 +3357,24 @@ var VoiceCallWebhookServer = class {
 		return cloneWebhookResponsePayload(await ownerResponse);
 	}
 	verifyPreAuthWebhookHeaders(headers) {
-		if (this.config.skipSignatureVerification) return { ok: true };
+		if (this.config.skipSignatureVerification) return;
 		switch (this.provider.name) {
 			case "telnyx": {
 				const signature = getHeader(headers, "telnyx-signature-ed25519");
 				const timestamp = getHeader(headers, "telnyx-timestamp");
-				if (signature && timestamp) return { ok: true };
-				return {
-					ok: false,
-					reason: "missing Telnyx signature or timestamp header"
-				};
+				if (signature && timestamp) return;
+				return "missing Telnyx signature or timestamp header";
 			}
 			case "twilio":
-				if (getHeader(headers, "x-twilio-signature")) return { ok: true };
-				return {
-					ok: false,
-					reason: "missing X-Twilio-Signature header"
-				};
+				if (getHeader(headers, "x-twilio-signature")) return;
+				return "missing X-Twilio-Signature header";
 			case "plivo": {
 				const hasV3 = Boolean(getHeader(headers, "x-plivo-signature-v3")) && Boolean(getHeader(headers, "x-plivo-signature-v3-nonce"));
 				const hasV2 = Boolean(getHeader(headers, "x-plivo-signature-v2")) && Boolean(getHeader(headers, "x-plivo-signature-v2-nonce"));
-				if (hasV3 || hasV2) return { ok: true };
-				return {
-					ok: false,
-					reason: "missing Plivo signature headers"
-				};
+				if (hasV3 || hasV2) return;
+				return "missing Plivo signature headers";
 			}
-			default: return { ok: true };
+			default: return;
 		}
 	}
 	isRealtimeWebSocketUpgrade(req) {
@@ -3304,10 +3434,6 @@ var VoiceCallWebhookServer = class {
 		if (payload.headers) for (const [key, value] of Object.entries(payload.headers)) res.setHeader(key, value);
 		res.end(payload.body);
 	}
-	/**
-	* Handle auto-response for inbound calls using the agent system.
-	* Supports tool calling for richer voice interactions.
-	*/
 	async handleInboundResponse(callId, userMessage) {
 		this.logger.info(`Auto-responding to inbound call ${callId} chars=${userMessage.length}`);
 		const call = this.manager.getCall(callId);
@@ -3348,7 +3474,7 @@ var VoiceCallWebhookServer = class {
 				sessionKey: call.sessionKey,
 				from: call.from,
 				senderIsOwner: call.direction === "inbound" ? false : void 0,
-				agentId: resolveCallAgentId(call, effectiveConfig),
+				agentId: resolveCallAgentId(call),
 				transcript: call.transcript,
 				userMessage,
 				onEarlyText: speakResponse
@@ -3375,12 +3501,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-DjFGCfy1.mjs"));
-const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-Bp3gfmUB.mjs"));
-const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-69ObrQPk.mjs"));
-const loadMockProvider = createLazyRuntimeModule(() => import("./mock-ClWW6Ufu.mjs"));
+const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-DPilutCH.mjs"));
+const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-BWFNGyVx.mjs"));
+const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-CpPIENu4.mjs"));
+const loadMockProvider = createLazyRuntimeModule(() => import("./mock-eLv_Dc4o.mjs"));
 const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.mjs"));
-const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-BgDPcPZt.mjs"));
+const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-Do7Sz7Gh.mjs"));
 function mapVoiceCallConsultTranscript(call, context) {
 	const transcript = (call.transcript ?? []).map((entry) => ({
 		role: entry.speaker === "bot" ? "assistant" : "user",
@@ -3504,13 +3630,10 @@ async function createRealtimeInstructionsResolver(params) {
 		})];
 	}));
 	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;
-	};
+	return (call) => instructionsByAgentId.get(resolveCallAgentId(call)) ?? genericInstructions;
 }
 async function createVoiceCallRuntime(params) {
+	params.scheduler.signal.throwIfAborted();
 	const { config: rawConfig, coreConfig, fullConfig, agentRuntime, stateRuntime, ttsRuntime, logger } = params;
 	const log = logger ?? {
 		info: console.log,
@@ -3532,7 +3655,7 @@ async function createVoiceCallRuntime(params) {
 	if (stateRuntime) setVoiceCallStateRuntime({ state: stateRuntime });
 	const manager = new CallManager(config, void 0, cfg.session, stateRuntime);
 	const realtimeVoiceRuntime = config.realtime.enabled ? await loadRealtimeVoiceRuntime() : null;
-	const webhookServer = new VoiceCallWebhookServer(config, manager, provider, coreConfig, cfg, agentRuntime, log);
+	const webhookServer = new VoiceCallWebhookServer(params.scheduler, config, manager, provider, coreConfig, cfg, agentRuntime, log);
 	if (realtimeVoiceRuntime) {
 		const { RealtimeCallHandler } = await loadRealtimeHandler();
 		const resolveRealtimeInstructions = await createRealtimeInstructionsResolver({
@@ -3547,7 +3670,7 @@ async function createVoiceCallRuntime(params) {
 		const resolveCallRegistration = (call) => {
 			const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
 			const effectiveConfig = resolveVoiceCallEffectiveConfig(config, numberRouteKey).config;
-			const agentId = resolveCallAgentId(call, effectiveConfig);
+			const agentId = resolveCallAgentId(call);
 			const resolved = realtimeVoiceRuntime.resolveConfiguredRealtimeVoiceProvider({
 				configuredProviderId: effectiveConfig.realtime.provider,
 				providerConfigs: effectiveConfig.realtime.providers,
@@ -3571,7 +3694,7 @@ async function createVoiceCallRuntime(params) {
 			if (!call) return { error: `Call "${callId}" not found` };
 			const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
 			const effectiveConfig = resolveVoiceCallEffectiveConfig(config, numberRouteKey).config;
-			const agentId = resolveCallAgentId(call, effectiveConfig);
+			const agentId = resolveCallAgentId(call);
 			const sessionKey = resolveVoiceCallSessionKey({
 				config: {
 					...effectiveConfig,
@@ -3601,6 +3724,12 @@ async function createVoiceCallRuntime(params) {
 				labels: {
 					audienceLabel: "caller",
 					contextName: "OpenClaw memory or session context"
+				},
+				liveness: {
+					signal: handlerContext.abortSignal,
+					assertCurrent() {
+						if (manager.getCall(callId) !== call || TerminalStates.has(call.state)) throw new Error(`Call "${callId}" is no longer active`);
+					}
 				}
 			});
 			handlerContext.abortSignal?.throwIfAborted();
@@ -3719,4 +3848,4 @@ async function createVoiceCallRuntime(params) {
 	}
 }
 //#endregion
-export { resolveCallAgentId as _, normalizeProviderStatus as a, mapVoiceToPolly as b, canonicalizeVoiceCallMediaBase64 as c, cleanupTailscaleExposureRoute as d, getTailscaleSelfInfo as f, resolveVoiceResponseModel as g, chunkAudio as h, mapProviderStatusToEndReason as i, getHeader as l, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as m, normalizeProxyIp as n, WebSocket as o, setupTailscaleExposureRoutes as p, isProviderStatusTerminal as r, WebSocketServer as s, createVoiceCallRuntime as t, resolveWebhookExposureStatus as u, resolveVoiceCallAgentId as v, escapeXml as y };
+export { MAX_CALL_RECORD_EVENTS as _, normalizeProviderStatus as a, loadActiveCallsFromStore as b, resolveWebhookExposureStatus as c, setupTailscaleExposureRoutes as d, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as f, generateDtmfRedirectTwiml as g, resolveVoiceCallAgentId as h, mapProviderStatusToEndReason as i, cleanupTailscaleExposureRoute as l, resolveCallAgentId as m, normalizeProxyIp as n, canonicalizeVoiceCallMediaBase64 as o, resolveVoiceResponseModel as p, isProviderStatusTerminal as r, getHeader as s, createVoiceCallRuntime as t, getTailscaleSelfInfo as u, findCallInStore as v, setVoiceCallStateRuntime as x, getCallHistoryFromStore as y };