@openclaw/voice-call 2026.9.3 → 2026.9.5

package/dist/{realtime-handler-BSW48gqM.js → .setup/realtime-handler-CaoetLrM.mjs}

@@ -1,9 +1,9 @@
-import { d as REALTIME_VOICE_END_CALL_TOOL_NAME, s as resolveVoiceCallPublicPathPrefix } from "./config-DQwvsxeV.js";
-import { c as canonicalizeVoiceCallMediaBase64, o as WebSocket, s as WebSocketServer } from "./runtime-entry-B8SNb2qD.js";
+import { d as REALTIME_VOICE_END_CALL_TOOL_NAME, s as resolveVoiceCallPublicPathPrefix } from "./config-72FnMWHb.mjs";
+import { c as canonicalizeVoiceCallMediaBase64, o as WebSocket, s as WebSocketServer } from "./runtime-entry-YWSSnAsH.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-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, REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ, buildRealtimeVoiceAgentConsultWorkingResponse, buildRealtimeVoiceAgentErrorProviderResult, calculateMulawRms, createRealtimeVoiceSessionHarness, createSpeechThresholdGate, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult } from "openclaw/plugin-sdk/realtime-voice";
+import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ, buildRealtimeVoiceAgentConsultWorkingResponse, buildRealtimeVoiceAgentErrorProviderResult, calculateMulawRms, createRealtimeVoiceSessionHarness, createSpeechThresholdGate, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult, resolveRealtimeVoiceBargeIn, resolveRealtimeVoiceSessionPolicy } 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";
@@ -15,6 +15,8 @@ const TELEPHONY_CHUNK_BYTES = 160;
 const LEAD_MS = 160;
 const DEFAULT_MAX_QUEUED_AUDIO_BYTES = TELEPHONY_SAMPLE_RATE * 120;
 const QUEUE_COMPACT_HEAD_THRESHOLD = 256;
+const MAX_PLAYBACK_SEGMENTS = 128;
+const MAX_PENDING_MARK_BOUNDARIES = 64;
 /** Paces outgoing mulaw audio frames at telephony cadence. */
 var RealtimeAudioPacer = class {
 	constructor(params) {
@@ -25,9 +27,18 @@ var RealtimeAudioPacer = class {
 		this.queuedAudioBytes = 0;
 		this.closed = false;
 		this.streamClockMs = null;
+		this.playbackSegments = [];
+		this.sentAudioMs = 0;
+		this.retiredAudioMs = 0;
+		this.confirmedPlayedMs = 0;
+		this.playbackMarkPrefix = `openclaw-playout-${randomUUID()}`;
+		this.playbackMarkSequence = 0;
+		this.lastPlaybackMarkMs = 0;
+		this.markBoundaries = [];
+		this.retiredItemOffsets = /* @__PURE__ */ new Map();
 	}
 	/** Queue mulaw audio and split it into 20ms-ish telephony chunks. */
-	sendAudio(muLaw) {
+	sendAudio(muLaw, metadata) {
 		if (this.closed || muLaw.length === 0) return;
 		const maxQueuedAudioBytes = this.params.maxQueuedAudioBytes ?? DEFAULT_MAX_QUEUED_AUDIO_BYTES;
 		for (let offset = 0; offset < muLaw.length; offset += TELEPHONY_CHUNK_BYTES) {
@@ -36,15 +47,42 @@ var RealtimeAudioPacer = class {
 				this.failBackpressure();
 				return;
 			}
+			const durationMs = chunk.length / 8;
+			const segment = this.extendPlaybackSegment(metadata?.itemId, durationMs);
+			if (!segment) {
+				this.failBackpressure();
+				return;
+			}
 			this.queue.push({
 				type: "audio",
 				chunk,
-				durationMs: chunk.length / 8
+				durationMs,
+				segment
 			});
 			this.queuedAudioBytes += chunk.length;
 		}
 		this.ensurePump();
 	}
+	/**
+	* Retained provider items in playback order with consumed playout duration.
+	* Queued audio has not reached the telephony line, so unplayed items report zero.
+	*/
+	getPlaybackState() {
+		let remaining = Math.max(0, this.confirmedPlayedMs - this.retiredAudioMs);
+		const playedByItem = /* @__PURE__ */ new Map();
+		for (const segment of this.playbackSegments) {
+			const consumed = Math.min(remaining, segment.sentMs);
+			remaining -= consumed;
+			if (segment.itemId !== void 0) {
+				const previousMs = playedByItem.get(segment.itemId) ?? this.retiredItemOffsets.get(segment.itemId) ?? 0;
+				playedByItem.set(segment.itemId, previousMs + consumed);
+			}
+		}
+		return Array.from(playedByItem, ([itemId, audioEndMs]) => ({
+			itemId,
+			audioEndMs: Math.floor(audioEndMs)
+		}));
+	}
 	/** Queue a provider mark frame after prior audio frames. */
 	sendMark(name) {
 		if (this.closed || !name) return;
@@ -54,14 +92,32 @@ var RealtimeAudioPacer = class {
 		});
 		this.ensurePump();
 	}
+	/** Retire the playback prefix once the carrier confirms playout reached the mark. */
+	acknowledgeMark(name) {
+		if (this.closed || !name) return;
+		const boundaryIndex = this.markBoundaries.findIndex((boundary) => boundary.name === name);
+		if (boundaryIndex < 0) return;
+		const boundary = this.markBoundaries[boundaryIndex];
+		this.markBoundaries.splice(0, boundaryIndex + 1);
+		if (!boundary) return;
+		while (this.playbackSegments.length > 0) {
+			const head = this.playbackSegments[0];
+			if (!head || head.sentMs < head.totalMs || head.lastSentEndMs === void 0 || head.lastSentEndMs > boundary.sentMs) break;
+			const retired = this.playbackSegments.shift();
+			if (retired) {
+				this.retiredAudioMs += retired.sentMs;
+				if (retired.itemId !== void 0) this.retiredItemOffsets.set(retired.itemId, (this.retiredItemOffsets.get(retired.itemId) ?? 0) + retired.sentMs);
+			}
+		}
+		this.confirmedPlayedMs = Math.max(this.confirmedPlayedMs, Math.min(boundary.sentMs, this.sentAudioMs));
+	}
 	/** Clear queued audio and notify the provider stream. */
 	clearAudio() {
 		if (this.closed) return 0;
 		const clearedAudioBytes = this.queuedAudioBytes;
 		this.clearTimer();
 		this.resetQueue();
-		this.queuedAudioBytes = 0;
-		this.streamClockMs = null;
+		this.resetPlaybackState();
 		this.params.send(this.params.serializer.clear());
 		return clearedAudioBytes;
 	}
@@ -74,8 +130,33 @@ var RealtimeAudioPacer = class {
 		this.closed = true;
 		this.clearTimer();
 		this.resetQueue();
+		this.resetPlaybackState();
+	}
+	extendPlaybackSegment(itemId, durationMs) {
+		let segment = this.playbackSegments.at(-1);
+		if (!segment || segment.itemId !== itemId) {
+			if (this.playbackSegments.length >= MAX_PLAYBACK_SEGMENTS) return null;
+			segment = {
+				itemId,
+				totalMs: 0,
+				sentMs: 0
+			};
+			this.playbackSegments.push(segment);
+		}
+		segment.totalMs += durationMs;
+		return segment;
+	}
+	resetPlaybackState() {
+		this.playbackSegments = [];
 		this.queuedAudioBytes = 0;
+		this.sentAudioMs = 0;
+		this.retiredAudioMs = 0;
+		this.confirmedPlayedMs = 0;
+		this.lastPlaybackMarkMs = 0;
+		this.markBoundaries = [];
+		this.retiredItemOffsets.clear();
 		this.streamClockMs = null;
+		this.params.onPlaybackReset?.();
 	}
 	/** Clear the scheduled pump timer. */
 	clearTimer() {
@@ -123,7 +204,7 @@ var RealtimeAudioPacer = class {
 		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)))) {
+			if (!(item.type === "audio" ? this.sendAudioItem(item) : this.sendMarkItem(item))) {
 				this.resetQueue();
 				this.queuedAudioBytes = 0;
 				this.streamClockMs = null;
@@ -140,7 +221,30 @@ var RealtimeAudioPacer = class {
 	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")));
+		if (sent) {
+			item.segment.sentMs += item.durationMs;
+			this.sentAudioMs += item.durationMs;
+			item.segment.lastSentEndMs = this.sentAudioMs;
+		}
 		this.streamClockMs = (this.streamClockMs ?? performance.now()) + item.durationMs;
+		if (!sent || item.segment.itemId === void 0 || this.sentAudioMs - this.lastPlaybackMarkMs < LEAD_MS) return sent;
+		this.lastPlaybackMarkMs = this.sentAudioMs;
+		this.playbackMarkSequence += 1;
+		return this.sendMarkItem({
+			type: "mark",
+			name: `${this.playbackMarkPrefix}-${this.playbackMarkSequence}`
+		});
+	}
+	/** Send a queued mark frame and bind it to the playback prefix before it. */
+	sendMarkItem(item) {
+		const sent = this.params.send(this.params.serializer.mark(item.name));
+		if (sent) {
+			this.markBoundaries.push({
+				name: item.name,
+				sentMs: this.sentAudioMs
+			});
+			if (this.markBoundaries.length > MAX_PENDING_MARK_BOUNDARIES) this.markBoundaries.shift();
+		}
 		return sent;
 	}
 };
@@ -421,26 +525,27 @@ async function waitForNativeConsult(state) {
 		result
 	})), state.cancellation.then(() => ({ kind: "cancelled" }))]);
 }
-function appendRecentTalkEventMetadata(call, event) {
-	if (!call) return;
-	const metadata = call.metadata ?? {};
-	const previous = Array.isArray(metadata.recentTalkEvents) ? metadata.recentTalkEvents : [];
-	metadata.lastTalkEventAt = event.timestamp;
-	metadata.lastTalkEventType = event.type;
-	metadata.recentTalkEvents = [...previous, {
-		id: event.id,
-		brain: event.brain,
-		mode: event.mode,
-		provider: event.provider,
-		seq: event.seq,
-		sessionId: event.sessionId,
-		timestamp: event.timestamp,
-		transport: event.transport,
-		type: event.type,
-		...event.turnId ? { turnId: event.turnId } : {},
-		...event.final !== void 0 ? { final: event.final } : {}
-	}].slice(-12);
-	call.metadata = metadata;
+function appendRecentTalkEventMetadata(metadata, event) {
+	const previous = metadata ?? {};
+	const recent = Array.isArray(previous.recentTalkEvents) ? previous.recentTalkEvents : [];
+	return {
+		...previous,
+		lastTalkEventAt: event.timestamp,
+		lastTalkEventType: event.type,
+		recentTalkEvents: [...recent, {
+			id: event.id,
+			brain: event.brain,
+			mode: event.mode,
+			provider: event.provider,
+			seq: event.seq,
+			sessionId: event.sessionId,
+			timestamp: event.timestamp,
+			transport: event.transport,
+			type: event.type,
+			...event.turnId ? { turnId: event.turnId } : {},
+			...event.final !== void 0 ? { final: event.final } : {}
+		}].slice(-12)
+	};
 }
 function rejectRealtimeUpgrade(socket, status) {
 	const reason = status === 401 ? "Unauthorized" : "Service Unavailable";
@@ -470,6 +575,7 @@ var RealtimeCallHandler = class {
 		this.consultSessionsByCallId = /* @__PURE__ */ new Map();
 		this.nativeConsultsInFlightByCallId = /* @__PURE__ */ new Map();
 		this.terminationAttempts = /* @__PURE__ */ new Set();
+		this.admissions = /* @__PURE__ */ new Set();
 		this.closePromise = null;
 		this.closing = false;
 		this.publicOrigin = null;
@@ -537,7 +643,19 @@ var RealtimeCallHandler = class {
 			let activeStreamSid = "unknown";
 			let lastMediaTimestamp;
 			let lastMediaGapWarnAt = 0;
-			ws.on("message", (data) => {
+			let admitting = false;
+			const pendingFrames = [];
+			let pendingBytes = 0;
+			const handleMessage = (data) => {
+				if (admitting) {
+					pendingBytes += Math.max(1, data.byteLength);
+					if (pendingBytes > MAX_REALTIME_WS_BUFFERED_BYTES) {
+						ws.terminate();
+						return;
+					}
+					pendingFrames.push(data);
+					return;
+				}
 				try {
 					const frame = adapter.parseInbound(data.toString());
 					if (frame.kind === "ignored") return;
@@ -546,10 +664,27 @@ var RealtimeCallHandler = class {
 						initialized = true;
 						activeCallSid = frame.providerCallId;
 						activeStreamSid = frame.streamId;
-						const nextBinding = this.handleCall(frame.streamId, frame.providerCallId, ws, callerMeta, adapter);
-						if (!nextBinding) return;
-						telephonyBinding = nextBinding;
-						this.streamDisconnectLifecycle.connect(activeCallSid, activeStreamSid);
+						admitting = true;
+						ws.pause();
+						const admission = this.handleCall(frame.streamId, frame.providerCallId, ws, callerMeta, adapter).then(async (nextBinding) => {
+							telephonyBinding = nextBinding;
+							if (!nextBinding) return;
+							if (this.closing || ws.readyState !== WebSocket.OPEN) {
+								await nextBinding.close(this.serverClosingSockets.has(ws) ? "shutdown" : "disconnect");
+								return;
+							}
+							this.streamDisconnectLifecycle.connect(activeCallSid, activeStreamSid);
+						}).catch((error) => {
+							console.error("[voice-call] realtime admission failed:", error);
+							ws.close(1011, "Failed to persist call");
+						}).finally(() => {
+							admitting = false;
+							if (ws.readyState === WebSocket.OPEN && !this.closing) for (const pending of pendingFrames) handleMessage(pending);
+							ws.resume();
+							pendingFrames.length = 0;
+							pendingBytes = 0;
+						});
+						this.trackShutdownWork(admission, this.admissions);
 						return;
 					}
 					if (!telephonyBinding) return;
@@ -572,7 +707,8 @@ var RealtimeCallHandler = class {
 						return;
 					}
 					if (frame.kind === "mark") {
-						telephonyBinding.bridge.acknowledgeMark();
+						telephonyBinding.acknowledgeCarrierMark(frame.name);
+						telephonyBinding.bridge.acknowledgeMark(frame.name);
 						return;
 					}
 					if (frame.kind === "error") {
@@ -583,7 +719,8 @@ var RealtimeCallHandler = class {
 				} catch (error) {
 					console.error("[voice-call] realtime WS parse failed:", error);
 				}
-			});
+			};
+			ws.on("message", handleMessage);
 			ws.on("close", () => {
 				this.activeSockets.delete(ws);
 				const reason = this.serverClosingSockets.has(ws) ? "shutdown" : "disconnect";
@@ -604,7 +741,7 @@ var RealtimeCallHandler = class {
 		this.closing = true;
 		this.pendingStreamTokens.clear();
 		const sockets = [...this.activeSockets];
-		this.closePromise = Promise.all([shutdownBarrier, ...sockets.map((ws) => new Promise((resolve) => {
+		this.closePromise = Promise.allSettled([shutdownBarrier, ...sockets.map((ws) => new Promise((resolve) => {
 			if (ws.readyState === WebSocket.CLOSED) {
 				resolve();
 				return;
@@ -612,15 +749,29 @@ var RealtimeCallHandler = class {
 			this.serverClosingSockets.add(ws);
 			ws.once("close", () => resolve());
 			ws.terminate();
-		}))]).then(async () => {
-			await Promise.all(this.terminationAttempts);
+		}))]).then(async (results) => {
+			results.push(...await Promise.allSettled(this.admissions));
+			results.push(...await Promise.allSettled(this.terminationAttempts));
 			this.pendingStreamTokens.clear();
+			const failure = results.find((result) => result.status === "rejected");
+			if (failure?.status === "rejected") throw failure.reason;
+			if (this.shutdownFailure) throw this.shutdownFailure.error;
 		}).finally(() => {
 			this.closing = false;
 			this.closePromise = null;
+			this.shutdownFailure = void 0;
 		});
 		return this.closePromise;
 	}
+	trackShutdownWork(work, pending) {
+		pending.add(work);
+		work.then(() => {
+			pending.delete(work);
+		}, (error) => {
+			pending.delete(work);
+			if (this.closing) this.shutdownFailure ??= { error };
+		});
+	}
 	registerToolHandler(name, fn) {
 		this.toolHandlers.set(name, fn);
 	}
@@ -688,16 +839,14 @@ var RealtimeCallHandler = class {
 			callId: entry.callId
 		};
 	}
-	handleCall(streamSid, callSid, ws, callerMeta, adapter) {
-		const preparedCall = this.prepareCallInManager(callSid, callerMeta);
+	async handleCall(streamSid, callSid, ws, callerMeta, adapter) {
+		const preparedCall = await this.prepareCallInManager(callSid, callerMeta);
 		if (!preparedCall) {
 			ws.close(1008, "Caller rejected by policy");
 			return null;
 		}
 		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;
@@ -710,29 +859,70 @@ var RealtimeCallHandler = class {
 				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);
+			this.trackShutdownWork(attempt, this.terminationAttempts);
 			return attempt;
 		};
+		const admissionAbandoned = () => this.closing || ws.readyState !== WebSocket.OPEN;
+		const abandonAdmission = async () => {
+			if (!this.activeBridgesByCallId.has(callId)) {
+				if (this.closing || this.serverClosingSockets.has(ws)) await emitCallEnd("shutdown");
+				else {
+					this.streamDisconnectLifecycle.connect(callSid, streamSid);
+					this.streamDisconnectLifecycle.disconnect(callSid, streamSid);
+				}
+			}
+		};
+		if (admissionAbandoned()) {
+			await abandonAdmission();
+			return null;
+		}
 		let registration;
+		let sessionPolicy;
 		try {
 			registration = this.resolveCallRegistration(callRecord);
+			sessionPolicy = resolveRealtimeVoiceSessionPolicy({
+				isAgentProxy: false,
+				capabilities: registration.capabilities,
+				configuredToolPolicy: this.config.toolPolicy,
+				configuredConsultPolicy: this.config.consultPolicy === "always" ? "always" : "auto",
+				requireWakeName: void 0,
+				configuredWakeNames: void 0,
+				cfg: this.coreConfig ?? {},
+				agentId: registration.agentId
+			});
 		} catch (error) {
 			console.error(`[voice-call] Failed to resolve realtime call registration callId=${callId} providerCallId=${callSid}: ${formatErrorMessage(error)}`);
-			if (!hadPredecessorOnAdmission) emitCallEnd("error");
+			if (!this.activeBridgesByCallId.has(callId)) 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({
+		const { baseFields } = preparedCall;
+		let initialGreeting;
+		await this.manager.updateCallMetadata(callRecord, (metadata) => {
+			if (metadata) {
+				initialGreeting = typeof metadata.initialMessage === "string" ? metadata.initialMessage : void 0;
+				delete metadata.initialMessage;
+			}
+			return metadata;
+		});
+		await this.manager.processEvent({
 			id: `realtime-answered-${callSid}`,
 			callId,
 			type: "call.answered",
 			...baseFields
 		});
-		const { agentId, instructions, provider: realtimeProvider, providerConfig } = registration;
+		if (admissionAbandoned()) {
+			await abandonAdmission();
+			return null;
+		}
+		if (this.manager.getCallByProviderCallId(callSid) !== callRecord) {
+			ws.close(1008, "Call is no longer active");
+			return null;
+		}
+		const previousTelephonyBinding = this.activeTelephonyBindingsByCallId.get(callId);
+		const { agentId, instructions, provider: realtimeProvider, providerConfig, capabilities } = registration;
+		const { handlesAgentConsult, toolPolicy } = sessionPolicy;
+		if (handlesAgentConsult) console.warn("[voice-call] This realtime model uses native agent delegation; the end-call and custom realtime function tools are unavailable.");
 		const initialGreetingInstructions = buildGreetingInstructions(instructions, initialGreeting);
 		const harness = createRealtimeVoiceSessionHarness({
 			talk: {
@@ -764,9 +954,13 @@ var RealtimeCallHandler = class {
 					reason
 				})
 			},
-			onTalkEvent: (event) => appendRecentTalkEventMetadata(callRecord, event)
+			onTalkEvent: (event) => {
+				this.manager.updateCallMetadata(callRecord, (metadata) => appendRecentTalkEventMetadata(metadata, event)).catch((error) => {
+					console.warn("[voice-call] Failed to update realtime call metadata:", error);
+				});
+			}
 		});
-		let providerHandlesInputAudioBargeIn = realtimeProvider.capabilities?.handlesInputAudioBargeIn === true;
+		const providerHandlesInputAudioBargeIn = (capabilities ?? realtimeProvider.capabilities)?.handlesInputAudioBargeIn === true;
 		const cancelOutputAudioForBargeIn = (source, interruptProvider, clearedAudioBytes = 0) => {
 			const outputAudioActive = harness.talk.outputAudioActive;
 			const pendingTelephonyAudio = audioPacer.hasPendingAudio();
@@ -811,7 +1005,9 @@ var RealtimeCallHandler = class {
 			}
 			return true;
 		};
+		const pendingMarkAcks = /* @__PURE__ */ new Map();
 		const audioPacer = new RealtimeAudioPacer({
+			onPlaybackReset: () => pendingMarkAcks.clear(),
 			send: sendString,
 			serializer: {
 				media: (payload) => adapter.serializeMedia(payload),
@@ -834,23 +1030,63 @@ var RealtimeCallHandler = class {
 		let sessionClosed = false;
 		const userTranscriptAdoption = this.beginUserTranscriptOwnerAdoption(callId);
 		const userTranscriptOwner = userTranscriptAdoption.owner;
+		let transcriptPersistence = Promise.resolve();
+		let transcriptFailure;
+		const reportTranscriptFailure = (error) => {
+			transcriptFailure ??= { error };
+			console.error("[voice-call] Failed to persist realtime transcript:", error);
+		};
+		const drainProviderClose = async (closeProvider) => {
+			const failures = [];
+			try {
+				await closeProvider();
+			} catch (error) {
+				failures.push(error);
+			}
+			await transcriptPersistence.catch((error) => {
+				transcriptFailure ??= { error };
+			});
+			if (transcriptFailure) failures.push(transcriptFailure.error);
+			if (failures.length === 1) throw failures[0];
+			if (failures.length > 1) throw new AggregateError(failures, "Realtime provider and transcript cleanup failed");
+		};
+		let continuityGeneration = 0;
 		const bridgeParams = {
 			provider: realtimeProvider,
 			cfg: this.coreConfig,
 			agentId,
 			providerConfig,
+			capabilities,
 			audioFormat: REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ,
 			interruptResponseOnInputAudio,
-			instructions,
-			tools: this.config.tools,
+			instructions: handlesAgentConsult ? `${instructions}\n\nUse native agent delegation for OpenClaw work. End-call and custom realtime function tools are unavailable in this session; the caller can hang up to end the call.` : instructions,
+			tools: handlesAgentConsult ? [] : this.config.tools,
+			...handlesAgentConsult ? { runAgentConsult: async (request) => {
+				const owner = nativeConsultOwner.current;
+				const generation = continuityGeneration;
+				request.signal?.throwIfAborted();
+				await transcriptPersistence;
+				if (!owner || sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, owner)) throw new Error("Realtime call delegation owner is no longer active");
+				if (toolPolicy === "none") throw new Error("Agent consultation is disabled for this call");
+				const result = await this.executeToolCall(owner, callId, randomUUID(), REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, { question: request.prompt }, harness.ensureTurn(), harness, userTranscriptOwner, { signal: request.signal });
+				request.signal?.throwIfAborted();
+				if (sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, owner)) throw new Error("Realtime call delegation owner is no longer active");
+				const text = readSpeakableRealtimeVoiceToolResult(result, {
+					keys: ["text", "output"],
+					maxChars: FORCED_CONSULT_RESULT_MAX_CHARS
+				});
+				if (!text) throw new Error("Agent consultation returned no spoken answer");
+				return { text };
+			} } : {},
 			initialGreetingInstructions,
 			triggerGreetingOnReady: Boolean(initialGreetingInstructions),
 			audioSink: {
-				isOpen: () => ws.readyState === WebSocket.OPEN,
-				sendAudio: (muLaw) => {
+				isOpen: () => !sessionClosed && ws.readyState === WebSocket.OPEN,
+				sendAudio: (muLaw, metadata) => {
 					harness.recordOutputAudio(muLaw);
-					audioPacer.sendAudio(muLaw);
+					audioPacer.sendAudio(muLaw, metadata);
 				},
+				getPlaybackState: () => audioPacer.getPlaybackState(),
 				clearAudio: (reason) => {
 					harness.flushOutput(() => {
 						const clearedBytes = audioPacer.clearAudio();
@@ -862,13 +1098,14 @@ var RealtimeCallHandler = class {
 						harness.finishOutputAudio("clear");
 					});
 				},
-				sendMark: (markName) => {
+				sendMark: (markName, acknowledge) => {
 					audioPacer.sendMark(markName);
+					if (markName && acknowledge) pendingMarkAcks.set(markName, acknowledge);
 				}
 			},
 			onTranscript: (role, text, isFinal) => {
 				const owner = nativeConsultOwner.current;
-				if (provisionalCloseReason || !this.getUserTranscriptState(callId, userTranscriptOwner) || owner && !this.isActiveBridgeOwner(callId, owner)) return;
+				if (provisionalCloseReason || sessionClosed && !isFinal || !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 } : {
@@ -910,7 +1147,7 @@ var RealtimeCallHandler = class {
 					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()}`,
+						id: `realtime-speech-${callSid}-${randomUUID()}`,
 						type: "call.speech",
 						callId,
 						providerCallId: callSid,
@@ -918,31 +1155,39 @@ var RealtimeCallHandler = class {
 						transcript,
 						isFinal: true
 					};
-					this.manager.processEvent(event);
-					this.scheduleForcedAgentConsult({
-						harness,
-						session,
-						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}`);
-						}
+					const generation = continuityGeneration;
+					transcriptPersistence = this.manager.processEvent(event).then(() => {
+						if (handlesAgentConsult || sessionClosed || generation !== continuityGeneration || !this.getUserTranscriptState(callId, userTranscriptOwner) || !this.isActiveBridgeOwner(callId, session)) return;
+						this.scheduleForcedAgentConsult({
+							harness,
+							session,
+							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}`);
+							}
+						});
 					});
+					transcriptPersistence.catch(reportTranscriptFailure);
 					return;
 				}
-				this.manager.processEvent({
-					id: `realtime-bot-${callSid}-${Date.now()}`,
+				transcriptPersistence = this.manager.processEvent({
+					id: `realtime-bot-${callSid}-${randomUUID()}`,
 					type: "call.assistant-speech",
 					callId,
 					providerCallId: callSid,
 					timestamp: Date.now(),
 					transcript: text
-				});
+				}).then(() => {});
+				transcriptPersistence.catch(reportTranscriptFailure);
 			},
-			onToolCall: (toolEvent, sessionLocal) => {
+			onToolCall: async (toolEvent, sessionLocal) => {
+				const generation = continuityGeneration;
+				await transcriptPersistence;
+				if (sessionClosed || generation !== continuityGeneration || !this.isActiveBridgeOwner(callId, sessionLocal)) return;
 				const turnId = harness.ensureTurn();
 				harness.emit({
 					type: "tool.call",
@@ -955,10 +1200,11 @@ 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, userTranscriptOwner);
+				await 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") {
+					continuityGeneration += 1;
 					const turnId = harness.talk.activeTurnId;
 					const owner = nativeConsultOwner.current;
 					if (owner && this.isActiveBridgeOwner(callId, owner)) {
@@ -1036,14 +1282,18 @@ var RealtimeCallHandler = class {
 					provisionalCloseReason ??= reason;
 					return;
 				}
+				if (sessionClosed) {
+					if (reason === "error") {
+						this.streamDisconnectLifecycle.retire(callSid, streamSid);
+						if (ws.readyState === WebSocket.OPEN) ws.close(1011, "Bridge disconnected");
+					}
+					return;
+				}
 				const ownsCallState = this.isActiveBridgeOwner(callId, owner);
-				this.clearActiveBridgeMappings(callId, callSid, owner);
-				this.cancelConsultSession(callId, owner);
-				if (ownsCallState) this.clearUserTranscriptState(callId, userTranscriptOwner);
-				if (reason === "completed" && (!ownsCallState || sessionClosed)) return;
+				if (reason === "completed" && !ownsCallState) return;
+				if (ownsCallState) closeBinding(telephonyBinding, reason);
 				this.streamDisconnectLifecycle.retire(callSid, streamSid);
 				if (ws.readyState === WebSocket.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Bridge disconnected");
-				if (ownsCallState) emitCallEnd(reason);
 			}
 		};
 		let candidate;
@@ -1055,21 +1305,26 @@ var RealtimeCallHandler = class {
 		if (!candidate || provisionalCloseReason) {
 			this.rollbackUserTranscriptOwnerAdoption(callId, userTranscriptAdoption);
 			try {
-				candidate?.close();
+				await drainProviderClose(() => candidate?.close());
 			} catch (error) {
 				console.warn(`[voice-call] Failed to close realtime bridge ${callSid}: ${formatErrorMessage(error)}`);
 			}
 			harness.close();
 			audioPacer.close();
 			const reason = provisionalCloseReason ?? "error";
-			if (!hadPredecessorOnAdmission || !this.activeBridgesByCallId.has(callId)) emitCallEnd(reason);
+			if (!this.activeBridgesByCallId.has(callId)) emitCallEnd(reason);
 			if (ws.readyState === WebSocket.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Failed to create realtime bridge");
 			return null;
 		}
 		const session = candidate;
 		this.commitUserTranscriptOwnerAdoption(callId, userTranscriptAdoption);
 		nativeConsultOwner.current = session;
-		providerHandlesInputAudioBargeIn = session.bridge.handlesInputAudioBargeIn ?? providerHandlesInputAudioBargeIn;
+		const localBargeIn = !(session.bridge.handlesInputAudioBargeIn ?? providerHandlesInputAudioBargeIn) && resolveRealtimeVoiceBargeIn({
+			configuredBargeIn: void 0,
+			interruptResponseOnInputAudio,
+			capabilities,
+			outputAudioMode: session.bridge.outputAudioMode
+		});
 		const previousConsultSession = this.consultSessionsByCallId.get(callId);
 		if (previousConsultSession && previousConsultSession.owner !== session) this.cancelConsultSession(callId, previousConsultSession.owner);
 		this.consultSessionsByCallId.set(callId, {
@@ -1078,12 +1333,13 @@ var RealtimeCallHandler = class {
 		});
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
+			if (sessionClosed) return;
 			if (speechDetector.accept({
 				rms: calculateMulawRms(audio),
 				peak: 0
 			})) {
 				console.log(`[voice-call] realtime local speech detected callId=${callId} providerCallId=${callSid}`);
-				if (!providerHandlesInputAudioBargeIn) cancelOutputAudioForBargeIn("local", (audioPlaybackActive) => {
+				if (localBargeIn) cancelOutputAudioForBargeIn("local", (audioPlaybackActive) => {
 					session.handleBargeIn({ audioPlaybackActive });
 				});
 			}
@@ -1091,18 +1347,18 @@ var RealtimeCallHandler = class {
 			sendAudioToSession(audio);
 		};
 		const closeSession = session.close.bind(session);
+		let sessionClosePromise;
 		session.close = () => {
-			if (sessionClosed) return;
+			if (sessionClosed) return sessionClosePromise ?? Promise.resolve();
 			sessionClosed = true;
-			try {
-				closeSession();
-			} finally {
+			this.cancelConsultSession(callId, session);
+			audioPacer.close();
+			sessionClosePromise = drainProviderClose(closeSession).finally(() => {
 				this.clearActiveBridgeMappings(callId, callSid, session);
-				this.cancelConsultSession(callId, session);
 				this.clearUserTranscriptState(callId, userTranscriptOwner);
 				harness.close();
-				audioPacer.close();
-			}
+			});
+			return sessionClosePromise;
 		};
 		let livenessTimer;
 		const clearLivenessTimer = () => {
@@ -1112,26 +1368,49 @@ var RealtimeCallHandler = class {
 			}
 		};
 		let bindingClosed = false;
+		let bindingClosePromise;
 		const closeBinding = (binding, cause) => {
-			if (bindingClosed) return callEndPromise ?? Promise.resolve();
+			if (bindingClosed) return bindingClosePromise ?? 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 {
+			const finishClose = () => {
+				const stillOwnsCall = this.activeTelephonyBindingsByCallId.get(callId) === binding;
 				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);
+				if (ownsCall && stillOwnsCall && cause && cause !== "disconnect") return emitCallEnd(cause);
+				return Promise.resolve();
+			};
+			let pending;
+			try {
+				pending = Promise.resolve(session.close());
+			} catch (error) {
+				pending = Promise.reject(error instanceof Error ? error : new Error("Realtime provider close failed", { cause: error }));
 			}
-			return termination;
+			bindingClosePromise = pending.then(finishClose, async (error) => {
+				console.warn(`[voice-call] Failed to close realtime bridge ${callSid}: ${formatErrorMessage(error)}`);
+				try {
+					await finishClose();
+				} catch (terminationError) {
+					throw new AggregateError([error, terminationError], "Realtime call cleanup failed", { cause: terminationError });
+				}
+				throw error;
+			});
+			this.trackShutdownWork(bindingClosePromise, this.terminationAttempts);
+			return bindingClosePromise;
 		};
 		const telephonyBinding = {
 			bridge: session,
+			acknowledgeCarrierMark: (markName) => {
+				audioPacer.acknowledgeMark(markName);
+				if (!markName) return;
+				const acknowledge = pendingMarkAcks.get(markName);
+				if (acknowledge) {
+					pendingMarkAcks.delete(markName);
+					acknowledge();
+				}
+			},
 			close: (cause) => closeBinding(telephonyBinding, cause),
 			endCall: () => {
 				closeBinding(telephonyBinding);
@@ -1159,16 +1438,11 @@ var RealtimeCallHandler = class {
 		this.activeTelephonyBindingsByCallId.set(callId, telephonyBinding);
 		telephonyBinding.noteMediaActivity();
 		if (previousTelephonyBinding && previousTelephonyBinding !== telephonyBinding) previousTelephonyBinding.retire();
-		session.connect().catch((error) => {
+		session.connect().catch(async (error) => {
 			console.error("[voice-call] Failed to connect realtime bridge:", error);
-			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");
+				await closeBinding(telephonyBinding, "error");
+			} catch {} finally {
 				ws.close(1011, "Failed to connect");
 			}
 		});
@@ -1257,7 +1531,6 @@ var RealtimeCallHandler = class {
 	cancelNativeConsult(callId, owner) {
 		const state = this.nativeConsultsInFlightByCallId.get(callId);
 		if (!state || state.owner !== owner) return;
-		state.cancelled = true;
 		this.nativeConsultsInFlightByCallId.delete(callId);
 		state.cancel();
 	}
@@ -1421,7 +1694,7 @@ var RealtimeCallHandler = class {
 			}
 		}
 	}
-	prepareCallInManager(callSid, callerMeta = {}) {
+	async prepareCallInManager(callSid, callerMeta = {}) {
 		const baseFields = {
 			providerCallId: callSid,
 			timestamp: Date.now(),
@@ -1429,22 +1702,19 @@ var RealtimeCallHandler = class {
 			...callerMeta.from ? { from: callerMeta.from } : {},
 			...callerMeta.to ? { to: callerMeta.to } : {}
 		};
-		const callRecord = this.resolveRealtimeCall(callSid, callerMeta, baseFields);
+		const callRecord = await this.resolveRealtimeCall(callSid, callerMeta, baseFields);
 		if (!callRecord) return null;
-		const initialGreeting = this.extractInitialGreeting(callRecord);
-		console.log(`[voice-call] Realtime call ${callRecord.callId} initial greeting ${initialGreeting ? "queued" : "absent"}`);
 		return {
 			callRecord,
-			baseFields,
-			initialGreeting
+			baseFields
 		};
 	}
-	resolveRealtimeCall(callSid, callerMeta, baseFields) {
+	async resolveRealtimeCall(callSid, callerMeta, baseFields) {
 		if (callerMeta.callId) {
-			const call = this.manager.getCall(callerMeta.callId);
+			const call = await this.manager.getCallForStream(callerMeta.callId);
 			return call?.providerCallId === callSid ? call : null;
 		}
-		this.manager.processEvent({
+		await this.manager.processEvent({
 			id: `realtime-initiated-${callSid}`,
 			callId: callSid,
 			type: "call.initiated",
@@ -1452,9 +1722,6 @@ var RealtimeCallHandler = class {
 		});
 		return this.manager.getCallByProviderCallId(callSid) ?? null;
 	}
-	extractInitialGreeting(call) {
-		return typeof call.metadata?.initialMessage === "string" ? call.metadata.initialMessage : void 0;
-	}
 	async executeEndCallTool(params) {
 		const binding = this.activeTelephonyBindingsByCallId.get(params.callId);
 		if (!binding || binding.bridge !== params.bridge || !this.isActiveBridgeOwner(params.callId, params.bridge)) return;
@@ -1495,7 +1762,7 @@ var RealtimeCallHandler = class {
 		});
 		binding.endCall();
 	}
-	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness, userTranscriptOwner) {
+	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness, userTranscriptOwner, delegation) {
 		if (name === "openclaw_end_call") {
 			await this.executeEndCallTool({
 				bridge,
@@ -1524,11 +1791,12 @@ var RealtimeCallHandler = class {
 			});
 		};
 		const submitFinalToolResult = async (result) => {
-			await bridge.submitToolResult(bridgeCallId, result);
+			if (!delegation) await bridge.submitToolResult(bridgeCallId, result);
 			emitFinalToolEvent(result);
+			return result;
 		};
 		const submitWorkingResponse = async () => {
-			if (handler && name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME && bridge.bridge.supportsToolResultContinuation && !this.config.fastContext.enabled) {
+			if (!delegation && handler && name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME && bridge.bridge.supportsToolResultContinuation && !this.config.fastContext.enabled) {
 				await bridge.submitToolResult(bridgeCallId, buildRealtimeVoiceAgentConsultWorkingResponse("caller"), { willContinue: true });
 				harness.emit({
 					type: "tool.progress",
@@ -1553,25 +1821,20 @@ var RealtimeCallHandler = class {
 			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({
+				return await submitFinalToolResult({
 					status: "cancelled",
 					message: "OpenClaw cancelled this consult before completion. Do not restart it."
 				});
-				return;
 			}
 			if (forcedConsult) {
-				if (forcedConsult.completedAt || forcedMatch.kind === "already_delivered") {
-					await submitFinalToolResult({
-						status: "already_delivered",
-						message: "OpenClaw already delivered this consult result internally. Do not repeat it."
-					});
-					return;
-				}
+				if (forcedConsult.completedAt || forcedMatch.kind === "already_delivered") return await submitFinalToolResult({
+					status: "already_delivered",
+					message: "OpenClaw already delivered this consult result internally. Do not repeat it."
+				});
 				forcedConsult.sendSpeechPrompt = false;
 				const result = await forcedConsult.promise.catch(buildRealtimeVoiceAgentErrorProviderResult);
 				if (forcedConsult.cancelled || forcedConsult.owner !== bridge || this.forcedConsultsByCallId.get(callId) !== forcedConsult) return;
-				await submitFinalToolResult(result);
-				return;
+				return await submitFinalToolResult(result);
 			}
 			const existingNativeConsult = this.nativeConsultsInFlightByCallId.get(callId);
 			if (existingNativeConsult) {
@@ -1579,8 +1842,7 @@ var RealtimeCallHandler = class {
 				await submitWorkingResponse();
 				const outcome = await waitForNativeConsult(existingNativeConsult);
 				if (outcome.kind === "cancelled") return;
-				await submitFinalToolResult(outcome.result);
-				return;
+				return await submitFinalToolResult(outcome.result);
 			}
 			const abortController = new AbortController();
 			let releaseCancellation = () => {};
@@ -1595,19 +1857,23 @@ var RealtimeCallHandler = class {
 					completeConsult = resolve;
 				}),
 				cancellation,
-				cancelled: false,
+				get cancelled() {
+					return abortController.signal.aborted;
+				},
 				cancel: () => {
 					abortController.abort(/* @__PURE__ */ new Error("Realtime native consult owner was cancelled."));
 					releaseCancellation();
 				}
 			};
+			if (delegation?.signal?.aborted) state.cancel();
+			else delegation?.signal?.addEventListener("abort", state.cancel, { once: true });
 			this.nativeConsultsInFlightByCallId.set(callId, state);
 			(async () => {
 				try {
 					await submitWorkingResponse();
-					if (state.cancelled) return;
+					if (state.cancelled || !this.isActiveBridgeOwner(callId, bridge)) return;
 					await Promise.race([this.waitForConsultTranscriptSettle(callId, userTranscriptOwner, startedAt), state.cancellation]);
-					if (state.cancelled) return;
+					if (state.cancelled || !this.isActiveBridgeOwner(callId, bridge)) return;
 					const context = {
 						partialUserTranscript: this.resolveUserTranscriptContext(callId, userTranscriptOwner),
 						abortSignal: abortController.signal
@@ -1629,10 +1895,11 @@ var RealtimeCallHandler = class {
 				console.log(`[voice-call] realtime tool call completed callId=${callId} tool=${name} status=${failed ? "error" : "ok"} elapsedMs=${Date.now() - startedAt}${error ? ` error=${error}` : ""}`);
 				await submitFinalToolResult(result);
 				if (!failed) this.consumePartialUserTranscript(callId, userTranscriptOwner, state.partialUserTranscript);
+				return result;
 			} finally {
+				delegation?.signal?.removeEventListener("abort", state.cancel);
 				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, userTranscriptOwner) };
@@ -1644,7 +1911,7 @@ var RealtimeCallHandler = class {
 		}
 		const error = hasResultError(result) ? formatErrorMessage(result.error ?? "unknown") : void 0;
 		console.log(`[voice-call] realtime tool call completed callId=${callId} tool=${name} status=${error === void 0 ? "ok" : "error"} elapsedMs=${Date.now() - startedAt}${error ? ` error=${error}` : ""}`);
-		await submitFinalToolResult(result);
+		return await submitFinalToolResult(result);
 	}
 };
 //#endregion