@openclaw/voice-call 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{runtime-entry-D0UJiLfi.js → runtime-entry-F13eJ4pp.js}

@@ -1,10 +1,9 @@
 import { TtsConfigSchema, isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "./runtime-api.js";
 import "./api.js";
 import { t as TWILIO_REGIONS } from "./twilio-region-4fkgz3UG.js";
-import { _ as TerminalStates, d as loadActiveCallsFromStore, g as setVoiceCallStateRuntime, l as findCallMatchesInStore, p as persistCallRecord, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-nYL-yM0S.js";
+import { _ as releaseRejectedProviderCall, b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, g as appendCallReplayKey, l as findCallMatchesInStore, p as persistCallRecord, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore, v as rememberManagerReplayKey, x as TerminalStates, y as reserveRejectedProviderCall } from "./store-path-51_oC_xn.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, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
@@ -21,6 +20,7 @@ import fs from "node:fs";
 import crypto from "node:crypto";
 import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
 import path from "node:path";
+import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import os from "node:os";
 import { root } from "openclaw/plugin-sdk/security-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -1207,7 +1207,8 @@ async function continueCall(ctx, callId, prompt) {
 	const turnStartedAt = Date.now();
 	const turnToken = provider.name === "twilio" ? crypto.randomUUID() : void 0;
 	try {
-		await speak(ctx, callId, prompt);
+		const speakResult = await speak(ctx, callId, prompt);
+		if (!speakResult.success) return speakResult;
 		transitionState(call, "listening");
 		persistCallRecord(ctx.storePath, call);
 		const listenStartedAt = Date.now();
@@ -1329,9 +1330,9 @@ function createWebhookCall(params) {
 			...effective.numberRouteKey ? { numberRouteKey: effective.numberRouteKey } : {}
 		}
 	};
+	persistCallRecord(params.ctx.storePath, callRecord);
 	params.ctx.activeCalls.set(callId, callRecord);
 	params.ctx.providerCallIdMap.set(params.providerCallId, callId);
-	persistCallRecord(params.ctx.storePath, callRecord);
 	log.info(`Created ${params.direction} call record: ${callId} caller=${redactIdentifier(params.from)}`);
 	return callRecord;
 }
@@ -1372,9 +1373,7 @@ function processEvent(ctx, event) {
 				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.`);
 				return { kind: "ignored" };
 			}
-			ctx.processedEventIds.add(dedupeKey);
 			if (ctx.rejectedProviderCallIds.has(pid)) return { kind: "ignored" };
-			ctx.rejectedProviderCallIds.add(pid);
 			const callId = event.callId ?? pid;
 			persistRejectedInboundCall({
 				ctx,
@@ -1382,13 +1381,16 @@ function processEvent(ctx, event) {
 				dedupeKey,
 				providerCallId: pid
 			});
+			const rejectionReservation = reserveRejectedProviderCall(ctx.rejectedProviderCallIds, pid);
+			if (rejectionReservation === void 0) return { kind: "ignored" };
+			rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
 			log.info(`Rejecting inbound call by policy: ${pid}`);
 			ctx.provider.hangupCall({
 				callId,
 				providerCallId: pid,
 				reason: "hangup-bot"
 			}).catch((err) => {
-				ctx.rejectedProviderCallIds.delete(pid);
+				releaseRejectedProviderCall(ctx.rejectedProviderCallIds, pid, rejectionReservation);
 				const message = formatErrorMessage(err);
 				log.warn(`Failed to reject inbound call ${pid}: ${message}`);
 			});
@@ -1403,126 +1405,162 @@ function processEvent(ctx, event) {
 		});
 		event.callId = call.callId;
 	}
-	if (!call) return { kind: "ignored" };
-	if (event.providerCallId && event.providerCallId !== call.providerCallId) {
-		const previousProviderCallId = call.providerCallId;
-		call.providerCallId = event.providerCallId;
-		ctx.providerCallIdMap.set(event.providerCallId, call.callId);
-		if (previousProviderCallId) {
-			if (ctx.providerCallIdMap.get(previousProviderCallId) === call.callId) ctx.providerCallIdMap.delete(previousProviderCallId);
-		}
-	}
-	if (!(event.type === "call.error" && event.retryable)) {
-		ctx.processedEventIds.add(dedupeKey);
-		call.processedEventIds.push(dedupeKey);
-	}
+	if (!call) return {
+		kind: "ignored",
+		replayable: true
+	};
+	const activeCall = call;
+	const previousCall = {
+		state: activeCall.state,
+		providerCallId: activeCall.providerCallId,
+		answeredAt: activeCall.answeredAt,
+		endedAt: activeCall.endedAt,
+		endReason: activeCall.endReason,
+		transcriptLength: activeCall.transcript.length,
+		processedEventIds: [...activeCall.processedEventIds]
+	};
+	const shouldCommitReplayKey = !(event.type === "call.error" && event.retryable);
+	const effects = [];
 	let result = { kind: "processed" };
-	switch (event.type) {
-		case "call.initiated":
-			transitionState(call, "initiated");
-			if (call.direction === "inbound" && call.providerCallId && ctx.provider?.answerCall) {
-				const inboundStreamSession = ctx.config.realtime?.enabled && ctx.provider.name === "telnyx" && ctx.streamSessionIssuer ? ctx.streamSessionIssuer({
-					providerName: "telnyx",
-					callId: call.callId,
-					from: call.from,
-					to: call.to,
-					direction: "inbound"
-				}) : void 0;
-				ctx.provider.answerCall({
-					callId: call.callId,
-					providerCallId: call.providerCallId,
-					...inboundStreamSession ? {
-						streamUrl: inboundStreamSession.streamUrl,
-						streamAuthToken: inboundStreamSession.token
-					} : {}
-				}).catch((err) => {
-					const message = formatErrorMessage(err);
-					log.warn(`Failed to answer inbound call ${call.providerCallId}: ${message}`);
-				});
+	const startDurationTimer = () => {
+		startMaxDurationTimer({
+			ctx,
+			callId: activeCall.callId,
+			onTimeout: async (callId) => {
+				await endCall(ctx, callId, { reason: "timeout" });
 			}
-			break;
-		case "call.ringing":
-			transitionState(call, "ringing");
-			break;
-		case "call.answered":
-			call.answeredAt = event.timestamp;
-			transitionState(call, "answered");
-			startMaxDurationTimer({
-				ctx,
-				callId: call.callId,
-				onTimeout: async (callId) => {
-					await endCall(ctx, callId, { reason: "timeout" });
-				}
-			});
-			ctx.onCallAnswered?.(call);
-			break;
-		case "call.active":
-			transitionState(call, "active");
-			break;
-		case "call.speaking":
-		case "call.assistant-speech":
-			ensureMaxDurationTimerForLiveCall({
-				ctx,
-				call,
-				liveAt: event.timestamp,
-				onTimeout: async (callId) => {
-					await endCall(ctx, callId, { reason: "timeout" });
-				}
-			});
-			transitionState(call, "speaking");
-			if (event.type === "call.assistant-speech" && event.transcript.trim()) addTranscriptEntry(call, "bot", event.transcript);
-			break;
-		case "call.speech":
-			if (event.isFinal) {
-				const hadWaiter = ctx.transcriptWaiters.has(call.callId);
-				const resolved = resolveTranscriptWaiter(ctx, call.callId, event.transcript, event.turnToken);
-				if (hadWaiter && !resolved) {
-					log.warn(`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
-				};
+		});
+	};
+	const prepareLiveDurationTimer = () => {
+		if (!activeCall.answeredAt) {
+			activeCall.answeredAt = event.timestamp;
+			effects.push(startDurationTimer);
+		}
+	};
+	const publishProviderCallId = (terminal = false) => {
+		if (!event.providerCallId || event.providerCallId === previousCall.providerCallId) return;
+		if (!terminal) ctx.providerCallIdMap.set(event.providerCallId, activeCall.callId);
+		if (previousCall.providerCallId) {
+			if (ctx.providerCallIdMap.get(previousCall.providerCallId) === activeCall.callId) ctx.providerCallIdMap.delete(previousCall.providerCallId);
+		}
+	};
+	try {
+		if (event.providerCallId && event.providerCallId !== activeCall.providerCallId) activeCall.providerCallId = event.providerCallId;
+		if (shouldCommitReplayKey) appendCallReplayKey(activeCall.processedEventIds, dedupeKey);
+		switch (event.type) {
+			case "call.initiated": {
+				transitionState(activeCall, "initiated");
+				const inboundProvider = ctx.provider;
+				const inboundProviderCallId = activeCall.providerCallId;
+				const answerInboundCall = inboundProvider?.answerCall?.bind(inboundProvider);
+				if (activeCall.direction === "inbound" && inboundProviderCallId && answerInboundCall) effects.push(() => {
+					const inboundStreamSession = ctx.config.realtime?.enabled && inboundProvider?.name === "telnyx" && ctx.streamSessionIssuer ? ctx.streamSessionIssuer({
+						providerName: "telnyx",
+						callId: activeCall.callId,
+						from: activeCall.from,
+						to: activeCall.to,
+						direction: "inbound"
+					}) : void 0;
+					answerInboundCall({
+						callId: activeCall.callId,
+						providerCallId: inboundProviderCallId,
+						...inboundStreamSession ? {
+							streamUrl: inboundStreamSession.streamUrl,
+							streamAuthToken: inboundStreamSession.token
+						} : {}
+					}).catch((err) => {
+						const message = formatErrorMessage(err);
+						log.warn(`Failed to answer inbound call ${activeCall.providerCallId}: ${message}`);
+					});
+				});
+				break;
 			}
-			ensureMaxDurationTimerForLiveCall({
-				ctx,
-				call,
-				liveAt: event.timestamp,
-				onTimeout: async (callId) => {
-					await endCall(ctx, callId, { reason: "timeout" });
+			case "call.ringing":
+				transitionState(activeCall, "ringing");
+				break;
+			case "call.answered":
+				activeCall.answeredAt = event.timestamp;
+				transitionState(activeCall, "answered");
+				effects.push(startDurationTimer, () => ctx.onCallAnswered?.(activeCall));
+				break;
+			case "call.active":
+				transitionState(activeCall, "active");
+				break;
+			case "call.speaking":
+			case "call.assistant-speech":
+				prepareLiveDurationTimer();
+				transitionState(activeCall, "speaking");
+				if (event.type === "call.assistant-speech" && event.transcript.trim()) addTranscriptEntry(activeCall, "bot", event.transcript);
+				break;
+			case "call.speech":
+				if (event.isFinal) {
+					const waiter = ctx.transcriptWaiters.get(activeCall.callId);
+					if (waiter?.turnToken && waiter.turnToken !== event.turnToken) {
+						log.warn(`Ignoring speech event with mismatched turn token for ${activeCall.callId}`);
+						result = { kind: "ignored" };
+						break;
+					}
+					addTranscriptEntry(activeCall, "user", event.transcript);
+					result = {
+						kind: "final-speech",
+						call: activeCall,
+						transcript: event.transcript,
+						waiterResolved: Boolean(waiter)
+					};
+					if (waiter) effects.push(() => {
+						resolveTranscriptWaiter(ctx, activeCall.callId, event.transcript, event.turnToken);
+					});
 				}
-			});
-			transitionState(call, "listening");
-			break;
-		case "call.silence":
-		case "call.dtmf": break;
-		case "call.ended":
-			finalizeCall({
-				ctx,
-				call,
-				endReason: event.reason,
-				endedAt: event.timestamp
-			});
-			return { kind: "processed" };
-		case "call.error":
-			if (!event.retryable) {
+				prepareLiveDurationTimer();
+				transitionState(activeCall, "listening");
+				break;
+			case "call.silence":
+			case "call.dtmf": break;
+			case "call.ended":
 				finalizeCall({
 					ctx,
-					call,
-					endReason: "error",
-					endedAt: event.timestamp,
-					transcriptRejectReason: `Call error: ${event.error}`
+					call: activeCall,
+					endReason: event.reason,
+					endedAt: event.timestamp
 				});
+				publishProviderCallId(true);
+				rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
 				return { kind: "processed" };
-			}
-			break;
+			case "call.error":
+				if (!event.retryable) {
+					finalizeCall({
+						ctx,
+						call: 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
+				};
+				break;
+		}
+		persistCallRecord(ctx.storePath, activeCall);
+		publishProviderCallId();
+		if (shouldCommitReplayKey) rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
+	} catch (err) {
+		Object.assign(activeCall, {
+			state: previousCall.state,
+			providerCallId: previousCall.providerCallId,
+			answeredAt: previousCall.answeredAt,
+			endedAt: previousCall.endedAt,
+			endReason: previousCall.endReason
+		});
+		activeCall.transcript.length = previousCall.transcriptLength;
+		activeCall.processedEventIds.splice(0, activeCall.processedEventIds.length, ...previousCall.processedEventIds);
+		throw err;
 	}
-	persistCallRecord(ctx.storePath, call);
+	for (const effect of effects) effect();
 	return result;
 }
 //#endregion
@@ -1564,7 +1602,7 @@ var CallManager = class {
 		this.activeCalls = /* @__PURE__ */ new Map();
 		this.providerCallIdMap = /* @__PURE__ */ new Map();
 		this.processedEventIds = /* @__PURE__ */ new Set();
-		this.rejectedProviderCallIds = /* @__PURE__ */ new Set();
+		this.rejectedProviderCallIds = /* @__PURE__ */ new Map();
 		this.provider = null;
 		this.webhookUrl = null;
 		this.activeTurnCalls = /* @__PURE__ */ new Set();
@@ -1585,7 +1623,7 @@ var CallManager = class {
 		fs.mkdirSync(this.storePath, { recursive: true });
 		const persisted = loadActiveCallsFromStore(this.storePath);
 		this.processedEventIds = persisted.processedEventIds;
-		this.rejectedProviderCallIds = persisted.rejectedProviderCallIds;
+		this.rejectedProviderCallIds = /* @__PURE__ */ new Map();
 		const verified = await this.verifyRestoredCalls(provider, persisted.activeCalls);
 		this.activeCalls = verified;
 		this.providerCallIdMap = /* @__PURE__ */ new Map();
@@ -2381,6 +2419,7 @@ const DEFAULT_MAX_PENDING_CONNECTIONS_PER_IP = 4;
 const DEFAULT_MAX_CONNECTIONS = 128;
 const MAX_INBOUND_MESSAGE_BYTES = 64 * 1024;
 const MAX_WS_BUFFERED_BYTES = 1024 * 1024;
+const MAX_PENDING_TTS_OPERATIONS_PER_STREAM = 8;
 const CLOSE_REASON_LOG_MAX_CHARS = 120;
 function sanitizeLogText(value, maxChars) {
 	const sanitized = value.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim();
@@ -2406,6 +2445,8 @@ function parseTwilioMediaMessage(data) {
 var MediaStreamHandler = class {
 	constructor(config) {
 		this.wss = null;
+		this.closePromise = null;
+		this.closing = false;
 		this.sessions = /* @__PURE__ */ new Map();
 		this.pendingConnections = /* @__PURE__ */ new Map();
 		this.pendingByIp = /* @__PURE__ */ new Map();
@@ -2423,6 +2464,10 @@ var MediaStreamHandler = class {
 	* Handle WebSocket upgrade for media stream connections.
 	*/
 	handleUpgrade(request, socket, head) {
+		if (this.closing) {
+			this.rejectUpgrade(socket, 503, "Media stream handler is shutting down");
+			return;
+		}
 		if (!this.wss) {
 			this.wss = new WebSocketServer({
 				noServer: true,
@@ -2464,6 +2509,23 @@ var MediaStreamHandler = class {
 			throw error;
 		}
 	}
+	close(shutdownBarrier = Promise.resolve()) {
+		if (this.closePromise) return this.closePromise;
+		this.closing = true;
+		const wss = this.wss;
+		this.wss = null;
+		this.closePromise = (async () => {
+			if (wss) await new Promise((resolve) => {
+				wss.close(() => resolve());
+				for (const ws of wss.clients) ws.terminate();
+			});
+			await shutdownBarrier;
+		})().finally(() => {
+			this.closing = false;
+			this.closePromise = null;
+		});
+		return this.closePromise;
+	}
 	/**
 	* Handle new WebSocket connection from Twilio.
 	*/
@@ -2483,6 +2545,11 @@ var MediaStreamHandler = class {
 						console.log("[MediaStream] Twilio connected");
 						break;
 					case "start":
+						if (session) {
+							console.warn("[MediaStream] Rejecting duplicate start frame for active connection");
+							ws.close(1008, "Duplicate start");
+							break;
+						}
 						session = this.handleStart(ws, message, streamToken);
 						if (session) this.clearPendingConnection(ws);
 						break;
@@ -2852,6 +2919,7 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 	*/
 	async queueTts(streamSid, playFn) {
 		const queue = this.getTtsQueue(streamSid);
+		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) => {
@@ -2871,8 +2939,8 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 	* Clear TTS queue and interrupt current playback (barge-in).
 	*/
 	clearTtsQueue(streamSid, _reason = "unspecified") {
-		const queue = this.getTtsQueue(streamSid);
-		this.resolveQueuedTtsEntries(queue);
+		const queue = this.ttsQueues.get(streamSid);
+		if (queue) this.resolveQueuedTtsEntries(queue);
 		this.ttsActiveControllers.get(streamSid)?.abort();
 		const session = this.sessions.get(streamSid);
 		if (session?.talk.activeTurnId) {
@@ -2901,8 +2969,9 @@ Content-Length: ${Buffer.byteLength(body)}\r\n\r
 		while (true) {
 			const queue = this.ttsQueues.get(streamSid);
 			if (!queue || queue.length === 0) {
-				this.ttsPlaying.set(streamSid, false);
+				this.ttsPlaying.delete(streamSid);
 				this.ttsActiveControllers.delete(streamSid);
+				this.ttsQueues.delete(streamSid);
 				return;
 			}
 			const entry = queue.shift();
@@ -3071,7 +3140,7 @@ const WEBHOOK_BODY_TIMEOUT_MS = WEBHOOK_BODY_READ_DEFAULTS.preAuth.timeoutMs;
 const MISSING_REMOTE_ADDRESS_IN_FLIGHT_KEY = "__voice_call_no_remote__";
 const STREAM_DISCONNECT_HANGUP_GRACE_MS = 2e3;
 const loadRealtimeTranscriptionRuntime = createLazyRuntimeModule(() => import("./realtime-transcription.runtime-CbJAs5t_.js"));
-const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-D-7ApVfT.js"));
+const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-D-hkzo5Y.js"));
 function appendRecentTalkEventMetadata(call, event) {
 	const metadata = call.metadata ?? {};
 	const recent = Array.isArray(metadata.recentTalkEvents) ? metadata.recentTalkEvents.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)) : [];
@@ -3147,6 +3216,7 @@ var VoiceCallWebhookServer = class {
 		this.server = null;
 		this.listeningUrl = null;
 		this.startPromise = null;
+		this.stopPromise = null;
 		this.stopStaleCallReaper = null;
 		this.webhookInFlightLimiter = createWebhookInFlightLimiter();
 		this.mediaStreamHandler = null;
@@ -3348,6 +3418,7 @@ var VoiceCallWebhookServer = class {
 	* 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;
 		const streamPath = this.config.streaming.streamPath;
 		if (this.server?.listening) return this.listeningUrl ?? this.resolveListeningUrl(bind, webhookPath);
@@ -3397,26 +3468,46 @@ var VoiceCallWebhookServer = class {
 	/**
 	* Stop the webhook server.
 	*/
-	async stop() {
+	stop() {
+		if (this.stopPromise) return this.stopPromise;
+		const server = this.server;
+		const serverClosePromise = new Promise((resolve, reject) => {
+			if (!server) {
+				resolve();
+				return;
+			}
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		});
+		this.startPromise = null;
 		for (const timer of this.pendingDisconnectHangups.values()) clearTimeout(timer);
 		this.pendingDisconnectHangups.clear();
-		this.webhookInFlightLimiter.clear();
-		this.startPromise = null;
 		if (this.stopStaleCallReaper) {
 			this.stopStaleCallReaper();
 			this.stopStaleCallReaper = null;
 		}
-		return new Promise((resolve) => {
-			if (this.server) this.server.close(() => {
-				this.server = null;
-				this.listeningUrl = null;
-				resolve();
-			});
-			else {
-				this.listeningUrl = null;
-				resolve();
-			}
+		this.webhookInFlightLimiter.clear();
+		this.stopPromise = (async () => {
+			const results = await Promise.allSettled([
+				serverClosePromise,
+				this.mediaStreamHandler?.close(serverClosePromise) ?? Promise.resolve(),
+				this.realtimeHandler?.close(serverClosePromise) ?? Promise.resolve()
+			]);
+			for (const timer of this.pendingDisconnectHangups.values()) clearTimeout(timer);
+			this.pendingDisconnectHangups.clear();
+			if (this.server === server) this.server = null;
+			this.listeningUrl = null;
+			const failure = results.find((result) => result.status === "rejected");
+			if (failure) throw failure.reason;
+		})().finally(() => {
+			this.stopPromise = null;
 		});
+		return this.stopPromise;
 	}
 	resolveListeningUrl(bind, webhookPath) {
 		const address = this.server?.address();
@@ -3521,9 +3612,9 @@ var VoiceCallWebhookServer = class {
 			const isReplay = Boolean(verification.isReplay);
 			if (isReplay) {
 				this.logger.warn("Replay detected; skipping event side effects");
-				if (this.provider.name === "twilio") return buildTwilioReplayTwiML();
 				const cachedResponse = await this.getCachedReplayResponse(verification.verifiedRequestKey);
 				if (cachedResponse) return cachedResponse;
+				if (this.provider.name === "twilio") return buildTwilioReplayTwiML();
 			}
 			const buildResponse = async () => {
 				const initialTwiML = this.provider.consumeInitialTwiML?.(ctx);
@@ -3547,12 +3638,11 @@ var VoiceCallWebhookServer = class {
 					return this.realtimeHandler.buildTwiMLPayload(req, realtimeParams);
 				}
 				const parsed = this.provider.parseWebhookEvent(ctx, { verifiedRequestKey: verification.verifiedRequestKey });
-				if (!isReplay) this.processParsedEvents(parsed.events);
+				if (!isReplay && this.processParsedEvents(parsed.events)) verification.releaseReplay?.();
 				return normalizeWebhookResponse(parsed);
 			};
 			if (isReplay) return await buildResponse();
-			if (this.provider.name === "twilio") return await buildResponse();
-			return await this.cacheReplayResponse(verification.verifiedRequestKey, buildResponse);
+			return await this.cacheReplayResponse(verification.verifiedRequestKey, buildResponse, verification.releaseReplay);
 		} finally {
 			this.webhookInFlightLimiter.release(inFlightKey);
 		}
@@ -3578,21 +3668,28 @@ var VoiceCallWebhookServer = class {
 		}
 		return cloneWebhookResponsePayload(await entry.response);
 	}
-	async cacheReplayResponse(key, buildResponse) {
+	async cacheReplayResponse(key, buildResponse, releaseReplay) {
 		const now = Date.now();
 		const expiresAt = resolveExpiresAtMsFromDurationMs(WEBHOOK_REPLAY_RESPONSE_TTL_MS, { nowMs: now });
 		this.replayResponseCacheCalls += 1;
 		if (this.replayResponseCacheCalls % WEBHOOK_REPLAY_RESPONSE_PRUNE_INTERVAL === 0) this.pruneReplayResponses(now);
-		const response = buildResponse().then(cloneWebhookResponsePayload).catch((err) => {
-			this.replayResponses.delete(key);
+		let cachedEntry;
+		const ownerResponse = buildResponse().then(cloneWebhookResponsePayload).catch((err) => {
+			if (cachedEntry && this.replayResponses.get(key) === cachedEntry) this.replayResponses.delete(key);
+			releaseReplay?.();
 			throw err;
 		});
-		if (expiresAt !== void 0) this.replayResponses.set(key, {
-			expiresAt,
-			response
-		});
+		const response = ownerResponse.then((payload) => this.provider.name === "twilio" ? buildTwilioReplayTwiML() : cloneWebhookResponsePayload(payload));
+		response.catch(() => {});
+		if (expiresAt !== void 0) {
+			cachedEntry = {
+				expiresAt,
+				response
+			};
+			this.replayResponses.set(key, cachedEntry);
+		}
 		if (this.replayResponses.size > WEBHOOK_REPLAY_RESPONSE_MAX_ENTRIES) this.pruneReplayResponses(now);
-		return cloneWebhookResponsePayload(await response);
+		return cloneWebhookResponsePayload(await ownerResponse);
 	}
 	verifyPreAuthWebhookHeaders(headers) {
 		if (this.config.skipSignatureVerification) return { ok: true };
@@ -3656,20 +3753,25 @@ var VoiceCallWebhookServer = class {
 		}
 	}
 	processParsedEvents(events) {
+		let replayable = false;
 		for (const event of events) try {
-			this.processEventWithAutoResponse(event);
+			replayable = this.processEventWithAutoResponse(event) || replayable;
 		} catch (err) {
 			this.logger.error(`Error processing event ${event.type}: ${String(err)}`);
+			throw err;
 		}
+		return replayable;
 	}
 	processEventWithAutoResponse(event) {
 		const result = this.manager.processEvent(event);
-		if (result.kind !== "final-speech" || result.waiterResolved) return;
+		if (result.kind !== "final-speech") return result.replayable === true;
+		if (result.waiterResolved) return false;
 		const callMode = result.call.metadata?.mode;
-		if (result.call.direction !== "inbound" && callMode !== "conversation") return;
+		if (result.call.direction !== "inbound" && callMode !== "conversation") return false;
 		this.handleInboundResponse(result.call.callId, result.transcript).catch((err) => {
 			this.logger.warn(`Failed to auto-respond: ${String(err)}`);
 		});
+		return false;
 	}
 	writeWebhookResponse(res, payload) {
 		res.statusCode = payload.statusCode;
@@ -3746,12 +3848,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-Dx6cfLvV.js"));
-const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-D_D8KysU.js"));
-const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-vZ--Wqxv.js"));
-const loadMockProvider = createLazyRuntimeModule(() => import("./mock-YsvBTX-7.js"));
+const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-sIS_WgnY.js"));
+const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-CbeVrVAl.js"));
+const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-DbI17uAc.js"));
+const loadMockProvider = createLazyRuntimeModule(() => import("./mock-BCq0q36l.js"));
 const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.js"));
-const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler--i_OERv6.js"));
+const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-uXR0QgVa.js"));
 function resolveVoiceCallConsultSessionKey(call) {
 	return resolveVoiceCallSessionKey({
 		config: call.config,
@@ -3775,7 +3877,7 @@ function mapVoiceCallConsultTranscript(call, context) {
 }
 function createRuntimeResourceLifecycle(params) {
 	let tunnelResult = null;
-	let stopped = false;
+	let stopPromise = null;
 	const runStep = async (step, suppressErrors) => {
 		if (suppressErrors) {
 			await step().catch(() => {});
@@ -3787,19 +3889,21 @@ function createRuntimeResourceLifecycle(params) {
 		setTunnelResult: (result) => {
 			tunnelResult = result;
 		},
-		stop: async (opts) => {
-			if (stopped) return;
-			stopped = true;
+		stop: (opts) => {
+			if (stopPromise) return stopPromise;
 			const suppressErrors = opts?.suppressErrors ?? false;
-			await runStep(async () => {
-				if (tunnelResult) await tunnelResult.stop();
-			}, suppressErrors);
-			await runStep(async () => {
-				await cleanupTailscaleExposure(params.config);
-			}, suppressErrors);
-			await runStep(async () => {
-				await params.webhookServer.stop();
-			}, suppressErrors);
+			stopPromise = (async () => {
+				await runStep(async () => {
+					if (tunnelResult) await tunnelResult.stop();
+				}, suppressErrors);
+				await runStep(async () => {
+					await cleanupTailscaleExposure(params.config);
+				}, suppressErrors);
+				await runStep(async () => {
+					await params.webhookServer.stop();
+				}, suppressErrors);
+			})();
+			return stopPromise;
 		}
 	};
 }
@@ -3937,6 +4041,7 @@ async function createVoiceCallRuntime(params) {
 			tools: resolveRealtimeVoiceAgentConsultTools(config.realtime.toolPolicy, config.realtime.tools)
 		}, 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) => {
+			handlerContext.abortSignal?.throwIfAborted();
 			const call = manager.getCall(callId);
 			if (!call) return { error: `Call "${callId}" not found` };
 			const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
@@ -3967,6 +4072,7 @@ async function createVoiceCallRuntime(params) {
 				args,
 				logger: log
 			});
+			handlerContext.abortSignal?.throwIfAborted();
 			if (fastContext.handled) {
 				assertRealtimeVoiceAgentConsultModelSelectionUnlocked(modelLockParams);
 				return fastContext.result;
@@ -4003,7 +4109,8 @@ async function createVoiceCallRuntime(params) {
 				spawnedBy: requesterSessionKey,
 				contextMode: requesterSessionKey ? "fork" : void 0,
 				toolsAllow: resolveRealtimeVoiceAgentConsultToolsAllow(effectiveConfig.realtime.toolPolicy),
-				extraSystemPrompt: REALTIME_VOICE_CONSULT_SYSTEM_PROMPT
+				extraSystemPrompt: REALTIME_VOICE_CONSULT_SYSTEM_PROMPT,
+				abortSignal: handlerContext.abortSignal
 			});
 		});
 		webhookServer.setRealtimeHandler(realtimeHandler);
@@ -4058,7 +4165,7 @@ async function createVoiceCallRuntime(params) {
 		}
 		if (realtimeProvider) log.info(`[voice-call] Realtime voice provider: ${realtimeProvider.provider.id}`);
 		await manager.initialize(provider, webhookUrl);
-		const stop = async () => await lifecycle.stop();
+		const stop = () => lifecycle.stop();
 		log.info("[voice-call] Runtime initialized");
 		log.info(`[voice-call] Webhook URL: ${webhookUrl}`);
 		if (publicUrl && publicUrl !== webhookUrl) log.info(`[voice-call] Public URL: ${publicUrl}`);