@openclaw/voice-call 2026.8.1-beta.2 → 2026.8.1-beta.3

package/dist/{mock-BCq0q36l.js → mock-Dv7KxYGt.js}

@@ -79,10 +79,12 @@ var MockProvider = class {
 			}
 			case "call.speech": {
 				const payload = evt;
+				const transcript = payload.transcript ?? "";
+				if (!transcript.trim()) return null;
 				return {
 					...base,
 					type: evt.type,
-					transcript: payload.transcript ?? "",
+					transcript,
 					isFinal: payload.isFinal ?? true,
 					confidence: payload.confidence
 				};

package/dist/{plivo-DbI17uAc.js → plivo-BbVnahnQ.js}

@@ -1,5 +1,5 @@
-import { _ as escapeXml, s as getHeader } from "./runtime-entry-F13eJ4pp.js";
-import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-DEDwgf4J.js";
+import { _ as escapeXml, s as getHeader } from "./runtime-entry-DK8kPCGC.js";
+import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-j4OEG0fR.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/plivo.ts

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

@@ -1,17 +1,18 @@
-import { o as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-F13eJ4pp.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 { 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 { randomUUID } from "node:crypto";
 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";
 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. */
@@ -23,6 +24,7 @@ var RealtimeAudioPacer = class {
 		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) {
@@ -37,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;
 		}
@@ -59,6 +61,7 @@ var RealtimeAudioPacer = class {
 		this.clearTimer();
 		this.resetQueue();
 		this.queuedAudioBytes = 0;
+		this.streamClockMs = null;
 		this.params.send(this.params.serializer.clear());
 		return clearedAudioBytes;
 	}
@@ -72,6 +75,7 @@ var RealtimeAudioPacer = class {
 		this.clearTimer();
 		this.resetQueue();
 		this.queuedAudioBytes = 0;
+		this.streamClockMs = null;
 	}
 	/** Clear the scheduled pump timer. */
 	clearTimer() {
@@ -110,25 +114,34 @@ var RealtimeAudioPacer = class {
 		this.queue.length = 0;
 		this.queueHead = 0;
 	}
-	/** Send one queued item and schedule the next send based on audio duration. */
+	/** Fill the provider playout cushion, then wake at the next timeline boundary. */
 	pump() {
 		this.timer = null;
 		if (this.closed) return;
-		const item = this.takeNextItem();
-		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.resetQueue();
-			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.pendingQueueSize > 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
@@ -144,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) {
@@ -297,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;
@@ -429,25 +442,24 @@ 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.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;
@@ -457,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 = "";
@@ -513,10 +522,10 @@ var RealtimeCallHandler = class {
 			maxPayload: MAX_REALTIME_MESSAGE_BYTES
 		}).handleUpgrade(request, socket, head, (ws) => {
 			this.activeSockets.add(ws);
-			let bridge = null;
+			let telephonyBinding = null;
 			let initialized = false;
 			let activeCallSid = "unknown";
-			let stopReceived = false;
+			let activeStreamSid = "unknown";
 			let lastMediaTimestamp;
 			let lastMediaGapWarnAt = 0;
 			ws.on("message", (data) => {
@@ -527,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;
@@ -546,33 +558,31 @@ 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) => {
+			ws.on("close", () => {
 				this.activeSockets.delete(ws);
-				const reason = this.serverClosingSockets.has(ws) || stopReceived || code === 1e3 || code === 1005 ? "completed" : "error";
-				this.closeTelephonyBridge(activeCallSid, bridge, reason);
+				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);
@@ -593,7 +603,8 @@ var RealtimeCallHandler = class {
 			this.serverClosingSockets.add(ws);
 			ws.once("close", () => resolve());
 			ws.terminate();
-		}))]).then(() => {
+		}))]).then(async () => {
+			await Promise.all(this.terminationAttempts);
 			this.pendingStreamTokens.clear();
 		}).finally(() => {
 			this.closing = false;
@@ -635,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) {
@@ -658,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: () => ({
@@ -697,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();
@@ -727,20 +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);
-			if (reason !== "error") return;
-			Promise.resolve(this.provider.hangupCall({
-				callId,
-				providerCallId: callSid,
-				reason
-			})).catch((error) => {
-				console.warn(`[voice-call] Failed to hang up realtime call ${callSid}: ${formatErrorMessage(error)}`);
-			});
-		};
 		const sendString = (message) => {
 			if (ws.readyState !== WebSocket$1.OPEN) return false;
 			if (ws.bufferedAmount > MAX_REALTIME_WS_BUFFERED_BYTES) {
@@ -773,15 +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 hadPredecessorOnAdmission = this.activeBridgesByCallId.has(callId);
+		const interruptResponseOnInputAudio = typeof providerConfig.interruptResponseOnInputAudio === "boolean" ? providerConfig.interruptResponseOnInputAudio : void 0;
 		const nativeConsultOwner = {};
 		const userTranscriptAdoption = this.beginUserTranscriptOwnerAdoption(callId);
 		const userTranscriptOwner = userTranscriptAdoption.owner;
 		const bridgeParams = {
-			provider: this.realtimeProvider,
+			provider: realtimeProvider,
 			cfg: this.coreConfig,
-			providerConfig: this.providerConfig,
+			agentId,
+			providerConfig,
 			interruptResponseOnInputAudio,
 			instructions,
 			tools: this.config.tools,
@@ -981,6 +1027,7 @@ var RealtimeCallHandler = class {
 					final: true
 				});
 				if (reason !== "error") return;
+				this.streamDisconnectLifecycle.retire(callSid, streamSid);
 				if (ws.readyState === WebSocket$1.OPEN) ws.close(1011, "Bridge disconnected");
 				if (owner && !ownsCallState || !owner && hadPredecessorOnAdmission && this.activeBridgesByCallId.has(callId)) return;
 				emitCallEnd("error");
@@ -1001,27 +1048,12 @@ var RealtimeCallHandler = class {
 		this.commitUserTranscriptOwnerAdoption(callId, userTranscriptAdoption);
 		nativeConsultOwner.current = session;
 		providerHandlesInputAudioBargeIn = session.bridge.handlesInputAudioBargeIn ?? providerHandlesInputAudioBargeIn;
-		const closeTelephony = (reason) => {
-			try {
-				session.close();
-			} finally {
-				emitCallEnd(reason);
-			}
-		};
 		const previousConsultSession = this.consultSessionsByCallId.get(callId);
 		if (previousConsultSession && previousConsultSession.owner !== session) this.cancelConsultSession(callId, previousConsultSession.owner);
 		this.consultSessionsByCallId.set(callId, {
 			owner: session,
 			coordinator: harness.forcedConsults
 		});
-		this.activeBridgesByCallId.set(callId, session);
-		this.activeBridgesByCallId.set(callSid, session);
-		const telephonyCloser = {
-			owner: session,
-			close: closeTelephony
-		};
-		this.activeTelephonyClosersByCallId.set(callId, telephonyCloser);
-		this.activeTelephonyClosersByCallId.set(callSid, telephonyCloser);
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
 			if (speechDetector.accept({
@@ -1051,9 +1083,65 @@ var RealtimeCallHandler = class {
 				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);
 			const ownsCallState = this.isActiveBridgeOwner(callId, session);
+			this.streamDisconnectLifecycle.retire(callSid, streamSid);
 			try {
 				session.close();
 			} catch (closeError) {
@@ -1063,7 +1151,7 @@ var RealtimeCallHandler = class {
 				ws.close(1011, "Failed to connect");
 			}
 		});
-		return session;
+		return telephonyBinding;
 	}
 	beginUserTranscriptOwnerAdoption(callId) {
 		const adoption = {
@@ -1187,9 +1275,11 @@ var RealtimeCallHandler = class {
 		for (const key of [callId, callSid]) {
 			if (this.activeBridgesByCallId.get(key) !== owner) continue;
 			this.activeBridgesByCallId.delete(key);
-			this.activeTelephonyClosersByCallId.delete(key);
 		}
 	}
+	clearActiveTelephonyBinding(callId, binding) {
+		if (this.activeTelephonyBindingsByCallId.get(callId) === binding) this.activeTelephonyBindingsByCallId.delete(callId);
+	}
 	resolveUserTranscriptContext(callId, owner) {
 		const state = this.getUserTranscriptState(callId, owner);
 		return state?.partial ?? state?.recentFinal;
@@ -1228,14 +1318,6 @@ var RealtimeCallHandler = class {
 			});
 		}
 	}
-	closeTelephonyBridge(callIdOrSid, bridge, reason) {
-		const closer = this.activeTelephonyClosersByCallId.get(callIdOrSid);
-		if (closer && closer.owner === bridge) {
-			closer.close(reason);
-			return;
-		}
-		bridge?.close();
-	}
 	scheduleForcedAgentConsult(params) {
 		if (this.config.consultPolicy !== "always" || this.activeBridgesByCallId.get(params.callId) !== params.session) return;
 		const question = params.transcript.trim();
@@ -1312,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(),
@@ -1324,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) {
@@ -1354,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, 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) => {