@openclaw/voice-call 2026.7.2-beta.5 → 2026.7.33

package/dist/{realtime-handler-hIVPEZxN.js → .setup/realtime-handler-DWLxvZuO.mjs}

@@ -1,8 +1,7 @@
-import { o as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-CQtitvRd.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
-import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, buildRealtimeVoiceAgentConsultWorkingResponse, calculateMulawRms, createRealtimeVoiceSessionHarness, createSpeechThresholdGate, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult } from "openclaw/plugin-sdk/realtime-voice";
+import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, buildRealtimeVoiceAgentConsultWorkingResponse, createRealtimeVoiceBridgeSession, createRealtimeVoiceForcedConsultCoordinator, createTalkSessionController, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult, recordTalkObservabilityEvent } from "openclaw/plugin-sdk/realtime-voice";
 import { normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import { randomUUID } from "node:crypto";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -12,7 +11,13 @@ import WebSocket$1, { WebSocketServer } from "ws";
 const TELEPHONY_SAMPLE_RATE = 8e3;
 const TELEPHONY_CHUNK_BYTES = 160;
 const TELEPHONY_CHUNK_MS = 20;
+const DEFAULT_SPEECH_RMS_THRESHOLD = .035;
+const DEFAULT_REQUIRED_LOUD_CHUNKS = 4;
+const DEFAULT_REQUIRED_QUIET_CHUNKS = 12;
 const DEFAULT_MAX_QUEUED_AUDIO_BYTES = TELEPHONY_SAMPLE_RATE * 120;
+const PCM16_MAX_AMPLITUDE = 32768;
+const MULAW_LINEAR_SAMPLES = /* @__PURE__ */ new Int16Array(256);
+for (let i = 0; i < MULAW_LINEAR_SAMPLES.length; i += 1) MULAW_LINEAR_SAMPLES[i] = decodeMulawSample(i);
 /** Paces outgoing mulaw audio frames at telephony cadence. */
 var RealtimeAudioPacer = class {
 	constructor(params) {
@@ -107,6 +112,52 @@ var RealtimeAudioPacer = class {
 		if (this.queue.length > 0) this.timer = setTimeout(() => this.pump(), delayMs);
 	}
 };
+/** Calculate normalized RMS from mulaw bytes. */
+function calculateMulawRms(muLaw) {
+	if (muLaw.length === 0) return 0;
+	let sum = 0;
+	for (const sample of muLaw) {
+		const normalized = (MULAW_LINEAR_SAMPLES[sample] ?? 0) / PCM16_MAX_AMPLITUDE;
+		sum += normalized * normalized;
+	}
+	return Math.sqrt(sum / muLaw.length);
+}
+/** Detect likely speech start from consecutive loud mulaw chunks. */
+var RealtimeMulawSpeechStartDetector = class {
+	constructor(params = {}) {
+		this.params = params;
+		this.loudChunks = 0;
+		this.quietChunks = DEFAULT_REQUIRED_QUIET_CHUNKS;
+		this.speaking = false;
+	}
+	/** Accept one mulaw chunk and return true only on transition into speaking. */
+	accept(muLaw) {
+		if (calculateMulawRms(muLaw) >= (this.params.rmsThreshold ?? DEFAULT_SPEECH_RMS_THRESHOLD)) {
+			this.quietChunks = 0;
+			this.loudChunks += 1;
+			const requiredLoudChunks = this.params.requiredLoudChunks ?? DEFAULT_REQUIRED_LOUD_CHUNKS;
+			if (!this.speaking && this.loudChunks >= requiredLoudChunks) {
+				this.speaking = true;
+				return true;
+			}
+			return false;
+		}
+		this.loudChunks = 0;
+		this.quietChunks += 1;
+		const requiredQuietChunks = this.params.requiredQuietChunks ?? DEFAULT_REQUIRED_QUIET_CHUNKS;
+		if (this.quietChunks >= requiredQuietChunks) this.speaking = false;
+		return false;
+	}
+};
+/** Decode one G.711 mulaw byte to a linear PCM sample. */
+function decodeMulawSample(value) {
+	const muLaw = ~value & 255;
+	const sign = muLaw & 128;
+	const exponent = muLaw >> 4 & 7;
+	let sample = ((muLaw & 15) << 3) + 132 << exponent;
+	sample -= 132;
+	return sign ? -sample : sample;
+}
 //#endregion
 //#region extensions/voice-call/src/webhook/stream-frame-adapter.ts
 /** Parse numeric timestamps sent as numbers or integer strings. */
@@ -130,15 +181,22 @@ function readRecordField(record, field) {
 	const value = record[field];
 	return typeof value === "object" && value !== null ? value : void 0;
 }
+/** Normalize base64/base64url padding differences for validation. */
+function normalizeBase64ForCompare(value) {
+	return value.replace(/=+$/u, "").replace(/-/gu, "+").replace(/_/gu, "/");
+}
+/** Return true when a payload round-trips as base64. */
+function isValidBase64Payload(value) {
+	return normalizeBase64ForCompare(Buffer.from(value, "base64").toString("base64")) === normalizeBase64ForCompare(value);
+}
 /** Parse a common provider media frame. */
 function parseMediaFrame(msg) {
 	const mediaData = readRecordField(msg, "media");
 	const payload = typeof mediaData?.payload === "string" ? mediaData.payload : void 0;
-	const canonicalPayload = payload ? canonicalizeVoiceCallMediaBase64(payload) : void 0;
-	if (!canonicalPayload) return { kind: "ignored" };
+	if (!payload || !isValidBase64Payload(payload)) return { kind: "ignored" };
 	return {
 		kind: "media",
-		payloadBase64: canonicalPayload,
+		payloadBase64: payload,
 		timestampMs: parseTimestampMs(mediaData?.timestamp),
 		track: typeof mediaData?.track === "string" ? mediaData.track : void 0
 	};
@@ -271,8 +329,8 @@ var TelnyxStreamFrameAdapter = class {
 //#region extensions/voice-call/src/webhook/realtime-handler.ts
 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 MAX_REALTIME_MESSAGE_BYTES = 262144;
+const MAX_REALTIME_WS_BUFFERED_BYTES = 1048576;
 const FORCED_CONSULT_FALLBACK_DELAY_MS = 200;
 const FORCED_CONSULT_NATIVE_DEDUPE_MS = 2e3;
 const FORCED_CONSULT_RESULT_MAX_CHARS = 1800;
@@ -374,7 +432,7 @@ function buildForcedConsultSpeechPrompt(result) {
 		"Internal OpenClaw consult result is ready.",
 		"Do not call tools for this internal result.",
 		"Speak the following answer to the caller now, briefly and naturally:",
-		trimmed.length <= FORCED_CONSULT_RESULT_MAX_CHARS ? trimmed : `${truncateUtf16Safe(trimmed, FORCED_CONSULT_RESULT_MAX_CHARS - 16).trimEnd()} [truncated]`
+		trimmed.length <= FORCED_CONSULT_RESULT_MAX_CHARS ? trimmed : `${truncateUtf16Safe(trimmed, 1784).trimEnd()} [truncated]`
 	].join("\n");
 }
 function appendRecentTalkEventMetadata(call, event) {
@@ -417,6 +475,7 @@ var RealtimeCallHandler = class {
 		this.partialUserTranscriptUpdatedAtByCallId = /* @__PURE__ */ new Map();
 		this.recentFinalUserTranscriptsByCallId = /* @__PURE__ */ new Map();
 		this.recentFinalUserTranscriptTimersByCallId = /* @__PURE__ */ new Map();
+		this.forcedConsultCoordinatorsByCallId = /* @__PURE__ */ new Map();
 		this.forcedConsultsByCallId = /* @__PURE__ */ new Map();
 		this.nativeConsultsInFlightByCallId = /* @__PURE__ */ new Map();
 		this.publicOrigin = null;
@@ -602,51 +661,56 @@ var RealtimeCallHandler = class {
 		}
 		const { callId, instructions, initialGreetingInstructions } = registration;
 		const callRecord = this.manager.getCallByProviderCallId(callSid);
-		const harness = createRealtimeVoiceSessionHarness({
-			talk: {
-				sessionId: `voice-call:${callId}:realtime`,
-				mode: "realtime",
-				transport: "gateway-relay",
-				brain: "agent-consult",
-				provider: this.realtimeProvider.id
-			},
-			talkPayloads: {
-				turnStarted: () => ({
-					callId,
-					providerCallId: callSid
-				}),
-				turnEnded: (reason) => ({
-					callId,
-					providerCallId: callSid,
-					reason
-				}),
-				inputAudioDelta: (audio) => ({ byteLength: audio.byteLength }),
-				outputAudioStarted: () => ({
-					callId,
-					providerCallId: callSid
-				}),
-				outputAudioDelta: (audio) => ({ byteLength: audio.byteLength }),
-				outputAudioDone: (reason) => ({
-					callId,
-					providerCallId: callSid,
-					reason
-				})
-			},
-			onTalkEvent: (event) => appendRecentTalkEventMetadata(callRecord, event)
-		});
+		const talk = createTalkSessionController({
+			sessionId: `voice-call:${callId}:realtime`,
+			mode: "realtime",
+			transport: "gateway-relay",
+			brain: "agent-consult",
+			provider: this.realtimeProvider.id
+		}, { onEvent: recordTalkObservabilityEvent });
+		const rememberTalkEvent = (event) => {
+			if (event) appendRecentTalkEventMetadata(callRecord, event);
+			return event;
+		};
+		const emitTalkEvent = (input) => {
+			return rememberTalkEvent(talk.emit(input));
+		};
+		const ensureTalkTurn = () => {
+			const turn = talk.ensureTurn({ payload: {
+				callId,
+				providerCallId: callSid
+			} });
+			rememberTalkEvent(turn.event);
+			return turn.turnId;
+		};
+		const endTalkTurn = (reason = "completed") => {
+			const ended = talk.endTurn({ payload: {
+				callId,
+				providerCallId: callSid,
+				reason
+			} });
+			if (ended.ok) rememberTalkEvent(ended.event);
+		};
+		const finishOutputAudio = (reason) => {
+			rememberTalkEvent(talk.finishOutputAudio({ payload: {
+				callId,
+				providerCallId: callSid,
+				reason
+			} }));
+		};
 		const providerHandlesInputAudioBargeIn = this.realtimeProvider.capabilities?.handlesInputAudioBargeIn === true;
 		const cancelOutputAudioForBargeIn = (source, interruptProvider, clearedAudioBytes = 0) => {
-			const outputAudioActive = harness.talk.outputAudioActive;
+			const outputAudioActive = talk.outputAudioActive;
 			const pendingTelephonyAudio = audioPacer.hasPendingAudio();
 			if (source === "provider" && !outputAudioActive && !pendingTelephonyAudio && clearedAudioBytes === 0) return;
-			const interruptedTurnId = harness.talk.activeTurnId;
+			const interruptedTurnId = talk.activeTurnId;
 			interruptProvider?.(outputAudioActive || pendingTelephonyAudio);
 			const clearedBytes = clearedAudioBytes + (source === "local" || pendingTelephonyAudio ? audioPacer.clearAudio() : 0);
 			console.log(`[voice-call] realtime outbound audio cleared by ${source} barge-in callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
 			if (!outputAudioActive || !interruptedTurnId) return;
 			const reason = `${source}-barge-in`;
-			harness.finishOutputAudio(reason);
-			harness.talk.cancelTurn({
+			finishOutputAudio(reason);
+			const cancelled = talk.cancelTurn({
 				turnId: interruptedTurnId,
 				payload: {
 					callId,
@@ -654,8 +718,9 @@ var RealtimeCallHandler = class {
 					reason
 				}
 			});
+			if (cancelled.ok) rememberTalkEvent(cancelled.event);
 		};
-		harness.emit({
+		emitTalkEvent({
 			type: "session.started",
 			payload: {
 				callId,
@@ -697,13 +762,9 @@ var RealtimeCallHandler = class {
 				if (ws.readyState === WebSocket$1.OPEN) ws.close(1013, "Backpressure: paced audio queue exceeded");
 			}
 		});
-		const speechDetector = createSpeechThresholdGate({
-			rmsThreshold: .035,
-			speechFrames: BARGE_IN_REQUIRED_LOUD_CHUNKS,
-			silenceFrames: 12
-		});
+		const speechDetector = new RealtimeMulawSpeechStartDetector({ requiredLoudChunks: BARGE_IN_REQUIRED_LOUD_CHUNKS });
 		const interruptResponseOnInputAudio = typeof this.providerConfig.interruptResponseOnInputAudio === "boolean" ? this.providerConfig.interruptResponseOnInputAudio : void 0;
-		const session = harness.createBridge({
+		const session = createRealtimeVoiceBridgeSession({
 			provider: this.realtimeProvider,
 			cfg: this.coreConfig,
 			providerConfig: this.providerConfig,
@@ -715,38 +776,46 @@ var RealtimeCallHandler = class {
 			audioSink: {
 				isOpen: () => ws.readyState === WebSocket$1.OPEN,
 				sendAudio: (muLaw) => {
-					harness.recordOutputAudio(muLaw);
+					const turnId = ensureTalkTurn();
+					rememberTalkEvent(talk.startOutputAudio({
+						turnId,
+						payload: {
+							callId,
+							providerCallId: callSid
+						}
+					}).event);
+					emitTalkEvent({
+						type: "output.audio.delta",
+						turnId,
+						payload: { byteLength: muLaw.length }
+					});
 					audioPacer.sendAudio(muLaw);
 				},
 				clearAudio: (reason) => {
-					harness.flushOutput(() => {
-						const clearedBytes = audioPacer.clearAudio();
-						if (reason === "barge-in") {
-							cancelOutputAudioForBargeIn("provider", void 0, clearedBytes);
-							return;
-						}
-						console.log(`[voice-call] realtime outbound audio clear requested callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
-						harness.finishOutputAudio("clear");
-					});
+					const clearedBytes = audioPacer.clearAudio();
+					if (reason === "barge-in") {
+						cancelOutputAudioForBargeIn("provider", void 0, clearedBytes);
+						return;
+					}
+					console.log(`[voice-call] realtime outbound audio clear requested callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
+					finishOutputAudio("clear");
 				},
 				sendMark: (markName) => {
 					audioPacer.sendMark(markName);
 				}
 			},
 			onTranscript: (role, text, isFinal) => {
-				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 } : {
-					role,
-					text
-				};
-				harness.emit({
-					type: eventType,
+				const turnId = ensureTalkTurn();
+				emitTalkEvent({
+					type: role === "assistant" ? isFinal ? "output.text.done" : "output.text.delta" : isFinal ? "transcript.done" : "transcript.delta",
 					turnId,
-					payload,
+					payload: role === "assistant" ? { text } : {
+						role,
+						text
+					},
 					final: isFinal
 				});
-				if (role === "user" && isFinal) harness.emit({
+				if (role === "user" && isFinal) emitTalkEvent({
 					type: "input.audio.committed",
 					turnId,
 					payload: {
@@ -782,7 +851,6 @@ var RealtimeCallHandler = class {
 					};
 					this.manager.processEvent(event);
 					this.scheduleForcedAgentConsult({
-						harness,
 						session,
 						callId,
 						callSid,
@@ -804,8 +872,8 @@ var RealtimeCallHandler = class {
 				});
 			},
 			onToolCall: (toolEvent, sessionLocal) => {
-				const turnId = harness.ensureTurn();
-				harness.emit({
+				const turnId = ensureTalkTurn();
+				emitTalkEvent({
 					type: "tool.call",
 					turnId,
 					itemId: toolEvent.itemId,
@@ -816,17 +884,17 @@ 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);
+				this.executeToolCall(sessionLocal, callId, toolEvent.callId || toolEvent.itemId, toolEvent.name, toolEvent.args, turnId, emitTalkEvent);
 			},
 			onEvent: (event) => {
 				if (event.type === "input_audio_buffer.speech_started") {
-					harness.ensureTurn();
+					ensureTalkTurn();
 					return;
 				}
 				if (event.type === "input_audio_buffer.speech_stopped") {
-					const turnId = harness.talk.activeTurnId;
+					const turnId = talk.activeTurnId;
 					if (!turnId) return;
-					harness.emit({
+					emitTalkEvent({
 						type: "input.audio.committed",
 						turnId,
 						payload: {
@@ -839,18 +907,18 @@ var RealtimeCallHandler = class {
 					return;
 				}
 				if (event.type === "response.done") {
-					harness.finishOutputAudio("response.done");
-					harness.endTurn("response.done");
+					finishOutputAudio("response.done");
+					endTalkTurn("response.done");
 					return;
 				}
-				if (event.type === "error") harness.emit({
+				if (event.type === "error") emitTalkEvent({
 					type: "session.error",
 					payload: { message: event.detail ?? "Realtime provider error" },
 					final: true
 				});
 			},
 			onReady: () => {
-				harness.emit({
+				emitTalkEvent({
 					type: "session.ready",
 					payload: {
 						callId,
@@ -860,7 +928,7 @@ var RealtimeCallHandler = class {
 			},
 			onError: (error) => {
 				console.error("[voice-call] realtime voice error:", error.message);
-				harness.emit({
+				emitTalkEvent({
 					type: "session.error",
 					payload: { message: error.message },
 					final: true
@@ -872,8 +940,8 @@ var RealtimeCallHandler = class {
 				this.activeTelephonyClosersByCallId.delete(callId);
 				this.activeTelephonyClosersByCallId.delete(callSid);
 				this.clearUserTranscriptState(callId);
-				harness.finishOutputAudio(reason);
-				harness.emit({
+				finishOutputAudio(reason);
+				emitTalkEvent({
 					type: "session.closed",
 					payload: { reason },
 					final: true
@@ -903,16 +971,17 @@ var RealtimeCallHandler = class {
 		this.activeTelephonyClosersByCallId.set(callSid, closeTelephony);
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
-			if (speechDetector.accept({
-				rms: calculateMulawRms(audio),
-				peak: 0
-			})) {
+			if (speechDetector.accept(audio)) {
 				console.log(`[voice-call] realtime local speech detected callId=${callId} providerCallId=${callSid}`);
 				if (!providerHandlesInputAudioBargeIn) cancelOutputAudioForBargeIn("local", (audioPlaybackActive) => {
 					session.handleBargeIn({ audioPlaybackActive });
 				});
 			}
-			harness.recordInputAudio(audio);
+			emitTalkEvent({
+				type: "input.audio.delta",
+				turnId: ensureTalkTurn(),
+				payload: { byteLength: audio.length }
+			});
 			sendAudioToSession(audio);
 		};
 		const closeSession = session.close.bind(session);
@@ -928,8 +997,7 @@ var RealtimeCallHandler = class {
 				this.activeTelephonyClosersByCallId.delete(callId);
 				this.activeTelephonyClosersByCallId.delete(callSid);
 				this.clearUserTranscriptState(callId);
-				this.forcedConsultsByCallId.delete(callId);
-				harness.close();
+				this.clearForcedConsultState(callId);
 				audioPacer.close();
 			}
 		};
@@ -1012,6 +1080,18 @@ var RealtimeCallHandler = class {
 			});
 		}
 	}
+	clearForcedConsultState(callId) {
+		this.forcedConsultCoordinatorsByCallId.get(callId)?.clear();
+		this.forcedConsultCoordinatorsByCallId.delete(callId);
+		this.forcedConsultsByCallId.delete(callId);
+	}
+	forcedConsultCoordinator(callId) {
+		const existing = this.forcedConsultCoordinatorsByCallId.get(callId);
+		if (existing) return existing;
+		const created = createRealtimeVoiceForcedConsultCoordinator();
+		this.forcedConsultCoordinatorsByCallId.set(callId, created);
+		return created;
+	}
 	closeTelephonyBridge(callIdOrSid, bridge, reason) {
 		const closer = this.activeTelephonyClosersByCallId.get(callIdOrSid);
 		if (closer) {
@@ -1028,7 +1108,7 @@ var RealtimeCallHandler = class {
 		if (!handler) return;
 		const existingForcedConsult = this.forcedConsultsByCallId.get(params.callId);
 		if (existingForcedConsult && !existingForcedConsult.completedAt) return;
-		const coordinator = params.harness.forcedConsults;
+		const coordinator = this.forcedConsultCoordinator(params.callId);
 		if (coordinator.hasRecentNativeConsult(question, { allowUnknownQuestion: true })) return;
 		coordinator.clearPending();
 		const pending = coordinator.prepare(question);
@@ -1044,7 +1124,7 @@ var RealtimeCallHandler = class {
 		});
 	}
 	async runForcedAgentConsult(params) {
-		const coordinator = params.harness.forcedConsults;
+		const coordinator = this.forcedConsultCoordinator(params.callId);
 		coordinator.markStarted(params.handle);
 		const startedAt = Date.now();
 		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}`);
@@ -1136,14 +1216,14 @@ var RealtimeCallHandler = class {
 			reason
 		});
 	}
-	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness) {
+	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, emitTalkEvent) {
 		const handler = this.toolHandlers.get(name);
 		const startedAt = Date.now();
 		const hasResultError = (result) => {
 			return Boolean(result && typeof result === "object" && !Array.isArray(result) && "error" in result);
 		};
 		const emitFinalToolEvent = (result) => {
-			harness.emit({
+			emitTalkEvent?.({
 				type: hasResultError(result) ? "tool.error" : "tool.result",
 				turnId,
 				callId: bridgeCallId,
@@ -1154,14 +1234,13 @@ var RealtimeCallHandler = class {
 				final: true
 			});
 		};
-		const submitFinalToolResult = async (result) => {
-			await bridge.submitToolResult(bridgeCallId, result);
+		const submitFinalToolResult = (result) => {
+			bridge.submitToolResult(bridgeCallId, result);
 			emitFinalToolEvent(result);
 		};
-		const submitWorkingResponse = async () => {
+		const submitWorkingResponse = () => {
 			if (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({
+				emitTalkEvent?.({
 					type: "tool.progress",
 					turnId,
 					callId: bridgeCallId,
@@ -1170,66 +1249,56 @@ var RealtimeCallHandler = class {
 						status: "working"
 					}
 				});
+				bridge.submitToolResult(bridgeCallId, buildRealtimeVoiceAgentConsultWorkingResponse("caller"), { willContinue: true });
 			}
 		};
 		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
-			const coordinator = harness.forcedConsults;
+			const coordinator = this.forcedConsultCoordinator(callId);
 			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);
-			if (forcedMatch.kind === "already_delivered" && coordinator.isCancelled(forcedMatch.handle)) {
-				if (forcedConsult) forcedConsult.sendSpeechPrompt = false;
-				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({
+					submitFinalToolResult({
 						status: "already_delivered",
 						message: "OpenClaw already delivered this consult result internally. Do not repeat it."
 					});
 					return;
 				}
 				forcedConsult.sendSpeechPrompt = false;
-				await submitFinalToolResult(await forcedConsult.promise.catch((error) => ({ error: formatErrorMessage(error) })));
+				submitFinalToolResult(await forcedConsult.promise.catch((error) => ({ error: formatErrorMessage(error) })));
 				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);
+				submitWorkingResponse();
+				submitFinalToolResult(await existingNativeConsult.promise);
 				return;
 			}
+			submitWorkingResponse();
 			const state = {
 				startedAt,
 				promise: Promise.resolve()
 			};
-			state.promise = submitWorkingResponse().then(async () => {
-				try {
-					await this.waitForConsultTranscriptSettle(callId, startedAt);
-					const context = { partialUserTranscript: this.resolveUserTranscriptContext(callId) };
-					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)}`);
-					return !handler ? { error: `Tool "${name}" not available` } : await handler(handlerArgs, callId, context);
-				} catch (error) {
-					return { error: formatErrorMessage(error) };
-				}
-			});
+			state.promise = (async () => {
+				await this.waitForConsultTranscriptSettle(callId, startedAt);
+				const context = { partialUserTranscript: this.resolveUserTranscriptContext(callId) };
+				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)}`);
+				return !handler ? { error: `Tool "${name}" not available` } : await handler(handlerArgs, callId, context);
+			})().catch((error) => ({ error: formatErrorMessage(error) }));
 			this.nativeConsultsInFlightByCallId.set(callId, state);
 			try {
 				const result = await state.promise;
 				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);
+				submitFinalToolResult(result);
 				if (status === "ok") this.consumePartialUserTranscript(callId, state.partialUserTranscript);
 			} finally {
 				if (this.nativeConsultsInFlightByCallId.get(callId) === state) this.nativeConsultsInFlightByCallId.delete(callId);
@@ -1243,7 +1312,7 @@ var RealtimeCallHandler = class {
 		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);
+		submitFinalToolResult(result);
 		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME && status === "ok") this.consumePartialUserTranscript(callId, context.partialUserTranscript);
 	}
 };

package/dist/{response-generator-z6M9229t.js → .setup/response-generator-DoC6lfcm.mjs}

@@ -1,7 +1,8 @@
-import { h as resolveCallAgentId, m as resolveVoiceResponseModel, x as resolveVoiceCallSessionKey } from "./runtime-entry-CQtitvRd.js";
+import { s as resolveVoiceCallSessionKey } from "./config-BBpso-fA.mjs";
+import { m as resolveCallAgentId, p as resolveVoiceResponseModel } from "./runtime-entry-CH-CV0Sf.mjs";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
-import { ModelSelectionLockedError, applyModelOverrideToSessionEntry, resolvePersistedSessionRuntimeId } from "openclaw/plugin-sdk/model-session-runtime";
+import { applyModelOverrideToSessionEntry } from "openclaw/plugin-sdk/model-session-runtime";
 //#region extensions/voice-call/src/response-generator.ts
 /**
 * Voice call response generator - uses the embedded OpenClaw agent for tool support.
@@ -66,11 +67,7 @@ function sanitizePlainSpokenText(text) {
 	const withoutCodeFences = text.replace(/```[\s\S]*?```/g, " ").trim();
 	if (!withoutCodeFences) return null;
 	const paragraphs = normalizeStringEntries(withoutCodeFences.split(/\n\s*\n+/));
-	while (paragraphs.length > 1) {
-		const firstParagraph = paragraphs.at(0);
-		if (!firstParagraph || !isLikelyMetaReasoningParagraph(firstParagraph)) break;
-		paragraphs.shift();
-	}
+	while (paragraphs.length > 1 && isLikelyMetaReasoningParagraph(paragraphs[0])) paragraphs.shift();
 	return normalizeSpokenText(paragraphs.join(" "));
 }
 function extractSpokenTextFromPayloads(payloads) {
@@ -107,7 +104,7 @@ function resolveVoiceSandboxSessionKey(agentId, sessionKey) {
 * Uses the same agent infrastructure as messaging for consistent behavior.
 */
 async function generateVoiceResponse(params) {
-	const { voiceConfig, callId, sessionKey, from, transcript, userMessage, coreConfig, agentRuntime, onEarlyText } = params;
+	const { voiceConfig, callId, sessionKey, from, senderIsOwner, transcript, userMessage, coreConfig, agentRuntime, onEarlyText } = params;
 	if (!coreConfig) return {
 		text: null,
 		deliveredEarly: false,
@@ -145,7 +142,6 @@ async function generateVoiceResponse(params) {
 				agentRuntime
 			});
 			let sessionEntry = existingSessionEntry;
-			if (sessionEntry?.modelSelectionLocked === true && voiceConfig.responseModel) throw new ModelSelectionLockedError();
 			if (!sessionEntry?.sessionId || voiceConfig.responseModel) sessionEntry = await agentRuntime.session.patchSessionEntry({
 				storePath,
 				sessionKey: resolvedSessionKey,
@@ -177,8 +173,6 @@ async function generateVoiceResponse(params) {
 				error: "Voice response session could not be initialized"
 			};
 			const sessionId = sessionEntry.sessionId;
-			const modelSelectionLocked = sessionEntry.modelSelectionLocked === true;
-			const persistedRuntimeId = resolvePersistedSessionRuntimeId(sessionEntry);
 			const thinkLevel = agentRuntime.resolveThinkingDefault({
 				cfg,
 				provider,
@@ -213,11 +207,6 @@ async function generateVoiceResponse(params) {
 				prompt: userMessage,
 				provider,
 				model,
-				modelSelectionLocked,
-				...persistedRuntimeId ? {
-					agentHarnessId: persistedRuntimeId,
-					agentHarnessRuntimeOverride: persistedRuntimeId
-				} : {},
 				thinkLevel,
 				verboseLevel: "off",
 				timeoutMs,
@@ -225,6 +214,7 @@ async function generateVoiceResponse(params) {
 				lane: "voice",
 				extraSystemPrompt,
 				agentDir,
+				senderIsOwner,
 				toolsAllow,
 				abortSignal,
 				blockReplyBreak: "text_end",
@@ -271,11 +261,6 @@ async function generateVoiceResponse(params) {
 			};
 		});
 	} catch (err) {
-		if (err instanceof ModelSelectionLockedError) return {
-			text: null,
-			deliveredEarly: false,
-			error: err.message
-		};
 		console.error(`[voice-call] Response generation failed:`, err);
 		return {
 			text: null,