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

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-Dm4NvtGo.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, o as getHeader } from "./runtime-entry-D8Mkwy8G.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";

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 { 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-D8Mkwy8G.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";

package/dist/{plivo-ByAIoPFp.js → plivo-rISw-5A8.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 { g as escapeXml, o as getHeader } from "./runtime-entry-D8Mkwy8G.js";
+import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-Dm4NvtGo.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-DJk-eYyf.js → realtime-handler-HSxcgwY_.js}

@@ -1,7 +1,7 @@
 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 +11,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 +106,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. */
@@ -475,7 +423,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 +608,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 +660,8 @@ var RealtimeCallHandler = class {
 					reason
 				}
 			});
-			if (cancelled.ok) rememberTalkEvent(cancelled.event);
 		};
-		emitTalkEvent({
+		harness.emit({
 			type: "session.started",
 			payload: {
 				callId,
@@ -762,9 +703,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 +721,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 +788,7 @@ var RealtimeCallHandler = class {
 					};
 					this.manager.processEvent(event);
 					this.scheduleForcedAgentConsult({
+						harness,
 						session,
 						callId,
 						callSid,
@@ -872,8 +810,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 +822,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 +845,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 +866,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 +878,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 +909,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 +934,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 +1018,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 +1034,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 +1050,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 +1142,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 +1167,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 +1179,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-r9wHPOEl.js}

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

package/dist/{runtime-entry-DSgyqIwE.js → runtime-entry-D8Mkwy8G.js}

@@ -23,7 +23,6 @@ import path from "node:path";
 import os from "node:os";
 import { root } from "openclaw/plugin-sdk/security-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
 import { spawn } from "node:child_process";
 import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import http from "node:http";
@@ -1913,26 +1912,26 @@ function chunkAudio(audio, chunkSize = 160) {
 /** Default timeout for one telephony synthesis request. */
 const TELEPHONY_DEFAULT_TTS_TIMEOUT_MS = 8e3;
 /** Create a TTS provider that honors voice-call overrides and converts PCM to mulaw. */
-function createTelephonyTtsProvider(params) {
+async function createTelephonyTtsProvider(params) {
 	const { coreConfig, ttsOverride, runtime, logger } = params;
-	const mergedConfig = applyTtsOverride(coreConfig, ttsOverride);
-	const ttsConfig = mergedConfig.messages?.tts;
-	const modelOverrides = resolveTelephonyModelOverridePolicy(readTelephonyModelOverrides(ttsConfig));
-	const providerConfigs = collectTelephonyProviderConfigs(ttsConfig);
-	const activeProvider = normalizeProviderId(ttsConfig?.provider);
+	const preparedConfig = await runtime.prepareTtsRequest({
+		cfg: coreConfig,
+		override: ttsOverride,
+		text: ""
+	});
 	return {
-		synthesisTimeoutMs: resolveTimerTimeoutMs(mergedConfig.messages?.tts?.timeoutMs, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS),
+		synthesisTimeoutMs: resolveTimerTimeoutMs(preparedConfig.cfg.messages?.tts?.timeoutMs, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS),
 		synthesizeForTelephony: async (text) => {
-			const directives = parseTtsDirectives(text, modelOverrides, {
-				cfg: mergedConfig,
-				providerConfigs,
-				preferredProviderId: activeProvider
+			const prepared = await runtime.prepareTtsRequest({
+				cfg: preparedConfig.cfg,
+				text
 			});
+			const directives = prepared.directives;
 			if (directives.warnings.length > 0) logger?.warn?.(`[voice-call] Ignored telephony TTS directive overrides (${directives.warnings.join("; ")})`);
 			const cleanText = directives.hasDirective ? directives.ttsText?.trim() || directives.cleanedText.trim() : text;
 			const result = await runtime.textToSpeechTelephony({
 				text: cleanText,
-				cfg: mergedConfig,
+				cfg: prepared.cfg,
 				overrides: directives.overrides
 			});
 			if (!result.success || !result.audioBuffer || !result.sampleRate) throw new Error(result.error ?? "TTS conversion failed");
@@ -1944,94 +1943,6 @@ function createTelephonyTtsProvider(params) {
 		}
 	};
 }
-/** Apply voice-call TTS overrides to core config without mutating the original object. */
-function applyTtsOverride(coreConfig, override) {
-	if (!override) return coreConfig;
-	const base = coreConfig.messages?.tts;
-	const merged = mergeTtsConfig(base, override);
-	if (!merged) return coreConfig;
-	return {
-		...coreConfig,
-		messages: {
-			...coreConfig.messages,
-			tts: merged
-		}
-	};
-}
-/** Merge core and voice-call TTS config, keeping undefined override fields out. */
-function mergeTtsConfig(base, override) {
-	if (!base && !override) return;
-	if (!override) return base;
-	if (!base) return override;
-	return mergeDeep(base, override);
-}
-/** Resolve directive override policy for telephony synthesis. */
-function resolveTelephonyModelOverridePolicy(overrides) {
-	if (!(overrides?.enabled ?? true)) return {
-		enabled: false,
-		allowText: false,
-		allowProvider: false,
-		allowVoice: false,
-		allowModelId: false,
-		allowVoiceSettings: false,
-		allowNormalization: false,
-		allowSeed: false
-	};
-	const allow = (value, defaultValue = true) => value ?? defaultValue;
-	return {
-		enabled: true,
-		allowText: allow(overrides?.allowText),
-		allowProvider: allow(overrides?.allowProvider, false),
-		allowVoice: allow(overrides?.allowVoice),
-		allowModelId: allow(overrides?.allowModelId),
-		allowVoiceSettings: allow(overrides?.allowVoiceSettings),
-		allowNormalization: allow(overrides?.allowNormalization),
-		allowSeed: allow(overrides?.allowSeed)
-	};
-}
-/** Read model override policy from TTS config when present. */
-function readTelephonyModelOverrides(ttsConfig) {
-	const value = ttsConfig?.modelOverrides;
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-/** Normalize provider ids for config lookup. */
-function normalizeProviderId(value) {
-	return typeof value === "string" ? value.trim().toLowerCase() || void 0 : void 0;
-}
-/** Coerce provider config objects while rejecting arrays and primitives. */
-function asProviderConfig(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-/** Collect named provider configs from canonical and legacy TTS config shapes. */
-function collectTelephonyProviderConfigs(ttsConfig) {
-	if (!ttsConfig) return {};
-	const entries = {};
-	const rawProviders = ttsConfig.providers && typeof ttsConfig.providers === "object" && !Array.isArray(ttsConfig.providers) ? ttsConfig.providers : {};
-	for (const [providerId, value] of Object.entries(rawProviders)) {
-		const normalized = normalizeProviderId(providerId) ?? providerId;
-		entries[normalized] = asProviderConfig(value);
-	}
-	const reservedKeys = /* @__PURE__ */ new Set([
-		"auto",
-		"enabled",
-		"maxTextLength",
-		"mode",
-		"modelOverrides",
-		"persona",
-		"personas",
-		"prefsPath",
-		"provider",
-		"providers",
-		"summaryModel",
-		"timeoutMs"
-	]);
-	for (const [key, value] of Object.entries(ttsConfig)) {
-		if (reservedKeys.has(key) || typeof value !== "object" || value === null || Array.isArray(value)) continue;
-		const normalized = normalizeProviderId(key) ?? key;
-		entries[normalized] ??= asProviderConfig(value);
-	}
-	return entries;
-}
 //#endregion
 //#region extensions/voice-call/src/bounded-child-output.ts
 const DEFAULT_MAX_OUTPUT_CHARS = 16384;
@@ -2159,6 +2070,30 @@ async function cleanupTailscaleExposure(config) {
 const NGROK_LOG_BUFFER_MAX_CHARS = 16384;
 const NGROK_ERROR_MARKER = "ERR_NGROK";
 const TUNNEL_COMMAND_OUTPUT_MAX_BYTES = 16384;
+const NGROK_STOP_GRACE_MS = 2e3;
+const NGROK_FORCE_KILL_WAIT_MS = 1e3;
+async function terminateNgrokProcess(proc, isClosed) {
+	if (isClosed()) return;
+	await new Promise((resolve) => {
+		let finished = false;
+		let forceKillWaitTimer;
+		const finish = () => {
+			if (finished) return;
+			finished = true;
+			if (forceKillTimer) clearTimeout(forceKillTimer);
+			if (forceKillWaitTimer) clearTimeout(forceKillWaitTimer);
+			proc.off("close", finish);
+			resolve();
+		};
+		proc.once("close", finish);
+		const forceKillTimer = setTimeout(() => {
+			forceKillWaitTimer = setTimeout(finish, NGROK_FORCE_KILL_WAIT_MS);
+			if (!isClosed()) proc.kill("SIGKILL");
+		}, NGROK_STOP_GRACE_MS);
+		proc.kill("SIGTERM");
+		if (isClosed()) finish();
+	});
+}
 function listenForChildStreamErrors(proc, onError) {
 	proc.stdout.on("error", (error) => onError("stdout", error));
 	proc.stderr.on("error", (error) => onError("stderr", error));
@@ -2194,23 +2129,25 @@ async function startNgrokTunnel(config) {
 			"pipe",
 			"pipe"
 		] });
-		let resolved = false;
-		let closed = false;
+		let startupSettled = false;
+		let childClosed = false;
 		let publicUrl = null;
 		let outputBuffer = "";
 		let stderrTail = "";
 		const timeout = setTimeout(() => {
-			if (!resolved) {
-				resolved = true;
-				proc.kill("SIGTERM");
-				reject(/* @__PURE__ */ new Error("ngrok startup timed out (30s)"));
+			if (!startupSettled) {
+				startupSettled = true;
+				terminateNgrokProcess(proc, () => childClosed).then(() => {
+					reject(/* @__PURE__ */ new Error("ngrok startup timed out (30s)"));
+				});
 			}
 		}, 3e4);
+		timeout.unref();
 		const rejectIfPending = (message, kill = false) => {
-			if (!resolved) {
-				resolved = true;
+			if (!startupSettled) {
+				startupSettled = true;
 				clearTimeout(timeout);
-				if (kill && !closed) proc.kill("SIGKILL");
+				if (kill && !childClosed) proc.kill("SIGKILL");
 				reject(new Error(message));
 			}
 		};
@@ -2219,8 +2156,8 @@ async function startNgrokTunnel(config) {
 				const log = JSON.parse(line);
 				if (log.msg === "started tunnel" && log.url) publicUrl = log.url;
 				if (log.addr && log.url && !publicUrl) publicUrl = log.url;
-				if (publicUrl && !resolved) {
-					resolved = true;
+				if (publicUrl && !startupSettled) {
+					startupSettled = true;
 					clearTimeout(timeout);
 					const fullUrl = publicUrl + config.path;
 					console.log(`[voice-call] ngrok tunnel active: ${fullUrl}`);
@@ -2228,38 +2165,22 @@ async function startNgrokTunnel(config) {
 						publicUrl: fullUrl,
 						provider: "ngrok",
 						stop: async () => {
-							if (closed) return;
-							await new Promise((res) => {
-								let finished = false;
-								const finish = () => {
-									if (finished) return;
-									finished = true;
-									clearTimeout(fallback);
-									proc.off("close", finish);
-									res();
-								};
-								if (closed) {
-									res();
-									return;
-								}
-								proc.once("close", finish);
-								const fallback = setTimeout(finish, 2e3);
-								proc.kill("SIGTERM");
-								if (closed) finish();
-							});
+							await terminateNgrokProcess(proc, () => childClosed);
 						}
 					});
 				}
 			} catch {}
 		};
-		proc.stdout.on("data", (data) => {
-			const lines = (outputBuffer + data.toString()).split("\n");
+		proc.stdout.setEncoding("utf8");
+		proc.stderr.setEncoding("utf8");
+		proc.stdout.on("data", (chunk) => {
+			const lines = (outputBuffer + chunk).split("\n");
 			outputBuffer = lines.pop() || "";
 			if (outputBuffer.length > NGROK_LOG_BUFFER_MAX_CHARS) outputBuffer = sliceUtf16Safe(outputBuffer, -16384);
 			for (const line of lines) if (line.trim()) processLine(line);
 		});
-		proc.stderr.on("data", (data) => {
-			const combined = stderrTail + data.toString();
+		proc.stderr.on("data", (chunk) => {
+			const combined = stderrTail + chunk;
 			if (combined.includes(NGROK_ERROR_MARKER)) rejectIfPending(`ngrok error: ${formatBoundedChildOutput(appendBoundedChildOutput(emptyBoundedChildOutput(), combined))}`, true);
 			stderrTail = sliceUtf16Safe(combined, -8);
 		});
@@ -2270,9 +2191,9 @@ async function startNgrokTunnel(config) {
 			rejectIfPending(`Failed to start ngrok: ${err.message}`);
 		});
 		proc.on("close", (code) => {
-			closed = true;
-			if (!resolved) {
-				resolved = true;
+			childClosed = true;
+			if (!startupSettled) {
+				startupSettled = true;
 				clearTimeout(timeout);
 				reject(/* @__PURE__ */ new Error(`ngrok exited unexpectedly with code ${code}`));
 			}
@@ -3141,7 +3062,7 @@ const WEBHOOK_BODY_TIMEOUT_MS = WEBHOOK_BODY_READ_DEFAULTS.preAuth.timeoutMs;
 const MISSING_REMOTE_ADDRESS_IN_FLIGHT_KEY = "__voice_call_no_remote__";
 const STREAM_DISCONNECT_HANGUP_GRACE_MS = 2e3;
 const loadRealtimeTranscriptionRuntime = createLazyRuntimeModule(() => import("./realtime-transcription.runtime-CbJAs5t_.js"));
-const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-Cdj8EuLg.js"));
+const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-r9wHPOEl.js"));
 function appendRecentTalkEventMetadata(call, event) {
 	const metadata = call.metadata ?? {};
 	const recent = Array.isArray(metadata.recentTalkEvents) ? metadata.recentTalkEvents.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)) : [];
@@ -3816,12 +3737,12 @@ const REALTIME_VOICE_CONSULT_SYSTEM_PROMPT = [
 	"Do not print secret values or dump environment variables; only check whether required configuration is present.",
 	"Be accurate, brief, and speakable."
 ].join(" ");
-const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-DMbLYwj4.js"));
-const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-BTKKlkLT.js"));
-const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-ByAIoPFp.js"));
+const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-DTD9jTqC.js"));
+const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-GzbIb5fv.js"));
+const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-rISw-5A8.js"));
 const loadMockProvider = createLazyRuntimeModule(() => import("./mock-YsvBTX-7.js"));
 const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.js"));
-const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-DJk-eYyf.js"));
+const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-HSxcgwY_.js"));
 function resolveVoiceCallConsultSessionKey(call) {
 	return resolveVoiceCallSessionKey({
 		config: call.config,
@@ -4101,8 +4022,8 @@ async function createVoiceCallRuntime(params) {
 		if (provider.name === "twilio" && config.streaming?.enabled) {
 			const twilioProvider = provider;
 			if (ttsRuntime?.textToSpeechTelephony) try {
-				const ttsProvider = createTelephonyTtsProvider({
-					coreConfig,
+				const ttsProvider = await createTelephonyTtsProvider({
+					coreConfig: cfg,
 					ttsOverride: config.tts,
 					runtime: ttsRuntime,
 					logger: log

package/dist/runtime-entry.js

@@ -1,2 +1,2 @@
-import { t as createVoiceCallRuntime } from "./runtime-entry-DSgyqIwE.js";
+import { t as createVoiceCallRuntime } from "./runtime-entry-D8Mkwy8G.js";
 export { createVoiceCallRuntime };

package/dist/{telnyx-DMbLYwj4.js → telnyx-DTD9jTqC.js}

@@ -1,4 +1,4 @@
-import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-BKOgUU1q.js";
+import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-Dm4NvtGo.js";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/telnyx.ts
 function normalizeTelnyxDirection(direction) {

package/dist/{twilio-BTKKlkLT.js → twilio-GzbIb5fv.js}

@@ -1,9 +1,10 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
 import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-4fkgz3UG.js";
-import { _ as mapVoiceToPolly, a as normalizeProviderStatus, f as chunkAudio, g as escapeXml, i as mapProviderStatusToEndReason, o as getHeader, r as isProviderStatusTerminal } from "./runtime-entry-DSgyqIwE.js";
-import { c as verifyTwilioWebhook, i as readProviderJsonResponseText, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-BKOgUU1q.js";
+import { _ as mapVoiceToPolly, a as normalizeProviderStatus, f as chunkAudio, g as escapeXml, i as mapProviderStatusToEndReason, o as getHeader, r as isProviderStatusTerminal } from "./runtime-entry-D8Mkwy8G.js";
+import { c as verifyTwilioWebhook, i as readProviderJsonResponseText, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-Dm4NvtGo.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -628,9 +629,12 @@ var TwilioProvider = class TwilioProvider {
 				chunkAttempts += 1;
 				if (sendAudioChunk(chunk).sent) chunkDelivered += 1;
 				const waitMs = nextChunkDueAt - Date.now();
-				if (waitMs > 0) await new Promise((resolve) => {
-					setTimeout(resolve, Math.ceil(waitMs));
-				});
+				if (waitMs > 0) try {
+					await sleepWithAbort(Math.ceil(waitMs), signal);
+				} catch (error) {
+					if (!signal.aborted) throw error;
+					break;
+				}
 				nextChunkDueAt += CHUNK_DELAY_MS;
 				if (signal.aborted) break;
 			}

package/npm-shrinkwrap.json

@@ -1,19 +1,19 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/voice-call",
-      "version": "2026.7.2-beta.2",
+      "version": "2026.7.2-beta.3",
       "dependencies": {
         "typebox": "1.3.3",
         "ws": "8.21.0",
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.7.2-beta.2"
+        "openclaw": ">=2026.7.2-beta.3"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.3",
   "description": "OpenClaw voice-call plugin for Twilio, Telnyx, and Plivo phone calls.",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.2"
+    "openclaw": ">=2026.7.2-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -30,10 +30,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.2"
+      "pluginApi": ">=2026.7.2-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.2"
+      "openclawVersion": "2026.7.2-beta.3"
     },
     "release": {
       "publishToClawHub": true,