@openclaw/voice-call 2026.7.2-beta.2 → 2026.7.2-beta.4

package/README.md

@@ -115,7 +115,7 @@ See the plugin docs for recommended ranges and production examples:
 
 ## TTS for calls
 
-Voice Call uses the core `messages.tts` configuration for
+Voice Call uses the core `tts` configuration for
 streaming speech on calls. Override examples and provider caveats live here:
 `https://docs.openclaw.ai/plugins/voice-call#tts-for-calls`
 

package/dist/doctor-contract-api.js

@@ -63,6 +63,7 @@ function describeVoiceCallSchemaMigration(migration) {
 		case "agent-databases-composite-primary-key": return "agent database registry primary key -> agent_id,path";
 		case "audit-events-v2": return "audit event ledger -> versioned message lifecycle schema";
 		case "operator-approvals-system-agent": return "operator approvals -> OpenClaw system changes";
+		case "session-watch-cursor-provenance-v4": return "session watch cursors -> provenance column";
 		case "strict-tables-v3": return "tables -> SQLite STRICT typing";
 	}
 	return migration.kind;

package/dist/{guarded-json-api-BKOgUU1q.js → guarded-json-api-Dxhe25Zi.js}

@@ -1,6 +1,6 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
-import { n as normalizeProxyIp, o as getHeader } from "./runtime-entry-DSgyqIwE.js";
+import { n as normalizeProxyIp, s as getHeader } from "./runtime-entry-CQtitvRd.js";
 import { n as markWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-aaP79dI8.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
@@ -462,7 +462,6 @@ function verifyPlivoWebhook(ctx, authToken, options) {
 	if (options?.publicUrl) try {
 		const req = new URL(reconstructed);
 		const base = new URL(options.publicUrl);
-		base.pathname = req.pathname;
 		base.search = req.search;
 		verificationUrl = base.toString();
 	} catch {

package/dist/index.js

@@ -1,6 +1,6 @@
 import { definePluginEntry, sleep } from "./runtime-api.js";
 import "./api.js";
-import { c as cleanupTailscaleExposureRoute, h as resolveUserPath, l as getTailscaleSelfInfo, s as resolveWebhookExposureStatus, t as createVoiceCallRuntime, u as setupTailscaleExposureRoute, v as VoiceCallConfigSchema, x as validateProviderConfig, y as resolveVoiceCallConfig } from "./runtime-entry-DSgyqIwE.js";
+import { S as validateProviderConfig, b as resolveVoiceCallConfig, c as resolveWebhookExposureStatus, d as setupTailscaleExposureRoute, g as resolveUserPath, l as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime, u as getTailscaleSelfInfo, y as VoiceCallConfigSchema } from "./runtime-entry-CQtitvRd.js";
 import { g as setVoiceCallStateRuntime, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-nYL-yM0S.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ErrorCodes, callGatewayFromCli, errorShape } from "openclaw/plugin-sdk/gateway-runtime";
@@ -87,13 +87,17 @@ function readCompletedContinueResult(payload) {
 }
 async function pollVoiceCallContinueGateway(params) {
 	const deadlineMs = resolveVoiceCallDeadlineMs(params.timeoutMs);
-	while (Date.now() <= deadlineMs) {
-		const gateway = await callVoiceCallGateway("voicecall.continue.result", { operationId: params.operationId }, { timeoutMs: VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS });
+	for (;;) {
+		const remainingMs = deadlineMs - Date.now();
+		if (remainingMs <= 0) break;
+		const gateway = await callVoiceCallGateway("voicecall.continue.result", { operationId: params.operationId }, { timeoutMs: Math.min(VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS, remainingMs) });
 		if (!gateway.ok) throw new Error(`gateway unavailable while waiting for voicecall continue result: ${formatErrorMessage(gateway.error)}`);
 		const result = readCompletedContinueResult(gateway.payload);
 		if (result.status === "completed") return result.result;
 		if (result.status === "failed") throw new Error(result.error);
-		await sleep(Math.min(VOICE_CALL_GATEWAY_POLL_INTERVAL_MS, Math.max(1, deadlineMs - Date.now())));
+		const sleepMs = Math.min(VOICE_CALL_GATEWAY_POLL_INTERVAL_MS, deadlineMs - Date.now());
+		if (sleepMs <= 0) break;
+		await sleep(sleepMs);
 	}
 	throw new Error("voicecall continue timed out waiting for gateway operation");
 }
@@ -533,7 +537,7 @@ const VOICE_CALL_CONTINUE_OPERATION_CLEANUP_MS = 300 * 1e3;
 function createVoiceCallContinueOperationStore(params) {
 	const operations = /* @__PURE__ */ new Map();
 	const resolvePollTimeoutMs = (rt) => {
-		const ttsTimeoutMs = rt.config.tts?.timeoutMs ?? params.config.tts?.timeoutMs ?? params.coreConfig.messages?.tts?.timeoutMs ?? 8e3;
+		const ttsTimeoutMs = rt.config.tts?.timeoutMs ?? params.config.tts?.timeoutMs ?? params.coreConfig.tts?.timeoutMs ?? 8e3;
 		return resolveTimerTimeoutMs((rt.config.transcriptTimeoutMs ?? params.config.transcriptTimeoutMs) + ttsTimeoutMs + VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS, VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS);
 	};
 	const scheduleCleanup = (operationId) => {
@@ -822,7 +826,7 @@ const voiceCallConfigSchema = {
 		},
 		"tts.provider": {
 			label: "TTS Provider Override",
-			help: "Deep-merges with messages.tts (Microsoft is ignored for calls).",
+			help: "Deep-merges with tts (Microsoft is ignored for calls).",
 			advanced: true
 		},
 		"tts.providers": {

package/dist/{plivo-ByAIoPFp.js → plivo-B-KvPVji.js}

@@ -1,5 +1,5 @@
-import { g as escapeXml, o as getHeader } from "./runtime-entry-DSgyqIwE.js";
-import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-BKOgUU1q.js";
+import { _ as escapeXml, s as getHeader } from "./runtime-entry-CQtitvRd.js";
+import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-Dxhe25Zi.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/plivo.ts
@@ -371,7 +371,6 @@ var PlivoProvider = class PlivoProvider {
 		try {
 			if (this.options.publicUrl) {
 				const base = new URL(this.options.publicUrl);
-				base.pathname = new URL(ctx.url).pathname;
 				return `${base.origin}${base.pathname}`;
 			}
 			const u = new URL(reconstructWebhookUrl(ctx, {

package/dist/{realtime-handler-DJk-eYyf.js → realtime-handler-hIVPEZxN.js}

@@ -1,7 +1,8 @@
+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, createRealtimeVoiceBridgeSession, createRealtimeVoiceForcedConsultCoordinator, createTalkSessionController, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult, recordTalkObservabilityEvent } from "openclaw/plugin-sdk/realtime-voice";
+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 { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -11,13 +12,7 @@ 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) {
@@ -112,52 +107,6 @@ 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. */
@@ -181,22 +130,15 @@ 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;
-	if (!payload || !isValidBase64Payload(payload)) return { kind: "ignored" };
+	const canonicalPayload = payload ? canonicalizeVoiceCallMediaBase64(payload) : void 0;
+	if (!canonicalPayload) return { kind: "ignored" };
 	return {
 		kind: "media",
-		payloadBase64: payload,
+		payloadBase64: canonicalPayload,
 		timestampMs: parseTimestampMs(mediaData?.timestamp),
 		track: typeof mediaData?.track === "string" ? mediaData.track : void 0
 	};
@@ -475,7 +417,6 @@ 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;
@@ -661,56 +602,51 @@ var RealtimeCallHandler = class {
 		}
 		const { callId, instructions, initialGreetingInstructions } = registration;
 		const callRecord = this.manager.getCallByProviderCallId(callSid);
-		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 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 providerHandlesInputAudioBargeIn = this.realtimeProvider.capabilities?.handlesInputAudioBargeIn === true;
 		const cancelOutputAudioForBargeIn = (source, interruptProvider, clearedAudioBytes = 0) => {
-			const outputAudioActive = talk.outputAudioActive;
+			const outputAudioActive = harness.talk.outputAudioActive;
 			const pendingTelephonyAudio = audioPacer.hasPendingAudio();
 			if (source === "provider" && !outputAudioActive && !pendingTelephonyAudio && clearedAudioBytes === 0) return;
-			const interruptedTurnId = talk.activeTurnId;
+			const interruptedTurnId = harness.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`;
-			finishOutputAudio(reason);
-			const cancelled = talk.cancelTurn({
+			harness.finishOutputAudio(reason);
+			harness.talk.cancelTurn({
 				turnId: interruptedTurnId,
 				payload: {
 					callId,
@@ -718,9 +654,8 @@ var RealtimeCallHandler = class {
 					reason
 				}
 			});
-			if (cancelled.ok) rememberTalkEvent(cancelled.event);
 		};
-		emitTalkEvent({
+		harness.emit({
 			type: "session.started",
 			payload: {
 				callId,
@@ -762,9 +697,13 @@ var RealtimeCallHandler = class {
 				if (ws.readyState === WebSocket$1.OPEN) ws.close(1013, "Backpressure: paced audio queue exceeded");
 			}
 		});
-		const speechDetector = new RealtimeMulawSpeechStartDetector({ requiredLoudChunks: BARGE_IN_REQUIRED_LOUD_CHUNKS });
+		const speechDetector = createSpeechThresholdGate({
+			rmsThreshold: .035,
+			speechFrames: BARGE_IN_REQUIRED_LOUD_CHUNKS,
+			silenceFrames: 12
+		});
 		const interruptResponseOnInputAudio = typeof this.providerConfig.interruptResponseOnInputAudio === "boolean" ? this.providerConfig.interruptResponseOnInputAudio : void 0;
-		const session = createRealtimeVoiceBridgeSession({
+		const session = harness.createBridge({
 			provider: this.realtimeProvider,
 			cfg: this.coreConfig,
 			providerConfig: this.providerConfig,
@@ -776,46 +715,38 @@ var RealtimeCallHandler = class {
 			audioSink: {
 				isOpen: () => ws.readyState === WebSocket$1.OPEN,
 				sendAudio: (muLaw) => {
-					const turnId = ensureTalkTurn();
-					rememberTalkEvent(talk.startOutputAudio({
-						turnId,
-						payload: {
-							callId,
-							providerCallId: callSid
-						}
-					}).event);
-					emitTalkEvent({
-						type: "output.audio.delta",
-						turnId,
-						payload: { byteLength: muLaw.length }
-					});
+					harness.recordOutputAudio(muLaw);
 					audioPacer.sendAudio(muLaw);
 				},
 				clearAudio: (reason) => {
-					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");
+					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");
+					});
 				},
 				sendMark: (markName) => {
 					audioPacer.sendMark(markName);
 				}
 			},
 			onTranscript: (role, text, isFinal) => {
-				const turnId = ensureTalkTurn();
-				emitTalkEvent({
-					type: role === "assistant" ? isFinal ? "output.text.done" : "output.text.delta" : isFinal ? "transcript.done" : "transcript.delta",
+				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,
 					turnId,
-					payload: role === "assistant" ? { text } : {
-						role,
-						text
-					},
+					payload,
 					final: isFinal
 				});
-				if (role === "user" && isFinal) emitTalkEvent({
+				if (role === "user" && isFinal) harness.emit({
 					type: "input.audio.committed",
 					turnId,
 					payload: {
@@ -851,6 +782,7 @@ var RealtimeCallHandler = class {
 					};
 					this.manager.processEvent(event);
 					this.scheduleForcedAgentConsult({
+						harness,
 						session,
 						callId,
 						callSid,
@@ -872,8 +804,8 @@ var RealtimeCallHandler = class {
 				});
 			},
 			onToolCall: (toolEvent, sessionLocal) => {
-				const turnId = ensureTalkTurn();
-				emitTalkEvent({
+				const turnId = harness.ensureTurn();
+				harness.emit({
 					type: "tool.call",
 					turnId,
 					itemId: toolEvent.itemId,
@@ -884,17 +816,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, emitTalkEvent);
+				return this.executeToolCall(sessionLocal, callId, toolEvent.callId || toolEvent.itemId, toolEvent.name, toolEvent.args, turnId, harness);
 			},
 			onEvent: (event) => {
 				if (event.type === "input_audio_buffer.speech_started") {
-					ensureTalkTurn();
+					harness.ensureTurn();
 					return;
 				}
 				if (event.type === "input_audio_buffer.speech_stopped") {
-					const turnId = talk.activeTurnId;
+					const turnId = harness.talk.activeTurnId;
 					if (!turnId) return;
-					emitTalkEvent({
+					harness.emit({
 						type: "input.audio.committed",
 						turnId,
 						payload: {
@@ -907,18 +839,18 @@ var RealtimeCallHandler = class {
 					return;
 				}
 				if (event.type === "response.done") {
-					finishOutputAudio("response.done");
-					endTalkTurn("response.done");
+					harness.finishOutputAudio("response.done");
+					harness.endTurn("response.done");
 					return;
 				}
-				if (event.type === "error") emitTalkEvent({
+				if (event.type === "error") harness.emit({
 					type: "session.error",
 					payload: { message: event.detail ?? "Realtime provider error" },
 					final: true
 				});
 			},
 			onReady: () => {
-				emitTalkEvent({
+				harness.emit({
 					type: "session.ready",
 					payload: {
 						callId,
@@ -928,7 +860,7 @@ var RealtimeCallHandler = class {
 			},
 			onError: (error) => {
 				console.error("[voice-call] realtime voice error:", error.message);
-				emitTalkEvent({
+				harness.emit({
 					type: "session.error",
 					payload: { message: error.message },
 					final: true
@@ -940,8 +872,8 @@ var RealtimeCallHandler = class {
 				this.activeTelephonyClosersByCallId.delete(callId);
 				this.activeTelephonyClosersByCallId.delete(callSid);
 				this.clearUserTranscriptState(callId);
-				finishOutputAudio(reason);
-				emitTalkEvent({
+				harness.finishOutputAudio(reason);
+				harness.emit({
 					type: "session.closed",
 					payload: { reason },
 					final: true
@@ -971,17 +903,16 @@ var RealtimeCallHandler = class {
 		this.activeTelephonyClosersByCallId.set(callSid, closeTelephony);
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
-			if (speechDetector.accept(audio)) {
+			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) => {
 					session.handleBargeIn({ audioPlaybackActive });
 				});
 			}
-			emitTalkEvent({
-				type: "input.audio.delta",
-				turnId: ensureTalkTurn(),
-				payload: { byteLength: audio.length }
-			});
+			harness.recordInputAudio(audio);
 			sendAudioToSession(audio);
 		};
 		const closeSession = session.close.bind(session);
@@ -997,7 +928,8 @@ var RealtimeCallHandler = class {
 				this.activeTelephonyClosersByCallId.delete(callId);
 				this.activeTelephonyClosersByCallId.delete(callSid);
 				this.clearUserTranscriptState(callId);
-				this.clearForcedConsultState(callId);
+				this.forcedConsultsByCallId.delete(callId);
+				harness.close();
 				audioPacer.close();
 			}
 		};
@@ -1080,18 +1012,6 @@ 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) {
@@ -1108,7 +1028,7 @@ var RealtimeCallHandler = class {
 		if (!handler) return;
 		const existingForcedConsult = this.forcedConsultsByCallId.get(params.callId);
 		if (existingForcedConsult && !existingForcedConsult.completedAt) return;
-		const coordinator = this.forcedConsultCoordinator(params.callId);
+		const coordinator = params.harness.forcedConsults;
 		if (coordinator.hasRecentNativeConsult(question, { allowUnknownQuestion: true })) return;
 		coordinator.clearPending();
 		const pending = coordinator.prepare(question);
@@ -1124,7 +1044,7 @@ var RealtimeCallHandler = class {
 		});
 	}
 	async runForcedAgentConsult(params) {
-		const coordinator = this.forcedConsultCoordinator(params.callId);
+		const coordinator = params.harness.forcedConsults;
 		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}`);
@@ -1216,14 +1136,14 @@ var RealtimeCallHandler = class {
 			reason
 		});
 	}
-	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, emitTalkEvent) {
+	async executeToolCall(bridge, callId, bridgeCallId, name, args, turnId, harness) {
 		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) => {
-			emitTalkEvent?.({
+			harness.emit({
 				type: hasResultError(result) ? "tool.error" : "tool.result",
 				turnId,
 				callId: bridgeCallId,
@@ -1241,7 +1161,7 @@ var RealtimeCallHandler = class {
 		const submitWorkingResponse = async () => {
 			if (handler && name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME && bridge.bridge.supportsToolResultContinuation && !this.config.fastContext.enabled) {
 				await bridge.submitToolResult(bridgeCallId, buildRealtimeVoiceAgentConsultWorkingResponse("caller"), { willContinue: true });
-				emitTalkEvent?.({
+				harness.emit({
 					type: "tool.progress",
 					turnId,
 					callId: bridgeCallId,
@@ -1253,7 +1173,7 @@ var RealtimeCallHandler = class {
 			}
 		};
 		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
-			const coordinator = this.forcedConsultCoordinator(callId);
+			const coordinator = harness.forcedConsults;
 			const forcedMatch = coordinator.recordNativeConsult(args, bridgeCallId);
 			if (forcedMatch.kind === "none") {
 				const pending = coordinator.consumePending();

package/dist/{response-generator-Cdj8EuLg.js → response-generator-z6M9229t.js}

@@ -1,4 +1,4 @@
-import { b as resolveVoiceCallSessionKey, m as resolveCallAgentId, p as resolveVoiceResponseModel } from "./runtime-entry-DSgyqIwE.js";
+import { h as resolveCallAgentId, m as resolveVoiceResponseModel, x as resolveVoiceCallSessionKey } from "./runtime-entry-CQtitvRd.js";
 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";