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

package/dist/{realtime-handler--i_OERv6.js → realtime-handler-uXR0QgVa.js}

@@ -1,10 +1,10 @@
-import { o as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-D0UJiLfi.js";
+import { o as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-F13eJ4pp.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, buildRealtimeVoiceAgentConsultWorkingResponse, calculateMulawRms, createRealtimeVoiceSessionHarness, createSpeechThresholdGate, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult } from "openclaw/plugin-sdk/realtime-voice";
 import { normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import { randomUUID } from "node:crypto";
+import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import "node:http";
 import WebSocket$1, { WebSocketServer } from "ws";
@@ -13,11 +13,13 @@ const TELEPHONY_SAMPLE_RATE = 8e3;
 const TELEPHONY_CHUNK_BYTES = 160;
 const TELEPHONY_CHUNK_MS = 20;
 const DEFAULT_MAX_QUEUED_AUDIO_BYTES = TELEPHONY_SAMPLE_RATE * 120;
+const QUEUE_COMPACT_HEAD_THRESHOLD = 256;
 /** Paces outgoing mulaw audio frames at telephony cadence. */
 var RealtimeAudioPacer = class {
 	constructor(params) {
 		this.params = params;
 		this.queue = [];
+		this.queueHead = 0;
 		this.timer = null;
 		this.queuedAudioBytes = 0;
 		this.closed = false;
@@ -55,7 +57,7 @@ var RealtimeAudioPacer = class {
 		if (this.closed) return 0;
 		const clearedAudioBytes = this.queuedAudioBytes;
 		this.clearTimer();
-		this.queue = [];
+		this.resetQueue();
 		this.queuedAudioBytes = 0;
 		this.params.send(this.params.serializer.clear());
 		return clearedAudioBytes;
@@ -68,7 +70,7 @@ var RealtimeAudioPacer = class {
 	close() {
 		this.closed = true;
 		this.clearTimer();
-		this.queue = [];
+		this.resetQueue();
 		this.queuedAudioBytes = 0;
 	}
 	/** Clear the scheduled pump timer. */
@@ -86,11 +88,33 @@ var RealtimeAudioPacer = class {
 		this.close();
 		this.params.onBackpressure?.();
 	}
+	get pendingQueueSize() {
+		return Math.max(0, this.queue.length - this.queueHead);
+	}
+	/** Take one queued item without shifting the remaining paced-audio backlog. */
+	takeNextItem() {
+		if (this.queueHead >= this.queue.length) {
+			this.resetQueue();
+			return;
+		}
+		const item = this.queue[this.queueHead];
+		this.queueHead += 1;
+		if (this.queueHead >= this.queue.length) this.resetQueue();
+		else if (this.queueHead > QUEUE_COMPACT_HEAD_THRESHOLD && this.queueHead * 2 > this.queue.length) {
+			this.queue.splice(0, this.queueHead);
+			this.queueHead = 0;
+		}
+		return item;
+	}
+	resetQueue() {
+		this.queue.length = 0;
+		this.queueHead = 0;
+	}
 	/** Send one queued item and schedule the next send based on audio duration. */
 	pump() {
 		this.timer = null;
 		if (this.closed) return;
-		const item = this.queue.shift();
+		const item = this.takeNextItem();
 		if (!item) return;
 		let delayMs = 0;
 		let sent;
@@ -100,11 +124,11 @@ var RealtimeAudioPacer = class {
 			delayMs = item.durationMs || TELEPHONY_CHUNK_MS;
 		} else sent = this.params.send(this.params.serializer.mark(item.name));
 		if (!sent) {
-			this.queue = [];
+			this.resetQueue();
 			this.queuedAudioBytes = 0;
 			return;
 		}
-		if (this.queue.length > 0) this.timer = setTimeout(() => this.pump(), delayMs);
+		if (this.pendingQueueSize > 0) this.timer = setTimeout(() => this.pump(), delayMs);
 	}
 };
 //#endregion
@@ -377,6 +401,12 @@ function buildForcedConsultSpeechPrompt(result) {
 		trimmed.length <= FORCED_CONSULT_RESULT_MAX_CHARS ? trimmed : `${truncateUtf16Safe(trimmed, FORCED_CONSULT_RESULT_MAX_CHARS - 16).trimEnd()} [truncated]`
 	].join("\n");
 }
+async function waitForNativeConsult(state) {
+	return await Promise.race([state.promise.then((result) => ({
+		kind: "completed",
+		result
+	})), state.cancellation.then(() => ({ kind: "cancelled" }))]);
+}
 function appendRecentTalkEventMetadata(call, event) {
 	if (!call) return;
 	const metadata = call.metadata ?? {};
@@ -410,15 +440,16 @@ var RealtimeCallHandler = class {
 		this.resolveInstructions = resolveInstructions;
 		this.toolHandlers = /* @__PURE__ */ new Map();
 		this.pendingStreamTokens = /* @__PURE__ */ new Map();
+		this.activeSockets = /* @__PURE__ */ new Set();
+		this.serverClosingSockets = /* @__PURE__ */ new WeakSet();
 		this.activeBridgesByCallId = /* @__PURE__ */ new Map();
 		this.activeTelephonyClosersByCallId = /* @__PURE__ */ new Map();
-		this.partialUserTranscriptsByCallId = /* @__PURE__ */ new Map();
-		this.rawPartialUserTranscriptsByCallId = /* @__PURE__ */ new Map();
-		this.partialUserTranscriptUpdatedAtByCallId = /* @__PURE__ */ new Map();
-		this.recentFinalUserTranscriptsByCallId = /* @__PURE__ */ new Map();
-		this.recentFinalUserTranscriptTimersByCallId = /* @__PURE__ */ new Map();
+		this.userTranscriptStatesByCallId = /* @__PURE__ */ new Map();
 		this.forcedConsultsByCallId = /* @__PURE__ */ new Map();
+		this.consultSessionsByCallId = /* @__PURE__ */ new Map();
 		this.nativeConsultsInFlightByCallId = /* @__PURE__ */ new Map();
+		this.closePromise = null;
+		this.closing = false;
 		this.publicOrigin = null;
 		this.publicPathPrefix = "";
 	}
@@ -464,6 +495,11 @@ var RealtimeCallHandler = class {
 		}
 	}
 	handleWebSocketUpgrade(request, socket, head) {
+		if (this.closing) {
+			socket.write("HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n");
+			socket.destroy();
+			return;
+		}
 		const token = new URL(request.url ?? "/", "wss://localhost").pathname.split("/").pop() ?? null;
 		const callerMeta = token ? this.consumeStreamToken(token) : null;
 		if (!callerMeta) {
@@ -476,6 +512,7 @@ var RealtimeCallHandler = class {
 			noServer: true,
 			maxPayload: MAX_REALTIME_MESSAGE_BYTES
 		}).handleUpgrade(request, socket, head, (ws) => {
+			this.activeSockets.add(ws);
 			let bridge = null;
 			let initialized = false;
 			let activeCallSid = "unknown";
@@ -530,13 +567,39 @@ var RealtimeCallHandler = class {
 				}
 			});
 			ws.on("close", (code) => {
-				const reason = stopReceived || code === 1e3 || code === 1005 ? "completed" : "error";
+				this.activeSockets.delete(ws);
+				const reason = this.serverClosingSockets.has(ws) || stopReceived || code === 1e3 || code === 1005 ? "completed" : "error";
 				this.closeTelephonyBridge(activeCallSid, bridge, reason);
 			});
 			ws.on("error", (error) => {
 				console.error("[voice-call] realtime WS error:", error);
 			});
+			if (this.closing) {
+				this.serverClosingSockets.add(ws);
+				ws.terminate();
+			}
+		});
+	}
+	close(shutdownBarrier = Promise.resolve()) {
+		if (this.closePromise) return this.closePromise;
+		this.closing = true;
+		this.pendingStreamTokens.clear();
+		const sockets = [...this.activeSockets];
+		this.closePromise = Promise.all([shutdownBarrier, ...sockets.map((ws) => new Promise((resolve) => {
+			if (ws.readyState === WebSocket$1.CLOSED) {
+				resolve();
+				return;
+			}
+			this.serverClosingSockets.add(ws);
+			ws.once("close", () => resolve());
+			ws.terminate();
+		}))]).then(() => {
+			this.pendingStreamTokens.clear();
+		}).finally(() => {
+			this.closing = false;
+			this.closePromise = null;
 		});
+		return this.closePromise;
 	}
 	registerToolHandler(name, fn) {
 		this.toolHandlers.set(name, fn);
@@ -669,6 +732,14 @@ var RealtimeCallHandler = class {
 			if (callEndEmitted) return;
 			callEndEmitted = true;
 			this.endCallInManager(callSid, callId, reason);
+			if (reason !== "error") return;
+			Promise.resolve(this.provider.hangupCall({
+				callId,
+				providerCallId: callSid,
+				reason
+			})).catch((error) => {
+				console.warn(`[voice-call] Failed to hang up realtime call ${callSid}: ${formatErrorMessage(error)}`);
+			});
 		};
 		const sendString = (message) => {
 			if (ws.readyState !== WebSocket$1.OPEN) return false;
@@ -703,7 +774,11 @@ var RealtimeCallHandler = class {
 			silenceFrames: 12
 		});
 		const interruptResponseOnInputAudio = typeof this.providerConfig.interruptResponseOnInputAudio === "boolean" ? this.providerConfig.interruptResponseOnInputAudio : void 0;
-		const session = harness.createBridge({
+		const hadPredecessorOnAdmission = this.activeBridgesByCallId.has(callId);
+		const nativeConsultOwner = {};
+		const userTranscriptAdoption = this.beginUserTranscriptOwnerAdoption(callId);
+		const userTranscriptOwner = userTranscriptAdoption.owner;
+		const bridgeParams = {
 			provider: this.realtimeProvider,
 			cfg: this.coreConfig,
 			providerConfig: this.providerConfig,
@@ -734,6 +809,8 @@ var RealtimeCallHandler = class {
 				}
 			},
 			onTranscript: (role, text, isFinal) => {
+				const owner = nativeConsultOwner.current;
+				if (!this.getUserTranscriptState(callId, userTranscriptOwner) || owner && !this.isActiveBridgeOwner(callId, owner)) return;
 				const turnId = harness.ensureTurn();
 				const eventType = role === "assistant" ? isFinal ? "output.text.done" : "output.text.delta" : isFinal ? "transcript.done" : "transcript.delta";
 				const payload = role === "assistant" ? { text } : {
@@ -757,19 +834,22 @@ var RealtimeCallHandler = class {
 				});
 				if (!isFinal) {
 					if (role === "user" && text.trim()) {
-						const transcript = this.recordPartialUserTranscript(callId, text);
+						const transcript = this.recordPartialUserTranscript(callId, userTranscriptOwner, text);
+						if (!transcript) return;
 						console.log(`[voice-call] realtime input transcript callId=${callId} providerCallId=${callSid} final=false chars=${text.trim().length} aggregateChars=${transcript.length}`);
 					}
 					return;
 				}
 				if (role === "user") {
+					const state = this.getUserTranscriptState(callId, userTranscriptOwner);
+					if (!state) return;
 					const transcript = resolveFinalTranscriptText({
-						partial: this.partialUserTranscriptsByCallId.get(callId),
-						rawPartial: this.rawPartialUserTranscriptsByCallId.get(callId),
+						partial: state.partial,
+						rawPartial: state.rawPartial,
 						final: text
 					});
-					this.clearPartialUserTranscript(callId);
-					this.setRecentFinalUserTranscript(callId, transcript);
+					this.clearPartialUserTranscript(callId, userTranscriptOwner);
+					this.setRecentFinalUserTranscript(callId, userTranscriptOwner, transcript);
 					console.log(`[voice-call] realtime input transcript callId=${callId} providerCallId=${callSid} final=true chars=${text.trim().length} aggregateChars=${transcript.length}`);
 					const event = {
 						id: `realtime-speech-${callSid}-${Date.now()}`,
@@ -787,6 +867,7 @@ var RealtimeCallHandler = class {
 						callId,
 						callSid,
 						transcript,
+						userTranscriptOwner,
 						clearAudio: () => {
 							const clearedBytes = audioPacer.clearAudio();
 							console.log(`[voice-call] realtime forced consult cleared outbound audio callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
@@ -816,9 +897,30 @@ var RealtimeCallHandler = class {
 					}
 				});
 				console.log(`[voice-call] realtime tool call received callId=${callId} providerCallId=${callSid} tool=${toolEvent.name}`);
-				return this.executeToolCall(sessionLocal, callId, toolEvent.callId || toolEvent.itemId, toolEvent.name, toolEvent.args, turnId, harness);
+				return this.executeToolCall(sessionLocal, callId, toolEvent.callId || toolEvent.itemId, toolEvent.name, toolEvent.args, turnId, harness, userTranscriptOwner);
 			},
 			onEvent: (event) => {
+				if (event.direction === "client" && event.type === "session.continuity.reset") {
+					const turnId = harness.talk.activeTurnId;
+					const owner = nativeConsultOwner.current;
+					if (owner && this.isActiveBridgeOwner(callId, owner)) {
+						this.resetUserTranscriptState(callId, userTranscriptOwner);
+						this.resetConsultSessionForContinuity(callId, owner);
+					}
+					harness.flushOutput(() => {
+						audioPacer.clearAudio();
+						harness.finishOutputAudio(event.type);
+					});
+					if (turnId) harness.talk.cancelTurn({
+						turnId,
+						payload: {
+							callId,
+							providerCallId: callSid,
+							reason: event.type
+						}
+					});
+					return;
+				}
 				if (event.type === "input_audio_buffer.speech_started") {
 					harness.ensureTurn();
 					return;
@@ -838,17 +940,15 @@ var RealtimeCallHandler = class {
 					});
 					return;
 				}
-				if (event.type === "response.done") {
-					harness.finishOutputAudio("response.done");
-					harness.endTurn("response.done");
-					return;
-				}
 				if (event.type === "error") harness.emit({
 					type: "session.error",
 					payload: { message: event.detail ?? "Realtime provider error" },
 					final: true
 				});
 			},
+			onResponseDone: (outcome) => {
+				if (outcome.status === "failed" || outcome.status === "incomplete") console.warn(`[voice-call] realtime response ${outcome.status}: ${outcome.message}`);
+			},
 			onReady: () => {
 				harness.emit({
 					type: "session.ready",
@@ -867,11 +967,13 @@ var RealtimeCallHandler = class {
 				});
 			},
 			onClose: (reason) => {
-				this.activeBridgesByCallId.delete(callId);
-				this.activeBridgesByCallId.delete(callSid);
-				this.activeTelephonyClosersByCallId.delete(callId);
-				this.activeTelephonyClosersByCallId.delete(callSid);
-				this.clearUserTranscriptState(callId);
+				const owner = nativeConsultOwner.current;
+				const ownsCallState = owner ? this.isActiveBridgeOwner(callId, owner) : false;
+				if (owner) {
+					this.clearActiveBridgeMappings(callId, callSid, owner);
+					this.cancelConsultSession(callId, owner);
+				}
+				if (ownsCallState) this.clearUserTranscriptState(callId, userTranscriptOwner);
 				harness.finishOutputAudio(reason);
 				harness.emit({
 					type: "session.closed",
@@ -879,17 +981,25 @@ var RealtimeCallHandler = class {
 					final: true
 				});
 				if (reason !== "error") return;
-				emitCallEnd("error");
 				if (ws.readyState === WebSocket$1.OPEN) ws.close(1011, "Bridge disconnected");
-				this.provider.hangupCall({
-					callId,
-					providerCallId: callSid,
-					reason: "error"
-				}).catch((error) => {
-					console.warn(`[voice-call] Failed to hang up realtime call ${callSid}: ${formatErrorMessage(error)}`);
-				});
+				if (owner && !ownsCallState || !owner && hadPredecessorOnAdmission && this.activeBridgesByCallId.has(callId)) return;
+				emitCallEnd("error");
 			}
-		});
+		};
+		let session;
+		try {
+			session = harness.createBridge(bridgeParams);
+		} catch (error) {
+			this.rollbackUserTranscriptOwnerAdoption(callId, userTranscriptAdoption);
+			harness.close();
+			audioPacer.close();
+			if (!hadPredecessorOnAdmission || !this.activeBridgesByCallId.has(callId)) emitCallEnd("error");
+			if (ws.readyState === WebSocket$1.OPEN) ws.close(1011, "Failed to create realtime bridge");
+			console.error("[voice-call] Failed to create realtime bridge:", error);
+			return null;
+		}
+		this.commitUserTranscriptOwnerAdoption(callId, userTranscriptAdoption);
+		nativeConsultOwner.current = session;
 		providerHandlesInputAudioBargeIn = session.bridge.handlesInputAudioBargeIn ?? providerHandlesInputAudioBargeIn;
 		const closeTelephony = (reason) => {
 			try {
@@ -898,10 +1008,20 @@ var RealtimeCallHandler = class {
 				emitCallEnd(reason);
 			}
 		};
+		const previousConsultSession = this.consultSessionsByCallId.get(callId);
+		if (previousConsultSession && previousConsultSession.owner !== session) this.cancelConsultSession(callId, previousConsultSession.owner);
+		this.consultSessionsByCallId.set(callId, {
+			owner: session,
+			coordinator: harness.forcedConsults
+		});
 		this.activeBridgesByCallId.set(callId, session);
 		this.activeBridgesByCallId.set(callSid, session);
-		this.activeTelephonyClosersByCallId.set(callId, closeTelephony);
-		this.activeTelephonyClosersByCallId.set(callSid, closeTelephony);
+		const telephonyCloser = {
+			owner: session,
+			close: closeTelephony
+		};
+		this.activeTelephonyClosersByCallId.set(callId, telephonyCloser);
+		this.activeTelephonyClosersByCallId.set(callSid, telephonyCloser);
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
 			if (speechDetector.accept({
@@ -924,86 +1044,181 @@ var RealtimeCallHandler = class {
 			try {
 				closeSession();
 			} finally {
-				this.activeBridgesByCallId.delete(callId);
-				this.activeBridgesByCallId.delete(callSid);
-				this.activeTelephonyClosersByCallId.delete(callId);
-				this.activeTelephonyClosersByCallId.delete(callSid);
-				this.clearUserTranscriptState(callId);
-				this.forcedConsultsByCallId.delete(callId);
+				this.clearActiveBridgeMappings(callId, callSid, session);
+				this.cancelConsultSession(callId, session);
+				this.clearUserTranscriptState(callId, userTranscriptOwner);
 				harness.close();
 				audioPacer.close();
 			}
 		};
 		session.connect().catch((error) => {
 			console.error("[voice-call] Failed to connect realtime bridge:", error);
-			session.close();
-			emitCallEnd("error");
-			ws.close(1011, "Failed to connect");
+			const ownsCallState = this.isActiveBridgeOwner(callId, session);
+			try {
+				session.close();
+			} catch (closeError) {
+				console.warn(`[voice-call] Failed to close realtime bridge ${callSid}: ${formatErrorMessage(closeError)}`);
+			} finally {
+				if (ownsCallState) emitCallEnd("error");
+				ws.close(1011, "Failed to connect");
+			}
 		});
 		return session;
 	}
-	recordPartialUserTranscript(callId, text) {
-		const next = limitPartialUserTranscript(appendTranscriptText(this.partialUserTranscriptsByCallId.get(callId), text));
-		const raw = limitPartialUserTranscript(`${this.rawPartialUserTranscriptsByCallId.get(callId) ?? ""}${text}`);
-		this.partialUserTranscriptsByCallId.set(callId, next);
-		this.rawPartialUserTranscriptsByCallId.set(callId, raw);
-		this.partialUserTranscriptUpdatedAtByCallId.set(callId, Date.now());
+	beginUserTranscriptOwnerAdoption(callId) {
+		const adoption = {
+			owner: {},
+			previous: this.userTranscriptStatesByCallId.get(callId)
+		};
+		this.userTranscriptStatesByCallId.set(callId, adoption.owner);
+		return adoption;
+	}
+	commitUserTranscriptOwnerAdoption(callId, adoption) {
+		if (this.userTranscriptStatesByCallId.get(callId) !== adoption.owner) return;
+		if (adoption.previous?.recentFinalTimer) {
+			clearTimeout(adoption.previous.recentFinalTimer);
+			adoption.previous.recentFinalTimer = void 0;
+		}
+	}
+	rollbackUserTranscriptOwnerAdoption(callId, adoption) {
+		if (this.userTranscriptStatesByCallId.get(callId) !== adoption.owner) return;
+		if (adoption.owner.recentFinalTimer) {
+			clearTimeout(adoption.owner.recentFinalTimer);
+			adoption.owner.recentFinalTimer = void 0;
+		}
+		if (adoption.previous) {
+			this.userTranscriptStatesByCallId.set(callId, adoption.previous);
+			return;
+		}
+		this.userTranscriptStatesByCallId.delete(callId);
+	}
+	getUserTranscriptState(callId, owner) {
+		const state = this.userTranscriptStatesByCallId.get(callId);
+		return state === owner ? state : void 0;
+	}
+	recordPartialUserTranscript(callId, owner, text) {
+		const state = this.getUserTranscriptState(callId, owner);
+		if (!state) return;
+		const next = limitPartialUserTranscript(appendTranscriptText(state.partial, text));
+		const raw = limitPartialUserTranscript(`${state.rawPartial ?? ""}${text}`);
+		state.partial = next;
+		state.rawPartial = raw;
+		state.partialUpdatedAt = Date.now();
 		return next;
 	}
-	clearPartialUserTranscript(callId) {
-		this.partialUserTranscriptsByCallId.delete(callId);
-		this.rawPartialUserTranscriptsByCallId.delete(callId);
-		this.partialUserTranscriptUpdatedAtByCallId.delete(callId);
+	clearPartialUserTranscript(callId, owner) {
+		const state = this.getUserTranscriptState(callId, owner);
+		if (!state) return;
+		state.partial = void 0;
+		state.rawPartial = void 0;
+		state.partialUpdatedAt = void 0;
 	}
-	setRecentFinalUserTranscript(callId, text) {
-		this.clearRecentFinalUserTranscript(callId);
-		this.recentFinalUserTranscriptsByCallId.set(callId, text);
+	setRecentFinalUserTranscript(callId, owner, text) {
+		const state = this.getUserTranscriptState(callId, owner);
+		if (!state) return;
+		this.clearRecentFinalUserTranscript(callId, owner);
+		state.recentFinal = text;
 		const timer = setTimeout(() => {
-			if (this.recentFinalUserTranscriptsByCallId.get(callId) === text) this.recentFinalUserTranscriptsByCallId.delete(callId);
-			this.recentFinalUserTranscriptTimersByCallId.delete(callId);
+			if (this.userTranscriptStatesByCallId.get(callId) !== state) return;
+			if (state.recentFinal === text) state.recentFinal = void 0;
+			if (state.recentFinalTimer === timer) state.recentFinalTimer = void 0;
 		}, RECENT_FINAL_USER_TRANSCRIPT_TTL_MS);
 		timer.unref?.();
-		this.recentFinalUserTranscriptTimersByCallId.set(callId, timer);
+		state.recentFinalTimer = timer;
 	}
-	clearRecentFinalUserTranscript(callId) {
-		const timer = this.recentFinalUserTranscriptTimersByCallId.get(callId);
-		if (timer) {
-			clearTimeout(timer);
-			this.recentFinalUserTranscriptTimersByCallId.delete(callId);
+	clearRecentFinalUserTranscript(callId, owner) {
+		const state = this.getUserTranscriptState(callId, owner);
+		if (!state) return;
+		if (state.recentFinalTimer) {
+			clearTimeout(state.recentFinalTimer);
+			state.recentFinalTimer = void 0;
 		}
-		this.recentFinalUserTranscriptsByCallId.delete(callId);
+		state.recentFinal = void 0;
+	}
+	resetUserTranscriptState(callId, owner) {
+		this.clearPartialUserTranscript(callId, owner);
+		this.clearRecentFinalUserTranscript(callId, owner);
+	}
+	clearUserTranscriptState(callId, owner) {
+		const state = this.getUserTranscriptState(callId, owner);
+		if (!state) return;
+		if (state.recentFinalTimer) clearTimeout(state.recentFinalTimer);
+		if (this.userTranscriptStatesByCallId.get(callId) === state) this.userTranscriptStatesByCallId.delete(callId);
+	}
+	cancelNativeConsult(callId, owner) {
+		const state = this.nativeConsultsInFlightByCallId.get(callId);
+		if (!state || state.owner !== owner) return;
+		state.cancelled = true;
+		this.nativeConsultsInFlightByCallId.delete(callId);
+		state.cancel();
+	}
+	cancelForcedConsult(callId, owner) {
+		const state = this.forcedConsultsByCallId.get(callId);
+		if (!state || state.owner !== owner) return;
+		state.cancelled = true;
+		state.sendSpeechPrompt = false;
+		state.cancel();
+		this.forcedConsultsByCallId.delete(callId);
+	}
+	resetConsultSession(callId, owner) {
+		const session = this.consultSessionsByCallId.get(callId);
+		if (!session || session.owner !== owner) return false;
+		session.coordinator.clearPending();
+		this.cancelForcedConsult(callId, owner);
+		this.cancelNativeConsult(callId, owner);
+		return true;
+	}
+	resetConsultSessionForContinuity(callId, owner) {
+		const session = this.consultSessionsByCallId.get(callId);
+		if (!session || session.owner !== owner) return false;
+		this.cancelForcedConsult(callId, owner);
+		this.cancelNativeConsult(callId, owner);
+		session.coordinator.clear();
+		return true;
+	}
+	cancelConsultSession(callId, owner) {
+		if (!owner || !this.resetConsultSession(callId, owner)) return;
+		this.consultSessionsByCallId.delete(callId);
+	}
+	isActiveBridgeOwner(callId, owner) {
+		return this.activeBridgesByCallId.get(callId) === owner;
 	}
-	clearUserTranscriptState(callId) {
-		this.clearPartialUserTranscript(callId);
-		this.clearRecentFinalUserTranscript(callId);
+	clearActiveBridgeMappings(callId, callSid, owner) {
+		for (const key of [callId, callSid]) {
+			if (this.activeBridgesByCallId.get(key) !== owner) continue;
+			this.activeBridgesByCallId.delete(key);
+			this.activeTelephonyClosersByCallId.delete(key);
+		}
 	}
-	resolveUserTranscriptContext(callId) {
-		return this.partialUserTranscriptsByCallId.get(callId) ?? this.recentFinalUserTranscriptsByCallId.get(callId);
+	resolveUserTranscriptContext(callId, owner) {
+		const state = this.getUserTranscriptState(callId, owner);
+		return state?.partial ?? state?.recentFinal;
 	}
-	consumePartialUserTranscript(callId, consumed) {
+	consumePartialUserTranscript(callId, owner, consumed) {
 		const text = consumed?.trim();
 		if (!text) return;
-		const current = this.partialUserTranscriptsByCallId.get(callId);
+		const state = this.getUserTranscriptState(callId, owner);
+		const current = state?.partial;
 		if (!current) return;
 		if (current === text) {
-			this.clearPartialUserTranscript(callId);
+			this.clearPartialUserTranscript(callId, owner);
 			return;
 		}
 		if (current.toLowerCase().startsWith(text.toLowerCase())) {
 			const remaining = current.slice(text.length).trimStart();
 			if (remaining) {
-				this.partialUserTranscriptsByCallId.set(callId, remaining);
-				this.rawPartialUserTranscriptsByCallId.set(callId, remaining);
-			} else this.clearPartialUserTranscript(callId);
+				state.partial = remaining;
+				state.rawPartial = remaining;
+			} else this.clearPartialUserTranscript(callId, owner);
 		}
-		const recent = this.recentFinalUserTranscriptsByCallId.get(callId);
+		const recent = state.recentFinal;
 		if (!recent) return;
-		if (recent === text || recent.toLowerCase().startsWith(text.toLowerCase())) this.clearRecentFinalUserTranscript(callId);
+		if (recent === text || recent.toLowerCase().startsWith(text.toLowerCase())) this.clearRecentFinalUserTranscript(callId, owner);
 	}
-	async waitForConsultTranscriptSettle(callId, startedAt) {
+	async waitForConsultTranscriptSettle(callId, owner, startedAt) {
 		const deadline = startedAt + CONSULT_TRANSCRIPT_SETTLE_MAX_MS;
 		while (true) {
-			const updatedAt = this.partialUserTranscriptUpdatedAtByCallId.get(callId);
+			const updatedAt = this.getUserTranscriptState(callId, owner)?.partialUpdatedAt;
 			if (!updatedAt) return;
 			const now = Date.now();
 			const quietFor = now - updatedAt;
@@ -1015,14 +1230,14 @@ var RealtimeCallHandler = class {
 	}
 	closeTelephonyBridge(callIdOrSid, bridge, reason) {
 		const closer = this.activeTelephonyClosersByCallId.get(callIdOrSid);
-		if (closer) {
-			closer(reason);
+		if (closer && closer.owner === bridge) {
+			closer.close(reason);
 			return;
 		}
 		bridge?.close();
 	}
 	scheduleForcedAgentConsult(params) {
-		if (this.config.consultPolicy !== "always") return;
+		if (this.config.consultPolicy !== "always" || this.activeBridgesByCallId.get(params.callId) !== params.session) return;
 		const question = params.transcript.trim();
 		if (!question) return;
 		const handler = this.toolHandlers.get(REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME);
@@ -1051,13 +1266,24 @@ var RealtimeCallHandler = class {
 		logger.debug(`[voice-call] realtime forced agent consult reason=${FORCED_CONSULT_REASON} consultPolicy=always callId=${params.callId} providerCallId=${params.callSid} chars=${params.handle.question.length}`);
 		console.log(`[voice-call] realtime forced agent consult starting callId=${params.callId} providerCallId=${params.callSid} chars=${params.handle.question.length}`);
 		params.clearAudio();
+		const abortController = new AbortController();
 		const state = {
+			owner: params.session,
 			sendSpeechPrompt: true,
-			promise: Promise.resolve().then(() => params.handler({ question: params.handle.question }, params.callId, {}))
+			cancelled: false,
+			cancel: () => {
+				abortController.abort(/* @__PURE__ */ new Error("Realtime forced consult owner was cancelled."));
+				coordinator.markCancelled(params.handle);
+			},
+			promise: Promise.resolve().then(() => {
+				abortController.signal.throwIfAborted();
+				return params.handler({ question: params.handle.question }, params.callId, { abortSignal: abortController.signal });
+			})
 		};
 		this.forcedConsultsByCallId.set(params.callId, state);
 		try {
 			const result = await state.promise;
+			if (state.cancelled || this.forcedConsultsByCallId.get(params.callId) !== state) return;
 			state.completedAt = Date.now();
 			coordinator.markDelivered(params.handle);
 			const text = readSpeakableRealtimeVoiceToolResult(result, {
@@ -1073,11 +1299,12 @@ var RealtimeCallHandler = class {
 				params.session.sendUserMessage(buildForcedConsultSpeechPrompt(text));
 			}
 			console.log(`[voice-call] realtime forced agent consult completed callId=${params.callId} providerCallId=${params.callSid} elapsedMs=${Date.now() - startedAt}`);
-			this.consumePartialUserTranscript(params.callId, params.handle.question);
+			this.consumePartialUserTranscript(params.callId, params.userTranscriptOwner, params.handle.question);
 		} catch (error) {
-			console.warn(`[voice-call] realtime forced agent consult failed callId=${params.callId} providerCallId=${params.callSid} error=${formatErrorMessage(error)}`);
+			if (!state.cancelled) console.warn(`[voice-call] realtime forced agent consult failed callId=${params.callId} providerCallId=${params.callSid} error=${formatErrorMessage(error)}`);
 		} finally {
-			setTimeout(() => {
+			if (!state.cancelled) if (this.forcedConsultsByCallId.get(params.callId) !== state) coordinator.remove(params.handle);
+			else setTimeout(() => {
 				if (this.forcedConsultsByCallId.get(params.callId) === state) {
 					this.forcedConsultsByCallId.delete(params.callId);
 					coordinator.remove(params.handle);
@@ -1137,7 +1364,7 @@ var RealtimeCallHandler = class {
 			reason
 		});
 	}
-	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness) {
+	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness, userTranscriptOwner) {
 		const handler = this.toolHandlers.get(name);
 		const startedAt = Date.now();
 		const hasResultError = (result) => {
@@ -1174,13 +1401,15 @@ var RealtimeCallHandler = class {
 			}
 		};
 		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
+			if (this.activeBridgesByCallId.get(callId) !== bridge) return;
 			const coordinator = harness.forcedConsults;
 			const forcedMatch = coordinator.recordNativeConsult(args, bridgeCallId);
 			if (forcedMatch.kind === "none") {
 				const pending = coordinator.consumePending();
 				if (pending) coordinator.remove(pending);
 			}
-			const forcedConsult = this.forcedConsultsByCallId.get(callId);
+			const forcedConsultState = this.forcedConsultsByCallId.get(callId);
+			const forcedConsult = forcedConsultState?.owner === bridge && !forcedConsultState.cancelled ? forcedConsultState : void 0;
 			if (forcedMatch.kind === "already_delivered" && coordinator.isCancelled(forcedMatch.handle)) {
 				if (forcedConsult) forcedConsult.sendSpeechPrompt = false;
 				await submitFinalToolResult({
@@ -1198,24 +1427,50 @@ var RealtimeCallHandler = class {
 					return;
 				}
 				forcedConsult.sendSpeechPrompt = false;
-				await submitFinalToolResult(await forcedConsult.promise.catch((error) => ({ error: formatErrorMessage(error) })));
+				const result = await forcedConsult.promise.catch((error) => ({ error: formatErrorMessage(error) }));
+				if (forcedConsult.cancelled || forcedConsult.owner !== bridge || this.forcedConsultsByCallId.get(callId) !== forcedConsult) return;
+				await submitFinalToolResult(result);
 				return;
 			}
 			const existingNativeConsult = this.nativeConsultsInFlightByCallId.get(callId);
 			if (existingNativeConsult) {
 				console.log(`[voice-call] realtime tool call sharing in-flight agent consult callId=${callId} ageMs=${Date.now() - existingNativeConsult.startedAt}`);
 				await submitWorkingResponse();
-				await submitFinalToolResult(await existingNativeConsult.promise);
+				const outcome = await waitForNativeConsult(existingNativeConsult);
+				if (outcome.kind === "cancelled") return;
+				await submitFinalToolResult(outcome.result);
 				return;
 			}
+			const abortController = new AbortController();
+			let releaseCancellation = () => {};
+			const cancellation = new Promise((resolve) => {
+				releaseCancellation = resolve;
+			});
+			let completeConsult = (_result) => {};
 			const state = {
+				owner: bridge,
 				startedAt,
-				promise: Promise.resolve()
+				promise: new Promise((resolve) => {
+					completeConsult = resolve;
+				}),
+				cancellation,
+				cancelled: false,
+				cancel: () => {
+					abortController.abort(/* @__PURE__ */ new Error("Realtime native consult owner was cancelled."));
+					releaseCancellation();
+				}
 			};
-			state.promise = submitWorkingResponse().then(async () => {
+			this.nativeConsultsInFlightByCallId.set(callId, state);
+			(async () => {
 				try {
-					await this.waitForConsultTranscriptSettle(callId, startedAt);
-					const context = { partialUserTranscript: this.resolveUserTranscriptContext(callId) };
+					await submitWorkingResponse();
+					if (state.cancelled) return;
+					await Promise.race([this.waitForConsultTranscriptSettle(callId, userTranscriptOwner, startedAt), state.cancellation]);
+					if (state.cancelled) return;
+					const context = {
+						partialUserTranscript: this.resolveUserTranscriptContext(callId, userTranscriptOwner),
+						abortSignal: abortController.signal
+					};
 					state.partialUserTranscript = context.partialUserTranscript;
 					const handlerArgs = withFallbackConsultQuestion(args, context.partialUserTranscript);
 					console.log(`[voice-call] realtime tool call executing callId=${callId} tool=${name} hasHandler=${Boolean(handler)}`);
@@ -1223,29 +1478,30 @@ var RealtimeCallHandler = class {
 				} catch (error) {
 					return { error: formatErrorMessage(error) };
 				}
-			});
-			this.nativeConsultsInFlightByCallId.set(callId, state);
+			})().then(completeConsult);
 			try {
-				const result = await state.promise;
+				const outcome = await waitForNativeConsult(state);
+				if (outcome.kind === "cancelled") return;
+				const result = outcome.result;
 				const status = result && typeof result === "object" && !Array.isArray(result) && "error" in result ? "error" : "ok";
 				const error = status === "error" && result && typeof result === "object" && !Array.isArray(result) ? formatErrorMessage(result.error ?? "unknown") : void 0;
 				console.log(`[voice-call] realtime tool call completed callId=${callId} tool=${name} status=${status} elapsedMs=${Date.now() - startedAt}${error ? ` error=${error}` : ""}`);
 				await submitFinalToolResult(result);
-				if (status === "ok") this.consumePartialUserTranscript(callId, state.partialUserTranscript);
+				if (status === "ok") this.consumePartialUserTranscript(callId, userTranscriptOwner, state.partialUserTranscript);
 			} finally {
 				if (this.nativeConsultsInFlightByCallId.get(callId) === state) this.nativeConsultsInFlightByCallId.delete(callId);
 			}
 			return;
 		}
 		console.log(`[voice-call] realtime tool call executing callId=${callId} tool=${name} hasHandler=${Boolean(handler)}`);
-		const context = { partialUserTranscript: this.resolveUserTranscriptContext(callId) };
+		const context = { partialUserTranscript: this.resolveUserTranscriptContext(callId, userTranscriptOwner) };
 		const handlerArgs = name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME ? withFallbackConsultQuestion(args, context.partialUserTranscript) : args;
 		const result = !handler ? { error: `Tool "${name}" not available` } : await handler(handlerArgs, callId, context).catch((error) => ({ error: formatErrorMessage(error) }));
 		const status = result && typeof result === "object" && !Array.isArray(result) && "error" in result ? "error" : "ok";
 		const error = status === "error" && result && typeof result === "object" && !Array.isArray(result) ? formatErrorMessage(result.error ?? "unknown") : void 0;
 		console.log(`[voice-call] realtime tool call completed callId=${callId} tool=${name} status=${status} elapsedMs=${Date.now() - startedAt}${error ? ` error=${error}` : ""}`);
 		await submitFinalToolResult(result);
-		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME && status === "ok") this.consumePartialUserTranscript(callId, context.partialUserTranscript);
+		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME && status === "ok") this.consumePartialUserTranscript(callId, userTranscriptOwner, context.partialUserTranscript);
 	}
 };
 //#endregion