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

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

@@ -1,9 +1,10 @@
-import { o as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-D0UJiLfi.js";
+import { T as REALTIME_VOICE_END_CALL_TOOL_NAME, o as canonicalizeVoiceCallMediaBase64, x as resolveVoiceCallPublicPathPrefix } from "./runtime-entry-DK8kPCGC.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
+import { asNullableRecord, asOptionalObjectRecord } from "openclaw/plugin-sdk/string-coerce-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 { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { randomUUID } from "node:crypto";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import "node:http";
@@ -11,16 +12,19 @@ import WebSocket$1, { WebSocketServer } from "ws";
 //#region extensions/voice-call/src/webhook/realtime-audio-pacer.ts
 const TELEPHONY_SAMPLE_RATE = 8e3;
 const TELEPHONY_CHUNK_BYTES = 160;
-const TELEPHONY_CHUNK_MS = 20;
+const LEAD_MS = 160;
 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;
+		this.streamClockMs = null;
 	}
 	/** Queue mulaw audio and split it into 20ms-ish telephony chunks. */
 	sendAudio(muLaw) {
@@ -35,7 +39,7 @@ var RealtimeAudioPacer = class {
 			this.queue.push({
 				type: "audio",
 				chunk,
-				durationMs: Math.max(1, Math.round(chunk.length / TELEPHONY_SAMPLE_RATE * 1e3))
+				durationMs: chunk.length / 8
 			});
 			this.queuedAudioBytes += chunk.length;
 		}
@@ -55,8 +59,9 @@ var RealtimeAudioPacer = class {
 		if (this.closed) return 0;
 		const clearedAudioBytes = this.queuedAudioBytes;
 		this.clearTimer();
-		this.queue = [];
+		this.resetQueue();
 		this.queuedAudioBytes = 0;
+		this.streamClockMs = null;
 		this.params.send(this.params.serializer.clear());
 		return clearedAudioBytes;
 	}
@@ -68,8 +73,9 @@ var RealtimeAudioPacer = class {
 	close() {
 		this.closed = true;
 		this.clearTimer();
-		this.queue = [];
+		this.resetQueue();
 		this.queuedAudioBytes = 0;
+		this.streamClockMs = null;
 	}
 	/** Clear the scheduled pump timer. */
 	clearTimer() {
@@ -86,25 +92,56 @@ var RealtimeAudioPacer = class {
 		this.close();
 		this.params.onBackpressure?.();
 	}
-	/** Send one queued item and schedule the next send based on audio duration. */
+	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;
+	}
+	/** Fill the provider playout cushion, then wake at the next timeline boundary. */
 	pump() {
 		this.timer = null;
 		if (this.closed) return;
-		const item = this.queue.shift();
-		if (!item) return;
-		let delayMs = 0;
-		let sent;
-		if (item.type === "audio") {
-			this.queuedAudioBytes = Math.max(0, this.queuedAudioBytes - item.chunk.length);
-			sent = this.params.send(this.params.serializer.media(item.chunk.toString("base64")));
-			delayMs = item.durationMs || TELEPHONY_CHUNK_MS;
-		} else sent = this.params.send(this.params.serializer.mark(item.name));
-		if (!sent) {
-			this.queue = [];
-			this.queuedAudioBytes = 0;
+		const now = performance.now();
+		this.streamClockMs ??= now;
+		while (this.pendingQueueSize > 0 && this.streamClockMs < now + LEAD_MS) {
+			const item = this.takeNextItem();
+			if (!item) break;
+			if (!(item.type === "audio" ? this.sendAudioItem(item) : this.params.send(this.params.serializer.mark(item.name)))) {
+				this.resetQueue();
+				this.queuedAudioBytes = 0;
+				this.streamClockMs = null;
+				return;
+			}
+		}
+		if (this.pendingQueueSize === 0) {
+			this.streamClockMs = null;
 			return;
 		}
-		if (this.queue.length > 0) this.timer = setTimeout(() => this.pump(), delayMs);
+		const delayMs = Math.max(1, this.streamClockMs - LEAD_MS - performance.now());
+		this.timer = setTimeout(() => this.pump(), delayMs);
+	}
+	sendAudioItem(item) {
+		this.queuedAudioBytes = Math.max(0, this.queuedAudioBytes - item.chunk.length);
+		const sent = this.params.send(this.params.serializer.media(item.chunk.toString("base64")));
+		this.streamClockMs = (this.streamClockMs ?? performance.now()) + item.durationMs;
+		return sent;
 	}
 };
 //#endregion
@@ -120,15 +157,13 @@ function parseTimestampMs(value) {
 /** Parse a JSON object frame, returning null for invalid or non-object payloads. */
 function tryParseJson(rawMessage) {
 	try {
-		const parsed = JSON.parse(rawMessage);
-		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		return asNullableRecord(JSON.parse(rawMessage));
 	} catch {}
 	return null;
 }
 /** Read an object-valued field from a parsed frame. */
 function readRecordField(record, field) {
-	const value = record[field];
-	return typeof value === "object" && value !== null ? value : void 0;
+	return asOptionalObjectRecord(record[field]);
 }
 /** Parse a common provider media frame. */
 function parseMediaFrame(msg) {
@@ -273,6 +308,8 @@ const STREAM_TOKEN_TTL_MS = 3e4;
 const DEFAULT_HOST = "localhost:8443";
 const MAX_REALTIME_MESSAGE_BYTES = 256 * 1024;
 const MAX_REALTIME_WS_BUFFERED_BYTES = 1024 * 1024;
+const REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS = 3e4;
+const REALTIME_DISCONNECT_HANGUP_GRACE_MS = 2e3;
 const FORCED_CONSULT_FALLBACK_DELAY_MS = 200;
 const FORCED_CONSULT_NATIVE_DEDUPE_MS = 2e3;
 const FORCED_CONSULT_RESULT_MAX_CHARS = 1800;
@@ -377,6 +414,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 ?? {};
@@ -399,26 +442,26 @@ function appendRecentTalkEventMetadata(call, event) {
 	call.metadata = metadata;
 }
 var RealtimeCallHandler = class {
-	constructor(config, manager, provider, realtimeProvider, providerConfig, servePath, coreConfig, resolveInstructions) {
+	constructor(config, manager, resolveCallRegistration, servePath, streamDisconnectLifecycle, coreConfig) {
 		this.config = config;
 		this.manager = manager;
-		this.provider = provider;
-		this.realtimeProvider = realtimeProvider;
-		this.providerConfig = providerConfig;
+		this.resolveCallRegistration = resolveCallRegistration;
 		this.servePath = servePath;
+		this.streamDisconnectLifecycle = streamDisconnectLifecycle;
 		this.coreConfig = coreConfig;
-		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.activeTelephonyBindingsByCallId = /* @__PURE__ */ new Map();
+		this.userTranscriptStatesByCallId = /* @__PURE__ */ new Map();
 		this.forcedConsultsByCallId = /* @__PURE__ */ new Map();
+		this.consultSessionsByCallId = /* @__PURE__ */ new Map();
 		this.nativeConsultsInFlightByCallId = /* @__PURE__ */ new Map();
+		this.terminationAttempts = /* @__PURE__ */ new Set();
+		this.closePromise = null;
+		this.closing = false;
 		this.publicOrigin = null;
 		this.publicPathPrefix = "";
 	}
@@ -426,10 +469,7 @@ var RealtimeCallHandler = class {
 		try {
 			const parsed = new URL(url);
 			this.publicOrigin = parsed.host;
-			const normalizedServePath = normalizeWebhookPath(this.servePath);
-			const normalizedPublicPath = normalizeWebhookPath(parsed.pathname);
-			const idx = normalizedPublicPath.indexOf(normalizedServePath);
-			this.publicPathPrefix = idx > 0 ? normalizedPublicPath.slice(0, idx) : "";
+			this.publicPathPrefix = resolveVoiceCallPublicPathPrefix(parsed.pathname, this.servePath);
 		} catch {
 			this.publicOrigin = null;
 			this.publicPathPrefix = "";
@@ -464,6 +504,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,10 +521,11 @@ var RealtimeCallHandler = class {
 			noServer: true,
 			maxPayload: MAX_REALTIME_MESSAGE_BYTES
 		}).handleUpgrade(request, socket, head, (ws) => {
-			let bridge = null;
+			this.activeSockets.add(ws);
+			let telephonyBinding = null;
 			let initialized = false;
 			let activeCallSid = "unknown";
-			let stopReceived = false;
+			let activeStreamSid = "unknown";
 			let lastMediaTimestamp;
 			let lastMediaGapWarnAt = 0;
 			ws.on("message", (data) => {
@@ -490,15 +536,18 @@ var RealtimeCallHandler = class {
 						if (initialized) return;
 						initialized = true;
 						activeCallSid = frame.providerCallId;
-						const nextBridge = this.handleCall(frame.streamId, frame.providerCallId, ws, callerMeta, adapter);
-						if (!nextBridge) return;
-						bridge = nextBridge;
+						activeStreamSid = frame.streamId;
+						const nextBinding = this.handleCall(frame.streamId, frame.providerCallId, ws, callerMeta, adapter);
+						if (!nextBinding) return;
+						telephonyBinding = nextBinding;
+						this.streamDisconnectLifecycle.connect(activeCallSid, activeStreamSid);
 						return;
 					}
-					if (!bridge) return;
+					if (!telephonyBinding) return;
 					if (frame.kind === "media") {
 						const audio = Buffer.from(frame.payloadBase64, "base64");
-						bridge.sendAudio(audio);
+						telephonyBinding.noteMediaActivity();
+						telephonyBinding.bridge.sendAudio(audio);
 						if (frame.timestampMs !== void 0) {
 							if (lastMediaTimestamp !== void 0) {
 								const gapMs = frame.timestampMs - lastMediaTimestamp;
@@ -509,35 +558,60 @@ var RealtimeCallHandler = class {
 								}
 							}
 							lastMediaTimestamp = frame.timestampMs;
-							bridge.setMediaTimestamp(frame.timestampMs);
+							telephonyBinding.bridge.setMediaTimestamp(frame.timestampMs);
 						}
 						return;
 					}
 					if (frame.kind === "mark") {
-						bridge.acknowledgeMark();
+						telephonyBinding.bridge.acknowledgeMark();
 						return;
 					}
 					if (frame.kind === "error") {
 						console.error(`[voice-call] realtime WS error frame providerCallId=${activeCallSid} code=${frame.code ?? "?"} title=${frame.title ?? ""} detail=${frame.detail ?? ""}`);
 						return;
 					}
-					if (frame.kind === "stop") {
-						stopReceived = true;
-						this.closeTelephonyBridge(activeCallSid, bridge, "completed");
-					}
+					if (frame.kind === "stop") telephonyBinding.close("disconnect");
 				} catch (error) {
 					console.error("[voice-call] realtime WS parse failed:", error);
 				}
 			});
-			ws.on("close", (code) => {
-				const reason = stopReceived || code === 1e3 || code === 1005 ? "completed" : "error";
-				this.closeTelephonyBridge(activeCallSid, bridge, reason);
+			ws.on("close", () => {
+				this.activeSockets.delete(ws);
+				const reason = this.serverClosingSockets.has(ws) ? "shutdown" : "disconnect";
+				if (telephonyBinding) telephonyBinding.close(reason);
 			});
 			ws.on("error", (error) => {
 				console.error("[voice-call] realtime WS error:", error);
+				ws.terminate();
 			});
+			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(async () => {
+			await Promise.all(this.terminationAttempts);
+			this.pendingStreamTokens.clear();
+		}).finally(() => {
+			this.closing = false;
+			this.closePromise = null;
+		});
+		return this.closePromise;
+	}
 	registerToolHandler(name, fn) {
 		this.toolHandlers.set(name, fn);
 	}
@@ -572,13 +646,24 @@ var RealtimeCallHandler = class {
 	}
 	issueStreamToken(meta = {}) {
 		const token = randomUUID();
-		const now = Date.now();
-		const expiry = resolveExpiresAtMsFromDurationMs(STREAM_TOKEN_TTL_MS, { nowMs: now });
-		if (expiry !== void 0) this.pendingStreamTokens.set(token, {
-			expiry,
-			...meta
-		});
-		for (const [candidate, entry] of this.pendingStreamTokens) if (!isFutureDateTimestampMs(entry.expiry, { nowMs: now })) this.pendingStreamTokens.delete(candidate);
+		const expiry = resolveExpiresAtMsFromDurationMs(STREAM_TOKEN_TTL_MS, { nowMs: Date.now() });
+		if (expiry !== void 0) {
+			this.pendingStreamTokens.set(token, {
+				expiry,
+				...meta
+			});
+			const host = this.publicOrigin || DEFAULT_HOST;
+			const streamPathPattern = this.getStreamPathPattern();
+			setTimeout(() => {
+				if (!this.pendingStreamTokens.has(token)) return;
+				this.pendingStreamTokens.delete(token);
+				if (this.closing) return;
+				const call = meta.callId ? ` for call ${meta.callId}` : "";
+				const endpoints = [meta.from ? `from ${meta.from}` : "", meta.to ? `to ${meta.to}` : ""].filter(Boolean).join(" ");
+				const participants = endpoints ? ` (${endpoints})` : "";
+				console.warn(`[voice-call] Realtime stream WebSocket never connected within ${STREAM_TOKEN_TTL_MS / 1e3}s${call}${participants} — the provider could not reach wss://${host}${streamPathPattern}/<token>. Verify the stream path is exposed (tailscale serve/funnel --set-path).`);
+			}, STREAM_TOKEN_TTL_MS).unref?.();
+		}
 		return token;
 	}
 	consumeStreamToken(token) {
@@ -595,20 +680,58 @@ var RealtimeCallHandler = class {
 		};
 	}
 	handleCall(streamSid, callSid, ws, callerMeta, adapter) {
-		const registration = this.registerCallInManager(callSid, callerMeta);
-		if (!registration) {
+		const preparedCall = this.prepareCallInManager(callSid, callerMeta);
+		if (!preparedCall) {
 			ws.close(1008, "Caller rejected by policy");
 			return null;
 		}
-		const { callId, instructions, initialGreetingInstructions } = registration;
-		const callRecord = this.manager.getCallByProviderCallId(callSid);
+		const { callRecord } = preparedCall;
+		const callId = callRecord.callId;
+		const hadPredecessorOnAdmission = this.activeBridgesByCallId.has(callId);
+		const previousTelephonyBinding = this.activeTelephonyBindingsByCallId.get(callId);
+		let callEndPromise;
+		const emitCallEnd = (cause) => {
+			if (callEndPromise) return callEndPromise;
+			const reason = cause === "error" ? "error" : cause === "inactivity" ? "timeout" : "completed";
+			const attempt = this.manager.endCall(callId, { reason }).then((result) => {
+				if (!result.success) {
+					console.warn(`[voice-call] Failed to end realtime call callId=${callId} providerCallId=${callSid} reason=${reason}: ${result.error ?? "unknown error"}; call remains active`);
+					return;
+				}
+				console.log(`[voice-call] Realtime call ended callId=${callId} providerCallId=${callSid} reason=${cause}`);
+			});
+			callEndPromise = attempt;
+			this.terminationAttempts.add(attempt);
+			const release = () => this.terminationAttempts.delete(attempt);
+			attempt.then(release, release);
+			return attempt;
+		};
+		let registration;
+		try {
+			registration = this.resolveCallRegistration(callRecord);
+		} catch (error) {
+			console.error(`[voice-call] Failed to resolve realtime call registration callId=${callId} providerCallId=${callSid}: ${formatErrorMessage(error)}`);
+			if (!hadPredecessorOnAdmission) emitCallEnd("error");
+			ws.close(1011, "Check realtime configuration for routed agent");
+			return null;
+		}
+		const { baseFields, initialGreeting } = preparedCall;
+		if (callRecord.metadata) delete callRecord.metadata.initialMessage;
+		this.manager.processEvent({
+			id: `realtime-answered-${callSid}`,
+			callId,
+			type: "call.answered",
+			...baseFields
+		});
+		const { agentId, instructions, provider: realtimeProvider, providerConfig } = registration;
+		const initialGreetingInstructions = buildGreetingInstructions(instructions, initialGreeting);
 		const harness = createRealtimeVoiceSessionHarness({
 			talk: {
 				sessionId: `voice-call:${callId}:realtime`,
 				mode: "realtime",
 				transport: "gateway-relay",
 				brain: "agent-consult",
-				provider: this.realtimeProvider.id
+				provider: realtimeProvider.id
 			},
 			talkPayloads: {
 				turnStarted: () => ({
@@ -634,7 +757,7 @@ var RealtimeCallHandler = class {
 			},
 			onTalkEvent: (event) => appendRecentTalkEventMetadata(callRecord, event)
 		});
-		let providerHandlesInputAudioBargeIn = this.realtimeProvider.capabilities?.handlesInputAudioBargeIn === true;
+		let providerHandlesInputAudioBargeIn = realtimeProvider.capabilities?.handlesInputAudioBargeIn === true;
 		const cancelOutputAudioForBargeIn = (source, interruptProvider, clearedAudioBytes = 0) => {
 			const outputAudioActive = harness.talk.outputAudioActive;
 			const pendingTelephonyAudio = audioPacer.hasPendingAudio();
@@ -664,12 +787,6 @@ var RealtimeCallHandler = class {
 			}
 		});
 		console.log(`[voice-call] Realtime bridge starting for call ${callId} (providerCallId=${callSid}, initialGreeting=${initialGreetingInstructions ? "queued" : "absent"})`);
-		let callEndEmitted = false;
-		const emitCallEnd = (reason) => {
-			if (callEndEmitted) return;
-			callEndEmitted = true;
-			this.endCallInManager(callSid, callId, reason);
-		};
 		const sendString = (message) => {
 			if (ws.readyState !== WebSocket$1.OPEN) return false;
 			if (ws.bufferedAmount > MAX_REALTIME_WS_BUFFERED_BYTES) {
@@ -702,11 +819,15 @@ var RealtimeCallHandler = class {
 			speechFrames: BARGE_IN_REQUIRED_LOUD_CHUNKS,
 			silenceFrames: 12
 		});
-		const interruptResponseOnInputAudio = typeof this.providerConfig.interruptResponseOnInputAudio === "boolean" ? this.providerConfig.interruptResponseOnInputAudio : void 0;
-		const session = harness.createBridge({
-			provider: this.realtimeProvider,
+		const interruptResponseOnInputAudio = typeof providerConfig.interruptResponseOnInputAudio === "boolean" ? providerConfig.interruptResponseOnInputAudio : void 0;
+		const nativeConsultOwner = {};
+		const userTranscriptAdoption = this.beginUserTranscriptOwnerAdoption(callId);
+		const userTranscriptOwner = userTranscriptAdoption.owner;
+		const bridgeParams = {
+			provider: realtimeProvider,
 			cfg: this.coreConfig,
-			providerConfig: this.providerConfig,
+			agentId,
+			providerConfig,
 			interruptResponseOnInputAudio,
 			instructions,
 			tools: this.config.tools,
@@ -734,6 +855,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 +880,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 +913,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 +943,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 +986,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 +1013,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,29 +1027,33 @@ var RealtimeCallHandler = class {
 					final: true
 				});
 				if (reason !== "error") return;
-				emitCallEnd("error");
+				this.streamDisconnectLifecycle.retire(callSid, streamSid);
 				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)}`);
-				});
-			}
-		});
-		providerHandlesInputAudioBargeIn = session.bridge.handlesInputAudioBargeIn ?? providerHandlesInputAudioBargeIn;
-		const closeTelephony = (reason) => {
-			try {
-				session.close();
-			} finally {
-				emitCallEnd(reason);
+				if (owner && !ownsCallState || !owner && hadPredecessorOnAdmission && this.activeBridgesByCallId.has(callId)) return;
+				emitCallEnd("error");
 			}
 		};
-		this.activeBridgesByCallId.set(callId, session);
-		this.activeBridgesByCallId.set(callSid, session);
-		this.activeTelephonyClosersByCallId.set(callId, closeTelephony);
-		this.activeTelephonyClosersByCallId.set(callSid, closeTelephony);
+		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 previousConsultSession = this.consultSessionsByCallId.get(callId);
+		if (previousConsultSession && previousConsultSession.owner !== session) this.cancelConsultSession(callId, previousConsultSession.owner);
+		this.consultSessionsByCallId.set(callId, {
+			owner: session,
+			coordinator: harness.forcedConsults
+		});
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
 			if (speechDetector.accept({
@@ -924,86 +1076,239 @@ 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();
 			}
 		};
+		let livenessTimer;
+		const clearLivenessTimer = () => {
+			if (livenessTimer) {
+				clearTimeout(livenessTimer);
+				livenessTimer = void 0;
+			}
+		};
+		let bindingClosed = false;
+		const closeBinding = (binding, cause) => {
+			if (bindingClosed) return callEndPromise ?? Promise.resolve();
+			bindingClosed = true;
+			clearLivenessTimer();
+			const ownsCall = this.activeTelephonyBindingsByCallId.get(callId) === binding;
+			let termination = Promise.resolve();
+			try {
+				session.close();
+			} catch (error) {
+				console.warn(`[voice-call] Failed to close realtime bridge ${callSid}: ${formatErrorMessage(error)}`);
+			} finally {
+				this.clearActiveTelephonyBinding(callId, binding);
+				if (cause === "disconnect") this.streamDisconnectLifecycle.disconnect(callSid, streamSid);
+				else this.streamDisconnectLifecycle.retire(callSid, streamSid);
+				if (ownsCall && cause && cause !== "disconnect") termination = emitCallEnd(cause);
+			}
+			return termination;
+		};
+		const telephonyBinding = {
+			bridge: session,
+			close: (cause) => closeBinding(telephonyBinding, cause),
+			endCall: () => {
+				closeBinding(telephonyBinding);
+				if (ws.readyState === WebSocket$1.OPEN) ws.close(1e3, "Call ended");
+			},
+			noteMediaActivity: () => {
+				if (bindingClosed || this.activeTelephonyBindingsByCallId.get(callId) !== telephonyBinding) return;
+				clearLivenessTimer();
+				livenessTimer = setTimeout(() => {
+					console.warn(`[voice-call] Realtime media inactive callId=${callId} providerCallId=${callSid} timeoutMs=${REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS} graceMs=${REALTIME_DISCONNECT_HANGUP_GRACE_MS}`);
+					livenessTimer = setTimeout(() => {
+						telephonyBinding.close("inactivity");
+						if (ws.readyState === WebSocket$1.OPEN) ws.close(1e3, "Media inactivity");
+					}, REALTIME_DISCONNECT_HANGUP_GRACE_MS);
+					livenessTimer.unref?.();
+				}, REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS);
+				livenessTimer.unref?.();
+			},
+			retire: () => {
+				closeBinding(telephonyBinding);
+			}
+		};
+		this.activeBridgesByCallId.set(callId, session);
+		this.activeBridgesByCallId.set(callSid, session);
+		this.activeTelephonyBindingsByCallId.set(callId, telephonyBinding);
+		telephonyBinding.noteMediaActivity();
+		if (previousTelephonyBinding && previousTelephonyBinding !== telephonyBinding) previousTelephonyBinding.retire();
 		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);
+			this.streamDisconnectLifecycle.retire(callSid, streamSid);
+			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());
+		return telephonyBinding;
+	}
+	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, owner) {
+		const state = this.getUserTranscriptState(callId, owner);
+		if (!state) return;
+		if (state.recentFinalTimer) {
+			clearTimeout(state.recentFinalTimer);
+			state.recentFinalTimer = void 0;
+		}
+		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);
 	}
-	clearRecentFinalUserTranscript(callId) {
-		const timer = this.recentFinalUserTranscriptTimersByCallId.get(callId);
-		if (timer) {
-			clearTimeout(timer);
-			this.recentFinalUserTranscriptTimersByCallId.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;
+	}
+	clearActiveBridgeMappings(callId, callSid, owner) {
+		for (const key of [callId, callSid]) {
+			if (this.activeBridgesByCallId.get(key) !== owner) continue;
+			this.activeBridgesByCallId.delete(key);
 		}
-		this.recentFinalUserTranscriptsByCallId.delete(callId);
 	}
-	clearUserTranscriptState(callId) {
-		this.clearPartialUserTranscript(callId);
-		this.clearRecentFinalUserTranscript(callId);
+	clearActiveTelephonyBinding(callId, binding) {
+		if (this.activeTelephonyBindingsByCallId.get(callId) === binding) this.activeTelephonyBindingsByCallId.delete(callId);
 	}
-	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;
@@ -1013,16 +1318,8 @@ var RealtimeCallHandler = class {
 			});
 		}
 	}
-	closeTelephonyBridge(callIdOrSid, bridge, reason) {
-		const closer = this.activeTelephonyClosersByCallId.get(callIdOrSid);
-		if (closer) {
-			closer(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 +1348,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 +1381,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);
@@ -1085,7 +1394,7 @@ var RealtimeCallHandler = class {
 			}, FORCED_CONSULT_NATIVE_DEDUPE_MS).unref?.();
 		}
 	}
-	registerCallInManager(callSid, callerMeta = {}) {
+	prepareCallInManager(callSid, callerMeta = {}) {
 		const baseFields = {
 			providerCallId: callSid,
 			timestamp: Date.now(),
@@ -1097,18 +1406,10 @@ var RealtimeCallHandler = class {
 		if (!callRecord) return null;
 		const initialGreeting = this.extractInitialGreeting(callRecord);
 		console.log(`[voice-call] Realtime call ${callRecord.callId} initial greeting ${initialGreeting ? "queued" : "absent"}`);
-		if (callRecord.metadata) delete callRecord.metadata.initialMessage;
-		this.manager.processEvent({
-			id: `realtime-answered-${callSid}`,
-			callId: callRecord.callId,
-			type: "call.answered",
-			...baseFields
-		});
-		const instructions = this.resolveInstructions?.(callRecord) ?? this.config.instructions;
 		return {
-			callId: callRecord.callId,
-			instructions,
-			initialGreetingInstructions: buildGreetingInstructions(instructions, initialGreeting)
+			callRecord,
+			baseFields,
+			initialGreeting
 		};
 	}
 	resolveRealtimeCall(callSid, callerMeta, baseFields) {
@@ -1127,17 +1428,57 @@ var RealtimeCallHandler = class {
 	extractInitialGreeting(call) {
 		return typeof call.metadata?.initialMessage === "string" ? call.metadata.initialMessage : void 0;
 	}
-	endCallInManager(callSid, callId, reason) {
-		this.manager.processEvent({
-			id: `realtime-ended-${callSid}-${Date.now()}`,
-			type: "call.ended",
-			callId,
-			providerCallId: callSid,
-			timestamp: Date.now(),
-			reason
+	async executeEndCallTool(params) {
+		const binding = this.activeTelephonyBindingsByCallId.get(params.callId);
+		if (!binding || binding.bridge !== params.bridge || !this.isActiveBridgeOwner(params.callId, params.bridge)) return;
+		let result;
+		try {
+			result = await this.manager.endCall(params.callId);
+		} catch (error) {
+			result = {
+				success: false,
+				error: formatErrorMessage(error)
+			};
+		}
+		if (this.activeTelephonyBindingsByCallId.get(params.callId) !== binding || !this.isActiveBridgeOwner(params.callId, params.bridge)) return;
+		if (!result.success) {
+			const toolResult = { error: `Could not end the current phone call: ${result.error?.trim() || "the telephony provider returned no reason"}. Tell the caller the call could not be ended and they can hang up or ask you to try again.` };
+			await params.bridge.submitToolResult(params.bridgeCallId, toolResult);
+			params.harness.emit({
+				type: "tool.error",
+				turnId: params.turnId,
+				callId: params.bridgeCallId,
+				payload: {
+					name: REALTIME_VOICE_END_CALL_TOOL_NAME,
+					result: toolResult
+				},
+				final: true
+			});
+			return;
+		}
+		params.harness.emit({
+			type: "tool.result",
+			turnId: params.turnId,
+			callId: params.bridgeCallId,
+			payload: {
+				name: REALTIME_VOICE_END_CALL_TOOL_NAME,
+				result: { success: true }
+			},
+			final: true
 		});
+		binding.endCall();
 	}
-	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness) {
+	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness, userTranscriptOwner) {
+		if (name === "openclaw_end_call") {
+			await this.executeEndCallTool({
+				bridge,
+				callId,
+				bridgeCallId,
+				turnId,
+				harness
+			});
+			return;
+		}
 		const handler = this.toolHandlers.get(name);
 		const startedAt = Date.now();
 		const hasResultError = (result) => {
@@ -1174,13 +1515,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 +1541,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 +1592,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