@openclaw/voice-call 2026.9.4 → 2026.9.6

package/dist/{runtime-entry-Ln4SWaYK.js → .setup/runtime-entry-dDRm6RgA.mjs}

@@ -1,7 +1,7 @@
-import { isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, sendHttpRequestRejection } from "./runtime-api.js";
-import "./api.js";
-import { a as resolveVoiceCallEffectiveConfig, c as resolveVoiceCallSessionKey, f as resolveVoiceCallRealtimeTools, i as resolveVoiceCallConfig, l as resolveVoiceCallStreamExposurePaths, n as normalizeVoiceCallConfig, o as resolveVoiceCallNumberRouteKeyForCall, r as resolveTwilioAuthToken, u as validateProviderConfig } from "./config-DQwvsxeV.js";
-import { _ as releaseRejectedProviderCall, b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, g as appendCallReplayKey, l as findCallInStore, p as persistCallRecord, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore, v as rememberManagerReplayKey, x as TerminalStates, y as reserveRejectedProviderCall } from "./store-path-M0GXxUfv.js";
+import { isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, sendHttpRequestRejection } from "../runtime-api.js";
+import "../api.js";
+import { a as resolveVoiceCallEffectiveConfig, c as resolveVoiceCallSessionKey, f as resolveVoiceCallRealtimeTools, i as resolveVoiceCallConfig, l as resolveVoiceCallStreamExposurePaths, n as normalizeVoiceCallConfig, o as resolveVoiceCallNumberRouteKeyForCall, r as resolveTwilioAuthToken, u as validateProviderConfig } from "./config-72FnMWHb.mjs";
+import { _ as releaseRejectedProviderCall, b as setVoiceCallStateRuntime, d as getCallHistoryFromStore, f as loadActiveCallsFromStore, g as appendCallReplayKey, m as persistCallRecord, t as resolveDefaultVoiceCallStoreDir, u as findCallInStore, v as rememberManagerReplayKey, x as TerminalStates, y as reserveRejectedProviderCall } from "./store-path-B1j1up4_.mjs";
 import { createRequire } from "node:module";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
@@ -14,6 +14,7 @@ import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, assertRealtimeVoiceAgentConsult
 import { WEBHOOK_BODY_READ_DEFAULTS, createWebhookInFlightLimiter, normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 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 { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
 import path from "node:path";
@@ -74,6 +75,15 @@ function addTranscriptEntry(call, speaker, text) {
 	};
 	call.transcript.push(entry);
 }
+/** Stage persisted changes without exposing uncommitted state through active-call getters. */
+function copyCallRecord(call) {
+	return {
+		...call,
+		transcript: [...call.transcript],
+		processedEventIds: [...call.processedEventIds],
+		...call.metadata ? { metadata: { ...call.metadata } } : {}
+	};
+}
 //#endregion
 //#region extensions/voice-call/src/manager/timer-delays.ts
 /** Convert seconds to a safe timeout delay in milliseconds. */
@@ -102,10 +112,10 @@ function startMaxDurationTimer(params) {
 	const maxDurationMs = params.timeoutMs === void 0 ? resolveVoiceCallSecondsTimerDelayMs(params.ctx.config.maxDurationSeconds) : resolveVoiceCallTimerDelayMs(params.timeoutMs);
 	console.log(`[voice-call] Starting max duration timer (${Math.ceil(maxDurationMs / 1e3)}s) for call ${params.callId}`);
 	const timer = setTimeout(() => {
-		(async () => {
+		const work = (async () => {
 			params.ctx.maxDurationTimers.delete(params.callId);
 			const call = params.ctx.activeCalls.get(params.callId);
-			if (call && !TerminalStates.has(call.state)) {
+			if (!params.ctx.isStopping() && call && !TerminalStates.has(call.state)) {
 				console.log(`[voice-call] Max duration reached (${Math.ceil(maxDurationMs / 1e3)}s), ending call ${params.callId}`);
 				try {
 					const result = await params.onTimeout(params.callId);
@@ -115,19 +125,10 @@ function startMaxDurationTimer(params) {
 				}
 			}
 		})();
+		params.ctx.trackCallWork(work);
 	}, maxDurationMs);
 	params.ctx.maxDurationTimers.set(params.callId, timer);
 }
-/** Backfill max-duration enforcement from the first live conversation signal. */
-function ensureMaxDurationTimerForLiveCall(params) {
-	if (params.call.answeredAt) return;
-	params.call.answeredAt = params.liveAt;
-	startMaxDurationTimer({
-		ctx: params.ctx,
-		callId: params.call.callId,
-		onTimeout: params.onTimeout
-	});
-}
 /** Clear and forget a pending final-transcript waiter. */
 function clearTranscriptWaiter(ctx, callId) {
 	const waiter = ctx.transcriptWaiters.get(callId);
@@ -176,18 +177,26 @@ function removeProviderCallMapping(providerCallIdMap, call) {
 	if (!call.providerCallId) return;
 	if (providerCallIdMap.get(call.providerCallId) === call.callId) providerCallIdMap.delete(call.providerCallId);
 }
-/** Persist terminal state, clean timers/waiters, and remove active call indexes. */
-function finalizeCall(params) {
+/** 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)) {
-		call.endedAt = params.endedAt ?? Date.now();
-		call.endReason = endReason;
-		transitionState(call, endReason);
-		persistCallRecord(ctx.storePath, call);
+		const next = copyCallRecord(params.preparedCall ?? call);
+		next.endedAt = params.endedAt ?? Date.now();
+		next.endReason = endReason;
+		transitionState(next, endReason);
+		await persistCallRecord(ctx.storePath, next, ctx.stateRuntime);
+		Object.assign(call, next);
 		log$1.info(`[voice-call] Call finalized callId=${call.callId} providerCallId=${call.providerCallId ?? "unknown"} endReason=${endReason}`);
 	}
 	if (ctx.maxDurationTimers) clearMaxDurationTimer({ maxDurationTimers: ctx.maxDurationTimers }, call.callId);
+	const notifyTimer = ctx.notifyHangupTimers?.get(call.callId);
+	if (notifyTimer) {
+		clearTimeout(notifyTimer);
+		ctx.notifyHangupTimers?.delete(call.callId);
+	}
 	if (ctx.transcriptWaiters) rejectTranscriptWaiter({ transcriptWaiters: ctx.transcriptWaiters }, call.callId, params.transcriptRejectReason ?? `Call ended: ${endReason}`);
 	ctx.activeCalls.delete(call.callId);
 	removeProviderCallMapping(ctx.providerCallIdMap, call);
@@ -260,6 +269,19 @@ function mapVoiceToPolly(voice) {
 	return OPENAI_TO_POLLY_MAP.get(normalizeLowercaseStringOrEmpty(voice)) ?? DEFAULT_POLLY_VOICE;
 }
 //#endregion
+//#region extensions/voice-call/src/manager/mutations.ts
+/** Commit one live call update while preserving the call identity held by its callbacks. */
+function updateCall(ctx, call, update, isCurrent) {
+	return ctx.mutationQueue.enqueue("state", async () => {
+		if (ctx.activeCalls.get(call.callId) !== call || TerminalStates.has(call.state) || isCurrent && !isCurrent()) return false;
+		const next = copyCallRecord(call);
+		update(next);
+		await persistCallRecord(ctx.storePath, next, ctx.stateRuntime);
+		Object.assign(call, next);
+		return true;
+	});
+}
+//#endregion
 //#region extensions/voice-call/src/manager/twiml.ts
 /** Generate TwiML that speaks one notification and hangs up. */
 function generateNotifyTwiml(message, voice) {
@@ -317,6 +339,9 @@ function requireConnectedCall(ctx, callId) {
 		provider: lookup.provider
 	};
 }
+function isCurrentCall(ctx, call) {
+	return ctx.activeCalls.get(call.callId) === call && !TerminalStates.has(call.state);
+}
 function validateDtmfDigits(digits) {
 	return /^[0-9*#wWpP,]+$/.test(digits) ? null : "digits may only contain digits, *, #, comma, w, p";
 }
@@ -350,7 +375,7 @@ async function initiateCall(ctx, to, sessionKey, options) {
 		success: false,
 		error: "Webhook URL not configured"
 	};
-	if (ctx.activeCalls.size >= ctx.config.maxConcurrentCalls) return {
+	if (ctx.activeCalls.size + ctx.pendingCallAdmissions.size >= ctx.config.maxConcurrentCalls) return {
 		callId: "",
 		success: false,
 		error: `Maximum concurrent calls (${ctx.config.maxConcurrentCalls}) reached`
@@ -389,9 +414,18 @@ async function initiateCall(ctx, to, sessionKey, options) {
 			...requesterSessionKey ? { requesterSessionKey } : {}
 		}
 	};
-	persistCallRecord(ctx.storePath, callRecord);
-	ctx.activeCalls.set(callId, callRecord);
+	ctx.pendingCallAdmissions.add(callId);
+	try {
+		await ctx.mutationQueue.enqueue("state", async () => {
+			await persistCallRecord(ctx.storePath, callRecord, ctx.stateRuntime);
+			ctx.activeCalls.set(callId, callRecord);
+			ctx.pendingCallAdmissions.delete(callId);
+		});
+	} finally {
+		ctx.pendingCallAdmissions.delete(callId);
+	}
 	try {
+		if (ctx.isStopping()) throw new Error("Voice Call manager is stopping");
 		let inlineTwiml;
 		let preConnectTwiml;
 		if (mode === "notify" && initialMessage) {
@@ -421,22 +455,25 @@ async function initiateCall(ctx, to, sessionKey, options) {
 				streamAuthToken: streamSession.token
 			} : {}
 		});
-		if (ctx.activeCalls.get(callId) === callRecord && !callRecord.providerCallId) {
-			callRecord.providerCallId = result.providerCallId;
+		await ctx.mutationQueue.enqueue("state", async () => {
+			if (!isCurrentCall(ctx, callRecord) || callRecord.providerCallId) return;
+			const next = copyCallRecord(callRecord);
+			next.providerCallId = result.providerCallId;
+			await persistCallRecord(ctx.storePath, next, ctx.stateRuntime);
+			Object.assign(callRecord, next);
 			ctx.providerCallIdMap.set(result.providerCallId, callId);
-			persistCallRecord(ctx.storePath, callRecord);
-		}
+		});
 		console.log(`[voice-call] Outbound call initiated: callId=${callId} providerCallId=${callRecord.providerCallId ?? result.providerCallId} mode=${mode} preConnectDtmf=${preConnectTwiml ? "yes" : "no"} initialMessage=${initialMessage ? "yes" : "no"}`);
 		return {
 			callId,
 			success: true
 		};
 	} catch (err) {
-		finalizeCall({
+		await ctx.mutationQueue.enqueue("state", () => finalizeCall({
 			ctx,
 			call: callRecord,
 			endReason: "failed"
-		});
+		}));
 		return {
 			callId,
 			success: false,
@@ -451,31 +488,49 @@ async function speak(ctx, callId, text, options) {
 		error: connected.error
 	};
 	const { call, providerCallId, provider } = connected;
+	let speakingCommitted = false;
 	try {
-		ensureMaxDurationTimerForLiveCall({
+		let startTimer = false;
+		speakingCommitted = await updateCall(ctx, call, (next) => {
+			if (!next.answeredAt) {
+				next.answeredAt = Date.now();
+				startTimer = true;
+			}
+			transitionState(next, "speaking");
+		}, options?.isCurrent);
+		if (options?.isCurrent) {
+			await ctx.mutationQueue.enqueue("state", async () => void 0);
+			if (!options.isCurrent()) throw new Error("Automatic reply superseded");
+		}
+		if (!speakingCommitted || !isCurrentCall(ctx, call)) return {
+			success: false,
+			error: "Call has ended"
+		};
+		if (ctx.isStopping()) throw new Error("Voice Call manager is stopping");
+		if (startTimer) startMaxDurationTimer({
 			ctx,
-			call,
-			liveAt: Date.now(),
+			callId,
 			onTimeout: (id) => endCall(ctx, id, { reason: "timeout" })
 		});
-		transitionState(call, "speaking");
-		persistCallRecord(ctx.storePath, call);
 		const numberRouteKey = resolveVoiceCallNumberRouteKeyForCall(call);
 		const voice = resolvePreferredTtsVoice(resolveVoiceCallEffectiveConfig(ctx.config, numberRouteKey).config);
 		const playbackOptions = options?.listenAfterPlayback ? { listenAfterPlayback: true } : {};
 		await provider.playTts({
 			callId,
-			providerCallId,
+			providerCallId: call.providerCallId ?? providerCallId,
 			text,
 			voice,
 			...playbackOptions
 		});
-		addTranscriptEntry(call, "bot", text);
-		persistCallRecord(ctx.storePath, call);
+		if (!await updateCall(ctx, call, (next) => addTranscriptEntry(next, "bot", text))) return {
+			success: false,
+			error: "Call has ended"
+		};
 		return { success: true };
 	} catch (err) {
-		transitionState(call, "listening");
-		persistCallRecord(ctx.storePath, call);
+		if (speakingCommitted) await updateCall(ctx, call, (next) => {
+			if (next.state === "speaking") transitionState(next, "listening");
+		});
 		return {
 			success: false,
 			error: formatErrorMessage(err)
@@ -544,30 +599,39 @@ async function speakInitialMessage(ctx, providerCallId) {
 			console.warn(`[voice-call] Failed to speak initial message: ${result.error}`);
 			return;
 		}
-		if (call.metadata) {
-			delete call.metadata.initialMessage;
-			persistCallRecord(ctx.storePath, call);
-		}
+		if (!await updateCall(ctx, call, (next) => {
+			if (next.metadata?.initialMessage === initialMessage) delete next.metadata.initialMessage;
+		}) || !isCurrentCall(ctx, call)) return;
+		if (ctx.isStopping()) throw new Error("Voice Call manager is stopping");
 		if (mode === "notify") {
 			const delaySec = ctx.config.outbound.notifyHangupDelaySec;
 			const delayMs = resolveVoiceCallSecondsTimerDelayMs(delaySec, 0);
 			console.log(`[voice-call] Notify mode: auto-hangup in ${delaySec}s for call ${call.callId}`);
-			setTimeout(() => {
-				(async () => {
-					const currentCall = ctx.activeCalls.get(call.callId);
-					if (currentCall && !TerminalStates.has(currentCall.state)) {
+			const previousTimer = ctx.notifyHangupTimers.get(call.callId);
+			if (previousTimer) clearTimeout(previousTimer);
+			const timer = setTimeout(() => {
+				if (ctx.notifyHangupTimers.get(call.callId) !== timer) return;
+				ctx.notifyHangupTimers.delete(call.callId);
+				const work = (async () => {
+					if (!ctx.isStopping() && isCurrentCall(ctx, call)) {
 						console.log(`[voice-call] Notify mode: hanging up call ${call.callId}`);
-						const endResult = await endCall(ctx, call.callId);
-						if (!endResult.success) console.warn(`[voice-call] Notify mode failed to hang up call ${call.callId}: ${endResult.error ?? "unknown error"}`);
+						try {
+							const endResult = await endCall(ctx, call.callId);
+							if (!endResult.success) console.warn(`[voice-call] Notify mode failed to hang up call ${call.callId}: ${endResult.error ?? "unknown error"}`);
+						} catch (error) {
+							console.warn(`[voice-call] Notify mode failed to hang up call ${call.callId}: ${formatErrorMessage(error)}`);
+						}
 					}
 				})();
+				ctx.trackCallWork(work);
 			}, delayMs);
+			ctx.notifyHangupTimers.set(call.callId, timer);
 		} else if (mode === "conversation" && ctx.provider && shouldStartListeningAfterInitialMessage(ctx)) {
-			transitionState(call, "listening");
-			persistCallRecord(ctx.storePath, call);
+			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({
 				callId: call.callId,
-				providerCallId
+				providerCallId: call.providerCallId ?? providerCallId
 			});
 		}
 	} finally {
@@ -591,14 +655,22 @@ async function continueCall(ctx, callId, prompt) {
 	try {
 		const speakResult = await speak(ctx, callId, prompt);
 		if (!speakResult.success) return speakResult;
-		transitionState(call, "listening");
-		persistCallRecord(ctx.storePath, call);
+		if (!await updateCall(ctx, call, (next) => transitionState(next, "listening")) || !isCurrentCall(ctx, call)) return {
+			success: false,
+			error: "Call has ended"
+		};
+		if (ctx.isStopping()) throw new Error("Voice Call manager is stopping");
 		const listenStartedAt = Date.now();
 		await provider.startListening({
 			callId,
-			providerCallId,
+			providerCallId: call.providerCallId ?? providerCallId,
 			turnToken
 		});
+		if (ctx.isStopping()) throw new Error("Voice Call manager is stopping");
+		if (!isCurrentCall(ctx, call)) return {
+			success: false,
+			error: "Call has ended"
+		};
 		const transcript = await waitForFinalTranscript(ctx, callId, turnToken);
 		const transcriptReceivedAt = Date.now();
 		await provider.stopListening({
@@ -607,15 +679,19 @@ async function continueCall(ctx, callId, prompt) {
 		});
 		const lastTurnLatencyMs = transcriptReceivedAt - turnStartedAt;
 		const lastTurnListenWaitMs = transcriptReceivedAt - listenStartedAt;
-		const turnCount = call.metadata && typeof call.metadata.turnCount === "number" ? call.metadata.turnCount + 1 : 1;
-		call.metadata = {
-			...call.metadata,
-			turnCount,
-			lastTurnLatencyMs,
-			lastTurnListenWaitMs,
-			lastTurnCompletedAt: transcriptReceivedAt
+		if (!await updateCall(ctx, call, (next) => {
+			const turnCount = typeof next.metadata?.turnCount === "number" ? next.metadata.turnCount + 1 : 1;
+			next.metadata = {
+				...next.metadata,
+				turnCount,
+				lastTurnLatencyMs,
+				lastTurnListenWaitMs,
+				lastTurnCompletedAt: transcriptReceivedAt
+			};
+		})) return {
+			success: false,
+			error: "Call has ended"
 		};
-		persistCallRecord(ctx.storePath, call);
 		console.log("[voice-call] continueCall latency call=" + call.callId + " totalMs=" + String(lastTurnLatencyMs) + " listenWaitMs=" + String(lastTurnListenWaitMs));
 		return {
 			success: true,
@@ -649,11 +725,11 @@ function endCall(ctx, callId, options) {
 				providerCallId,
 				reason
 			});
-			finalizeCall({
+			await ctx.mutationQueue.enqueue("state", () => finalizeCall({
 				ctx,
 				call,
 				endReason: reason
-			});
+			}));
 			return { success: true };
 		} catch (err) {
 			return {
@@ -695,7 +771,7 @@ function shouldAcceptInbound(config, from) {
 		default: return false;
 	}
 }
-function createWebhookCall(params) {
+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;
@@ -722,13 +798,13 @@ function createWebhookCall(params) {
 			...effective.numberRouteKey ? { numberRouteKey: effective.numberRouteKey } : {}
 		}
 	};
-	persistCallRecord(params.ctx.storePath, callRecord);
+	await persistCallRecord(params.ctx.storePath, callRecord, params.ctx.stateRuntime);
 	params.ctx.activeCalls.set(callId, callRecord);
 	params.ctx.providerCallIdMap.set(params.providerCallId, callId);
 	log.info(`Created ${params.direction} call record: ${callId} caller=${redactIdentifier(params.from)}`);
 	return callRecord;
 }
-function persistRejectedInboundCall(params) {
+async function persistRejectedInboundCall(params) {
 	const callId = params.event.callId || params.providerCallId;
 	const now = Date.now();
 	const rejectedCall = {
@@ -746,9 +822,12 @@ function persistRejectedInboundCall(params) {
 		processedEventIds: [params.dedupeKey],
 		metadata: { rejectionReason: "inbound-policy" }
 	};
-	persistCallRecord(params.ctx.storePath, rejectedCall);
+	await persistCallRecord(params.ctx.storePath, rejectedCall, params.ctx.stateRuntime);
 }
 function processEvent(ctx, event) {
+	return ctx.mutationQueue.enqueue("state", () => processEventInQueue(ctx, event));
+}
+async function processEventInQueue(ctx, event) {
 	const dedupeKey = event.dedupeKey || event.id;
 	if (ctx.processedEventIds.has(dedupeKey)) return { kind: "ignored" };
 	let call = findCall({
@@ -759,8 +838,8 @@ function processEvent(ctx, event) {
 	let providerCallId = event.providerCallId;
 	let retained;
 	if (!call) {
-		retained = findCallInStore(ctx.storePath, event.callId);
-		if (!retained && providerCallId && providerCallId !== event.callId) retained = findCallInStore(ctx.storePath, providerCallId);
+		retained = await findCallInStore(ctx.storePath, event.callId, ctx.stateRuntime);
+		if (!retained && providerCallId && providerCallId !== event.callId) retained = await findCallInStore(ctx.storePath, providerCallId, ctx.stateRuntime);
 		if (retained && retained.metadata?.rejectionReason !== "inbound-policy") {
 			call = ctx.activeCalls.get(retained.callId);
 			if (!call) return TerminalStates.has(retained.state) ? { kind: "ignored" } : {
@@ -770,7 +849,7 @@ function processEvent(ctx, event) {
 		}
 	}
 	if (call && providerCallId && providerCallId !== call.providerCallId) {
-		if ((providerCallId === event.callId && retained ? retained : findCallInStore(ctx.storePath, providerCallId))?.callId === call.callId) 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) {
@@ -782,17 +861,18 @@ function processEvent(ctx, event) {
 			}
 			if (ctx.rejectedProviderCallIds.has(pid)) return { kind: "ignored" };
 			const callId = event.callId ?? pid;
-			persistRejectedInboundCall({
+			await persistRejectedInboundCall({
 				ctx,
 				event,
 				dedupeKey,
 				providerCallId: pid
 			});
+			if (ctx.isStopping()) return { kind: "processed" };
 			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({
+			ctx.trackCallWork(ctx.provider.hangupCall({
 				callId,
 				providerCallId: pid,
 				reason: "hangup-bot"
@@ -800,10 +880,10 @@ function processEvent(ctx, event) {
 				releaseRejectedProviderCall(ctx.rejectedProviderCallIds, pid, rejectionReservation);
 				const message = formatErrorMessage(err);
 				log.warn(`Failed to reject inbound call ${pid}: ${message}`);
-			});
+			}));
 			return { kind: "processed" };
 		}
-		call = createWebhookCall({
+		call = await createWebhookCall({
 			ctx,
 			providerCallId,
 			direction: eventDirection === "outbound" ? "outbound" : "inbound",
@@ -816,16 +896,8 @@ function processEvent(ctx, event) {
 		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 activeCall = copyCallRecord(call);
+	const previousCall = { providerCallId: call.providerCallId };
 	const shouldCommitReplayKey = !(event.type === "call.error" && event.retryable);
 	const effects = [];
 	let result = { kind: "processed" };
@@ -849,123 +921,114 @@ function processEvent(ctx, event) {
 			if (ctx.providerCallIdMap.get(previousCall.providerCallId) === activeCall.callId) ctx.providerCallIdMap.delete(previousCall.providerCallId);
 		}
 	};
-	try {
-		if (providerCallId && providerCallId !== activeCall.providerCallId) activeCall.providerCallId = 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}`);
-					});
+	if (providerCallId && providerCallId !== activeCall.providerCallId) activeCall.providerCallId = 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;
+				ctx.trackCallWork(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;
+		}
+		case "call.ringing":
+			transitionState(activeCall, "ringing");
+			break;
+		case "call.answered":
+			activeCall.answeredAt = event.timestamp;
+			transitionState(activeCall, "answered");
+			effects.push(startDurationTimer, () => ctx.onCallAnswered?.(call));
+			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 && event.transcript.trim()) {
+				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);
+				const speechResult = {
+					kind: "final-speech",
+					call,
+					transcript: event.transcript,
+					waiterResolved: false
+				};
+				result = speechResult;
+				if (waiter) effects.push(() => {
+					if (ctx.transcriptWaiters.get(activeCall.callId) === waiter) speechResult.waiterResolved = resolveTranscriptWaiter(ctx, activeCall.callId, event.transcript, event.turnToken);
 				});
-				break;
 			}
-			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 && event.transcript.trim()) {
-					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);
-					});
-				}
-				if (event.transcript.trim()) effects.push(() => ctx.onCallerSpeech?.(activeCall));
-				prepareLiveDurationTimer();
-				transitionState(activeCall, "listening");
-				break;
-			case "call.silence":
-			case "call.dtmf": break;
-			case "call.ended":
-				finalizeCall({
+			if (event.transcript.trim()) effects.push(() => ctx.onCallerSpeech?.(call));
+			prepareLiveDurationTimer();
+			transitionState(activeCall, "listening");
+			break;
+		case "call.silence":
+		case "call.dtmf": break;
+		case "call.ended":
+			await finalizeCall({
+				ctx,
+				call,
+				preparedCall: activeCall,
+				endReason: event.reason,
+				endedAt: event.timestamp
+			});
+			publishProviderCallId(true);
+			rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
+			return { kind: "processed" };
+		case "call.error":
+			if (!event.retryable) {
+				await finalizeCall({
 					ctx,
-					call: activeCall,
-					endReason: event.reason,
-					endedAt: event.timestamp
+					call,
+					preparedCall: activeCall,
+					endReason: "error",
+					endedAt: event.timestamp,
+					transcriptRejectReason: `Call error: ${event.error}`
 				});
 				publishProviderCallId(true);
 				rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
 				return { kind: "processed" };
-			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
-				};
-		}
-		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;
+			}
+			result = {
+				kind: "processed",
+				replayable: true
+			};
 	}
-	for (const effect of effects) effect();
+	await persistCallRecord(ctx.storePath, activeCall, ctx.stateRuntime);
+	Object.assign(call, activeCall);
+	publishProviderCallId();
+	if (shouldCommitReplayKey) rememberManagerReplayKey(ctx.processedEventIds, dedupeKey);
+	if (!ctx.isStopping()) for (const effect of effects) effect();
 	return result;
 }
 //#endregion
@@ -1003,7 +1066,49 @@ function resolveDefaultStoreBase(config, storePath) {
 * Manages voice calls: state ownership and delegation to manager helper modules.
 */
 var CallManager = class {
-	constructor(config, storePath, coreSession) {
+	runOperation(operation) {
+		if (this.closing) return Promise.reject(/* @__PURE__ */ new Error("Voice Call manager is stopping"));
+		const pending = this.initialization ? this.initialization.then(() => {
+			if (this.closing) throw new Error("Voice Call manager is stopping");
+			return operation();
+		}) : operation();
+		this.trackCallWork(pending);
+		return pending;
+	}
+	/** Stop is owned by runtime shutdown, after webhook and stream producers have closed. */
+	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();
+		}
+		for (const waiter of this.transcriptWaiters.values()) {
+			clearTimeout(waiter.timeout);
+			waiter.reject(/* @__PURE__ */ new Error("Voice Call runtime stopped"));
+		}
+		this.transcriptWaiters.clear();
+		this.stopPromise = (async () => {
+			const failures = [];
+			while (this.pendingWork.size > 0) {
+				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();
+			}
+			if (failures.length > 0) throw new AggregateError(failures, "Voice Call work failed during shutdown");
+		})();
+		return this.stopPromise;
+	}
+	/** Serialize transient metadata with persisted updates without adding event-store writes. */
+	updateCallMetadata(call, update) {
+		return this.runOperation(() => this.mutationQueue.enqueue("state", async () => {
+			if (this.activeCalls.get(call.callId) === call && !TerminalStates.has(call.state)) call.metadata = update(call.metadata ? { ...call.metadata } : void 0);
+		}));
+	}
+	constructor(config, storePath, coreSession, stateRuntime) {
 		this.activeCalls = /* @__PURE__ */ new Map();
 		this.providerCallIdMap = /* @__PURE__ */ new Map();
 		this.processedEventIds = /* @__PURE__ */ new Set();
@@ -1016,25 +1121,48 @@ var CallManager = class {
 		this.maxDurationTimers = /* @__PURE__ */ new Map();
 		this.initialMessageInFlight = /* @__PURE__ */ new Set();
 		this.autoResponseOwners = /* @__PURE__ */ new WeakMap();
+		this.mutationQueue = new KeyedAsyncQueue();
+		this.pendingCallAdmissions = /* @__PURE__ */ new Set();
+		this.pendingWork = /* @__PURE__ */ new Set();
+		this.notifyHangupTimers = /* @__PURE__ */ new Map();
+		this.initialization = null;
+		this.closing = false;
+		this.stopPromise = null;
+		this.trackCallWork = (work) => {
+			this.pendingWork.add(work);
+			const settled = () => this.pendingWork.delete(work);
+			work.then(settled, settled);
+		};
 		this.config = config;
 		this.coreSession = coreSession;
 		this.storePath = resolveDefaultStoreBase(config, storePath);
+		this.stateRuntime = stateRuntime;
 	}
 	/**
 	* Initialize the call manager with a provider.
 	* Verifies persisted calls with the provider and restarts timers.
 	*/
-	async initialize(provider, webhookUrl) {
+	initialize(provider, webhookUrl) {
+		if (this.closing) return Promise.reject(/* @__PURE__ */ new Error("Voice Call manager is stopping"));
+		const pending = this.initializeFromStore(provider, webhookUrl);
+		this.initialization = pending;
+		this.trackCallWork(pending);
+		pending.then(() => {
+			if (this.initialization === pending) this.initialization = null;
+		}, () => {});
+		return pending;
+	}
+	async initializeFromStore(provider, webhookUrl) {
 		this.provider = provider;
 		this.webhookUrl = webhookUrl;
 		fs.mkdirSync(this.storePath, { recursive: true });
-		const persisted = loadActiveCallsFromStore(this.storePath);
+		const persisted = await loadActiveCallsFromStore(this.storePath, this.stateRuntime);
+		if (this.closing) return;
 		this.processedEventIds = persisted.processedEventIds;
 		this.rejectedProviderCallIds = /* @__PURE__ */ new Map();
 		const verified = await this.verifyRestoredCalls(provider, persisted.activeCalls);
-		this.activeCalls = verified;
-		this.providerCallIdMap = /* @__PURE__ */ new Map();
-		for (const [callId, call] of verified) if (call.providerCallId) this.providerCallIdMap.set(call.providerCallId, callId);
+		if (this.closing) return;
+		const timers = [];
 		let skippedAlreadyElapsedTimers = 0;
 		for (const [callId, call] of verified) {
 			const maxDurationAnchor = resolveRestoredMaxDurationAnchor(call);
@@ -1043,23 +1171,32 @@ var CallManager = class {
 				const maxDurationMs = resolveVoiceCallSecondsTimerDelayMs(this.config.maxDurationSeconds);
 				if (elapsed >= maxDurationMs) {
 					verified.delete(callId);
-					if (call.providerCallId) this.providerCallIdMap.delete(call.providerCallId);
 					skippedAlreadyElapsedTimers += 1;
 					continue;
 				}
 				if (call.answeredAt === void 0) {
 					call.answeredAt = maxDurationAnchor;
-					persistCallRecord(this.storePath, call);
+					await persistCallRecord(this.storePath, call, this.stateRuntime);
 				}
-				startMaxDurationTimer({
-					ctx: this.getContext(),
+				if (this.closing) return;
+				timers.push({
 					callId,
-					timeoutMs: maxDurationMs - elapsed,
-					onTimeout: (id) => this.endCall(id, { reason: "timeout" })
+					deadline: maxDurationAnchor + maxDurationMs
 				});
-				console.log(`[voice-call] Restarted max-duration timer for restored call ${callId}`);
 			}
 		}
+		this.activeCalls = verified;
+		this.providerCallIdMap = /* @__PURE__ */ new Map();
+		for (const [callId, call] of verified) if (call.providerCallId) this.providerCallIdMap.set(call.providerCallId, callId);
+		for (const { callId, deadline } of timers) {
+			startMaxDurationTimer({
+				ctx: this.getContext(),
+				callId,
+				timeoutMs: Math.max(0, deadline - Date.now()),
+				onTimeout: (id) => this.endCall(id, { reason: "timeout" })
+			});
+			console.log(`[voice-call] Restarted max-duration timer for restored call ${callId}`);
+		}
 		if (skippedAlreadyElapsedTimers > 0) console.log(`[voice-call] Skipped ${skippedAlreadyElapsedTimers} restored call(s) whose max-duration timer already elapsed`);
 		if (verified.size > 0) console.log(`[voice-call] Restored ${verified.size} active call(s) from store`);
 	}
@@ -1080,32 +1217,33 @@ var CallManager = class {
 		let keptVerifiedActive = 0;
 		let keptUnknownProviderStatus = 0;
 		let keptVerificationFailures = 0;
-		for (const [callId, call] of candidates) {
-			if (!call.providerCallId) {
-				skippedNoProviderCallId += 1;
-				continue;
-			}
-			if (now - call.startedAt > maxAgeMs) {
-				skippedOlderThanMaxDuration += 1;
-				markRestoredCallSkipped(call, "timeout");
-				persistCallRecord(this.storePath, call);
-				await provider.hangupCall({
-					callId,
-					providerCallId: call.providerCallId,
-					reason: "timeout"
-				}).catch((err) => {
-					console.warn(`[voice-call] Failed to hang up expired restored call ${callId}:`, err instanceof Error ? err.message : String(err));
-				});
-				continue;
-			}
-			const task = {
-				callId,
-				call,
-				promise: provider.getCallStatus({ providerCallId: call.providerCallId }).then((result) => {
+		let admissionFailure;
+		try {
+			for (const [callId, call] of candidates) {
+				if (this.closing) break;
+				if (!call.providerCallId) {
+					skippedNoProviderCallId += 1;
+					continue;
+				}
+				if (now - call.startedAt > maxAgeMs) {
+					skippedOlderThanMaxDuration += 1;
+					markRestoredCallSkipped(call, "timeout");
+					await persistCallRecord(this.storePath, call, this.stateRuntime);
+					if (this.closing) break;
+					await provider.hangupCall({
+						callId,
+						providerCallId: call.providerCallId,
+						reason: "timeout"
+					}).catch((err) => {
+						console.warn(`[voice-call] Failed to hang up expired restored call ${callId}:`, err instanceof Error ? err.message : String(err));
+					});
+					continue;
+				}
+				const task = provider.getCallStatus({ providerCallId: call.providerCallId }).then(async (result) => {
 					if (result.isTerminal) {
 						incrementRestoreStatusCount(skippedTerminalStatuses, result.status);
 						markRestoredCallSkipped(call, "completed");
-						persistCallRecord(this.storePath, call);
+						await persistCallRecord(this.storePath, call, this.stateRuntime);
 					} else if (result.isUnknown) {
 						keptUnknownProviderStatus += 1;
 						verified.set(callId, call);
@@ -1113,14 +1251,19 @@ var CallManager = class {
 						keptVerifiedActive += 1;
 						verified.set(callId, call);
 					}
-				}).catch(() => {
+				}, () => {
 					keptVerificationFailures += 1;
 					verified.set(callId, call);
-				})
-			};
-			verifyTasks.push(task);
+				});
+				task.catch(() => {});
+				verifyTasks.push(task);
+			}
+		} catch (error) {
+			admissionFailure = { error };
 		}
-		await Promise.allSettled(verifyTasks.map((t) => t.promise));
+		const outcomes = await Promise.allSettled(verifyTasks);
+		if (admissionFailure) throw admissionFailure.error;
+		for (const outcome of outcomes) if (outcome.status === "rejected") throw outcome.reason;
 		if (skippedNoProviderCallId > 0) console.log(`[voice-call] Skipped ${skippedNoProviderCallId} restored call(s) with no providerCallId`);
 		if (skippedOlderThanMaxDuration > 0) console.log(`[voice-call] Skipped ${skippedOlderThanMaxDuration} restored call(s) older than maxDurationSeconds`);
 		for (const [status, count] of [...skippedTerminalStatuses].toSorted(([a], [b]) => a.localeCompare(b))) console.log(`[voice-call] Skipped ${count} restored call(s) with provider status: ${status}`);
@@ -1139,40 +1282,45 @@ var CallManager = class {
 	* Initiate an outbound call.
 	*/
 	async initiateCall(to, sessionKey, options) {
-		return initiateCall(this.getContext(), to, sessionKey, options);
+		return this.runOperation(() => initiateCall(this.getContext(), to, sessionKey, options));
 	}
 	/**
 	* Speak to user in an active call.
 	*/
 	async speak(callId, text, options) {
-		return speak(this.getContext(), callId, text, options);
+		return this.runOperation(() => speak(this.getContext(), callId, text, options));
 	}
 	/**
 	* Send DTMF digits to an active call.
 	*/
 	async sendDtmf(callId, digits) {
-		return sendDtmf(this.getContext(), 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 speakInitialMessage(this.getContext(), providerCallId);
+		return this.runOperation(() => speakInitialMessage(this.getContext(), providerCallId));
 	}
 	/**
 	* Continue call: speak prompt, then wait for user's final transcript.
 	*/
 	async continueCall(callId, prompt) {
-		return continueCall(this.getContext(), callId, prompt);
+		return this.runOperation(() => continueCall(this.getContext(), callId, prompt));
 	}
 	/**
 	* End an active call.
 	*/
 	endCall(callId, options) {
-		return endCall(this.getContext(), callId, options);
+		return this.runOperation(() => endCall(this.getContext(), callId, options));
 	}
 	getContext() {
 		return {
+			mutationQueue: this.mutationQueue,
+			pendingCallAdmissions: this.pendingCallAdmissions,
+			trackCallWork: this.trackCallWork,
+			isStopping: () => this.closing,
+			notifyHangupTimers: this.notifyHangupTimers,
 			activeCalls: this.activeCalls,
 			providerCallIdMap: this.providerCallIdMap,
 			processedEventIds: this.processedEventIds,
@@ -1181,6 +1329,7 @@ var CallManager = class {
 			config: this.config,
 			coreSession: this.coreSession,
 			storePath: this.storePath,
+			stateRuntime: this.stateRuntime,
 			webhookUrl: this.webhookUrl,
 			activeTurnCalls: this.activeTurnCalls,
 			endCallOperations: this.endCallOperations,
@@ -1198,13 +1347,13 @@ var CallManager = class {
 	* Process a webhook event.
 	*/
 	processEvent(event) {
-		return processEvent(this.getContext(), event);
+		return this.runOperation(() => processEvent(this.getContext(), event));
 	}
 	createAutoResponseGuard(call) {
 		const owner = Symbol("automatic response");
 		this.autoResponseOwners.set(call, owner);
 		return {
-			isCurrent: () => this.activeCalls.get(call.callId) === call && !TerminalStates.has(call.state) && this.autoResponseOwners.get(call) === owner,
+			isCurrent: () => !this.closing && this.activeCalls.get(call.callId) === call && !TerminalStates.has(call.state) && this.autoResponseOwners.get(call) === owner,
 			release: () => {
 				if (this.autoResponseOwners.get(call) === owner) this.autoResponseOwners.delete(call);
 			}
@@ -1237,6 +1386,10 @@ var CallManager = class {
 	getCall(callId) {
 		return this.activeCalls.get(callId);
 	}
+	/** Await admitted identity updates before resolving a token-bound stream's active call. */
+	getCallForStream(callId) {
+		return this.runOperation(() => this.mutationQueue.enqueue("state", async () => this.closing ? void 0 : this.activeCalls.get(callId)));
+	}
 	/**
 	* Get an active call by provider call ID (e.g., Twilio CallSid).
 	*/
@@ -1257,13 +1410,13 @@ var CallManager = class {
 	async getCallFromMemoryOrStore(callId) {
 		const active = this.getCall(callId) ?? this.getCallByProviderCallId(callId);
 		if (active) return active;
-		return findCallInStore(this.storePath, callId);
+		return this.runOperation(() => findCallInStore(this.storePath, callId, this.stateRuntime));
 	}
 	/**
 	* Get call history (from persisted logs).
 	*/
 	async getCallHistory(limit = 50) {
-		return getCallHistoryFromStore(this.storePath, limit);
+		return this.runOperation(() => getCallHistoryFromStore(this.storePath, limit, this.stateRuntime));
 	}
 };
 //#endregion
@@ -2691,19 +2844,19 @@ var StreamDisconnectGrace = class {
 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_.js"));
-const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-DsdC88Xg.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)) : [];
+const loadRealtimeTranscriptionRuntime = createLazyRuntimeModule(() => import("./realtime-transcription.runtime-CbJAs5t_.mjs"));
+const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-hZyGIjO4.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)) : [];
 	recent.push({
 		at: event.timestamp,
 		type: event.type,
 		sessionId: event.sessionId,
 		turnId: event.turnId
 	});
-	call.metadata = {
-		...metadata,
+	return {
+		...previous,
 		lastTalkEventAt: event.timestamp,
 		lastTalkEventType: event.type,
 		recentTalkEvents: recent.slice(-10)
@@ -2772,6 +2925,7 @@ var VoiceCallWebhookServer = class {
 		this.stopStaleCallReaper = null;
 		this.webhookInFlightLimiter = createWebhookInFlightLimiter();
 		this.mediaStreamHandler = null;
+		this.streamSpeechGenerations = /* @__PURE__ */ new WeakMap();
 		this.realtimeHandler = null;
 		this.replayResponses = /* @__PURE__ */ new Map();
 		this.replayResponseCacheCalls = 0;
@@ -2858,8 +3012,11 @@ var VoiceCallWebhookServer = class {
 	interruptStreamReply(providerCallId, streamSid) {
 		const current = this.getCurrentStream(providerCallId, streamSid);
 		if (!current || this.shouldSuppressBargeInForInitialMessage(current.call)) return;
+		const generation = Symbol("stream speech");
+		this.streamSpeechGenerations.set(current.call, generation);
 		this.manager.invalidateAutoResponse(current.call);
 		current.provider.clearTtsQueue(providerCallId);
+		return generation;
 	}
 	/**
 	* Initialize media streaming with the selected realtime transcription provider.
@@ -2924,12 +3081,12 @@ var VoiceCallWebhookServer = class {
 					this.logger.info(`Ignoring transcript from inactive stream ${streamSid} (${providerCallId})`);
 					return;
 				}
-				const { call, provider: streamProvider } = current;
+				const { call } = current;
 				if (this.shouldSuppressBargeInForInitialMessage(call)) {
 					this.logger.info(`Ignoring barge transcript while initial message is still playing (${providerCallId})`);
 					return;
 				}
-				streamProvider.clearTtsQueue(providerCallId);
+				const generation = this.interruptStreamReply(providerCallId, streamSid);
 				const event = {
 					id: `stream-transcript-${Date.now()}`,
 					type: "call.speech",
@@ -2939,7 +3096,9 @@ var VoiceCallWebhookServer = class {
 					transcript,
 					isFinal: true
 				};
-				this.processEventWithAutoResponse(event);
+				this.processEventWithAutoResponse(event, () => this.streamSpeechGenerations.get(call) === generation && this.getCurrentStream(providerCallId, streamSid)?.call === call).catch((err) => {
+					this.logger.error(`Error processing stream transcript: ${String(err)}`);
+				});
 			},
 			onSpeechStart: (providerCallId, streamSid) => this.interruptStreamReply(providerCallId, streamSid),
 			onPartialTranscript: (callId, partial, streamSid) => {
@@ -2948,7 +3107,9 @@ var VoiceCallWebhookServer = class {
 			},
 			onTalkEvent: (providerCallId, streamSid, event) => {
 				const current = this.getCurrentStream(providerCallId, streamSid);
-				if (current) appendRecentTalkEventMetadata(current.call, event);
+				if (current) this.manager.updateCallMetadata(current.call, (metadata) => this.getCurrentStream(providerCallId, streamSid) ? appendRecentTalkEventMetadata(metadata, event) : metadata).catch((error) => {
+					this.logger.warn(`Failed to update stream call metadata: ${String(error)}`);
+				});
 			},
 			onConnect: (callId, streamSid) => {
 				this.logger.info(`Media stream connected: ${callId} -> ${streamSid}`);
@@ -3203,7 +3364,7 @@ var VoiceCallWebhookServer = class {
 					return this.realtimeHandler.buildTwiMLPayload(req, realtimeParams);
 				}
 				const parsed = this.provider.parseWebhookEvent(ctx, { verifiedRequestKey: verification.verifiedRequestKey });
-				if (!isReplay && this.processParsedEvents(parsed.events)) verification.releaseReplay?.();
+				if (!isReplay && await this.processParsedEvents(parsed.events)) verification.releaseReplay?.();
 				return normalizeWebhookResponse(parsed);
 			};
 			if (isReplay) return await buildResponse();
@@ -3317,20 +3478,20 @@ var VoiceCallWebhookServer = class {
 			default: return false;
 		}
 	}
-	processParsedEvents(events) {
+	async processParsedEvents(events) {
 		let replayable = false;
 		for (const event of events) try {
-			replayable = this.processEventWithAutoResponse(event) || replayable;
+			replayable = await 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);
+	async processEventWithAutoResponse(event, isCurrent) {
+		const result = await this.manager.processEvent(event);
 		if (result.kind !== "final-speech") return result.replayable === true;
-		if (result.waiterResolved) return false;
+		if (result.waiterResolved || isCurrent && !isCurrent()) return false;
 		const callMode = result.call.metadata?.mode;
 		if (result.call.direction !== "inbound" && callMode !== "conversation") return false;
 		this.handleInboundResponse(result.call.callId, result.transcript).catch((err) => {
@@ -3379,7 +3540,10 @@ var VoiceCallWebhookServer = class {
 				return false;
 			}
 			this.logger.info(`AI response queued ${callId} chars=${text.length}`);
-			return (await this.manager.speak(callId, text, { listenAfterPlayback: true })).success;
+			return (await this.manager.speak(callId, text, {
+				listenAfterPlayback: true,
+				isCurrent: response.isCurrent
+			})).success;
 		};
 		try {
 			const { generateVoiceResponse } = await loadResponseGeneratorModule();
@@ -3421,12 +3585,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-eCxGOUfA.js"));
-const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-DQKhnXXE.js"));
-const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-BsdFT1gS.js"));
-const loadMockProvider = createLazyRuntimeModule(() => import("./mock-C57qj18W.js"));
-const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.js"));
-const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-C7N4qzvf.js"));
+const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-BV56PXr-.mjs"));
+const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-BMb-7cu-.mjs"));
+const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-BGJda1Uz.mjs"));
+const loadMockProvider = createLazyRuntimeModule(() => import("./mock-CcYEAUhV.mjs"));
+const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.mjs"));
+const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-DlFmdSPn.mjs"));
 function resolveVoiceCallConsultSessionKey(call) {
 	return resolveVoiceCallSessionKey({
 		config: call.config,
@@ -3451,13 +3615,6 @@ function mapVoiceCallConsultTranscript(call, context) {
 function createRuntimeResourceLifecycle(params) {
 	let tunnelResult = null;
 	let stopPromise = null;
-	const runStep = async (step, suppressErrors) => {
-		if (suppressErrors) {
-			await step().catch(() => {});
-			return;
-		}
-		await step();
-	};
 	return {
 		setTunnelResult: (result) => {
 			tunnelResult = result;
@@ -3466,15 +3623,20 @@ function createRuntimeResourceLifecycle(params) {
 			if (stopPromise) return stopPromise;
 			const suppressErrors = opts?.suppressErrors ?? false;
 			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);
+				let failure;
+				for (const step of [
+					async () => {
+						await tunnelResult?.stop();
+					},
+					() => cleanupTailscaleExposure(params.config),
+					() => params.webhookServer.stop(),
+					() => params.manager.stop()
+				]) try {
+					await step();
+				} catch (error) {
+					failure ??= { error };
+				}
+				if (failure && !suppressErrors) throw failure.error;
 			})();
 			return stopPromise;
 		}
@@ -3587,7 +3749,7 @@ async function createVoiceCallRuntime(params) {
 	if (!validation.valid) throw new Error(`Invalid voice-call config: ${validation.errors.join("; ")}`);
 	const provider = await resolveProvider(config);
 	if (stateRuntime) setVoiceCallStateRuntime({ state: stateRuntime });
-	const manager = new CallManager(config, void 0, cfg.session);
+	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, fullConfig ?? coreConfig, agentRuntime, log);
 	if (realtimeVoiceRuntime) {
@@ -3609,12 +3771,15 @@ async function createVoiceCallRuntime(params) {
 				configuredProviderId: effectiveConfig.realtime.provider,
 				providerConfigs: effectiveConfig.realtime.providers,
 				cfg,
-				agentId
+				agentId,
+				surface: "gateway-relay",
+				useProviderDefaultModel: true
 			});
 			return {
 				agentId,
 				provider: resolved.provider,
 				providerConfig: resolved.providerConfig,
+				capabilities: resolved.capabilities,
 				instructions: resolveRealtimeInstructions(call)
 			};
 		};
@@ -3696,7 +3861,8 @@ async function createVoiceCallRuntime(params) {
 	}
 	const lifecycle = createRuntimeResourceLifecycle({
 		config,
-		webhookServer
+		webhookServer,
+		manager
 	});
 	const localUrl = await webhookServer.start();
 	try {