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

package/dist/doctor-contract-api.js

@@ -1,7 +1,7 @@
-import { a as MAX_CALL_RECORD_EVENTS, d as parseVoiceCallRecordLine, i as CALL_RECORD_EVENT_META_MAX_ENTRIES, m as resolveVoiceCallLegacyCallLogPath, n as CALL_RECORD_EVENTS_NAMESPACE, o as RAW_CALL_RECORD_CHUNK_BYTES, p as prepareVoiceCallRecordForStorage, r as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, s as buildVoiceCallLegacyJsonlEventKey, t as CALL_RECORD_CHUNK_MAX_ENTRIES } from "./store-C1pl3avP.js";
+import { a as CALL_RECORD_EVENT_META_MAX_ENTRIES, c as buildVoiceCallLegacyJsonlEventKey, f as parseVoiceCallRecordLine, h as resolveVoiceCallLegacyCallLogPath, i as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, m as prepareVoiceCallRecordForStorage, n as CALL_RECORD_CHUNK_MAX_ENTRIES, o as MAX_CALL_RECORD_EVENTS, r as CALL_RECORD_EVENTS_NAMESPACE, s as RAW_CALL_RECORD_CHUNK_BYTES, t as resolveDefaultVoiceCallStoreDir } from "./store-path-nYL-yM0S.js";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-import os from "node:os";
 import path from "node:path";
+import os from "node:os";
 import fs from "node:fs/promises";
 import { archiveLegacyStateSource, detectOpenClawStateDatabaseSchemaMigrations, repairOpenClawStateDatabaseSchema } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/voice-call/doctor-contract-api.ts
@@ -50,7 +50,7 @@ function resolveSessionStoreAgentIds(params) {
 function resolveVoiceCallStorePath(params) {
 	const configuredStore = getVoiceCallConfigStore(params.config);
 	if (configuredStore) return resolveUserPath(configuredStore, params.env);
-	return path.join(resolveHome(params.env), ".openclaw", "voice-calls");
+	return resolveDefaultVoiceCallStoreDir(params.env);
 }
 function resolveVoiceCallStateDatabaseEnv(params) {
 	return {
@@ -59,7 +59,14 @@ function resolveVoiceCallStateDatabaseEnv(params) {
 	};
 }
 function describeVoiceCallSchemaMigration(migration) {
-	return migration.kind === "agent-databases-composite-primary-key" ? "agent database registry primary key -> agent_id,path" : "audit event ledger -> versioned message lifecycle schema";
+	switch (migration.kind) {
+		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;
 }
 /** Return true when a path exists and is a file. */
 /** Build the plugin state key for one migrated event chunk. */
@@ -190,15 +197,14 @@ const stateMigrations = [{
 		const { entries, warnings: readWarnings } = await readLegacyCallRecords(filePath);
 		warnings.push(...readWarnings);
 		const stateDatabaseEnv = resolveVoiceCallStateDatabaseEnv(params);
-		const schemaMigrations = detectOpenClawStateDatabaseSchemaMigrations({ env: stateDatabaseEnv });
-		if (schemaMigrations.length > 0) {
+		if (detectOpenClawStateDatabaseSchemaMigrations({ env: stateDatabaseEnv }).length > 0) {
 			const repaired = repairOpenClawStateDatabaseSchema({ env: stateDatabaseEnv });
 			warnings.push(...repaired.warnings);
 			if (repaired.warnings.length > 0) return {
 				changes,
 				warnings
 			};
-			changes.push(...schemaMigrations.map((migration) => `Migrated Voice Call SQLite ${describeVoiceCallSchemaMigration(migration)}`));
+			changes.push(...repaired.changes.map((change) => change.replace(/^Migrated shared state /, "Migrated Voice Call SQLite ").replaceAll("→", "->")));
 		}
 		if (entries.length === 0) return {
 			changes,

package/dist/{guarded-json-api-DoLAoIRF.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-DhTLZ2uB.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,7 +1,7 @@
 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-DhTLZ2uB.js";
-import { h as setVoiceCallStateRuntime, l as getCallHistoryFromStore } from "./store-C1pl3avP.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";
 import { MAX_TCP_PORT, MAX_TIMER_TIMEOUT_MS, addTimerTimeoutGraceMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
@@ -10,16 +10,14 @@ import { asOptionalRecord, isRecord, normalizeOptionalLowercaseString, normalize
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
 import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import { randomUUID } from "node:crypto";
+import path from "node:path";
 import { format } from "node:util";
 //#region extensions/voice-call/src/cli.ts
 const VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS = 5e3;
 const VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS = 3e4;
 const VOICE_CALL_GATEWAY_TRANSCRIPT_BUFFER_MS = 1e4;
 const VOICE_CALL_GATEWAY_POLL_INTERVAL_MS = 1e3;
-const voiceCallCliDeps = { callGatewayFromCli };
 function writeStdoutLine(...values) {
 	process.stdout.write(`${format(...values)}\n`);
 }
@@ -41,7 +39,7 @@ async function callVoiceCallGateway(method, params, opts) {
 		const timeoutMs = typeof opts?.timeoutMs === "number" && Number.isFinite(opts.timeoutMs) ? Math.max(1, Math.ceil(opts.timeoutMs)) : VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS;
 		return {
 			ok: true,
-			payload: await voiceCallCliDeps.callGatewayFromCli(method, {
+			payload: await callGatewayFromCli(method, {
 				json: true,
 				timeout: String(timeoutMs)
 			}, params, { progress: false })
@@ -105,15 +103,7 @@ function resolveMode(input) {
 	return "funnel";
 }
 function resolveDefaultStorePath(config) {
-	const resolvedPreferred = resolveUserPath(path.join(os.homedir(), ".openclaw", "voice-calls"));
-	const existing = [resolvedPreferred].find((dir) => {
-		try {
-			return fs.existsSync(path.join(dir, "calls.jsonl")) || fs.existsSync(dir);
-		} catch {
-			return false;
-		}
-	}) ?? resolvedPreferred;
-	const base = config.store?.trim() ? resolveUserPath(config.store) : existing;
+	const base = config.store?.trim() ? resolveUserPath(config.store) : resolveDefaultVoiceCallStoreDir();
 	return path.join(base, "calls.jsonl");
 }
 function percentile(values, p) {

package/dist/{plivo-BICQA_yK.js → plivo-rISw-5A8.js}

@@ -1,5 +1,5 @@
-import { g as escapeXml, o as getHeader } from "./runtime-entry-DhTLZ2uB.js";
-import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-DoLAoIRF.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-hmAdGp5h.js → response-generator-r9wHPOEl.js}

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

@@ -1,7 +1,7 @@
 import { TtsConfigSchema, isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "./runtime-api.js";
 import "./api.js";
 import { t as TWILIO_REGIONS } from "./twilio-region-4fkgz3UG.js";
-import { c as findCallMatchesInStore, f as persistCallRecord, g as TerminalStates, h as setVoiceCallStateRuntime, l as getCallHistoryFromStore, u as loadActiveCallsFromStore } from "./store-C1pl3avP.js";
+import { _ as TerminalStates, d as loadActiveCallsFromStore, g as setVoiceCallStateRuntime, l as findCallMatchesInStore, p as persistCallRecord, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-nYL-yM0S.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -13,16 +13,16 @@ import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONSULT_TO
 import { mergeDeep } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { buildSecretInputSchema, hasConfiguredSecretInput, normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { canonicalizeMainSessionAlias } from "openclaw/plugin-sdk/session-store-runtime";
+import { resolveSpeechProviderApiKey } from "openclaw/plugin-sdk/speech-core";
 import { WEBHOOK_BODY_READ_DEFAULTS, createWebhookInFlightLimiter, normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import { z } from "zod";
 import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import crypto from "node:crypto";
 import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
+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";
@@ -586,28 +586,28 @@ function resolveVoiceCallConfig(config) {
 	const resolved = normalizeVoiceCallConfig(config);
 	if (resolved.provider === "telnyx") {
 		resolved.telnyx = resolved.telnyx ?? {};
-		resolved.telnyx.apiKey = resolved.telnyx.apiKey ?? process.env.TELNYX_API_KEY;
-		resolved.telnyx.connectionId = resolved.telnyx.connectionId ?? process.env.TELNYX_CONNECTION_ID;
-		resolved.telnyx.publicKey = resolved.telnyx.publicKey ?? process.env.TELNYX_PUBLIC_KEY;
+		resolved.telnyx.apiKey = resolved.telnyx.apiKey ?? resolveSpeechProviderApiKey(process.env.TELNYX_API_KEY);
+		resolved.telnyx.connectionId = resolved.telnyx.connectionId ?? resolveSpeechProviderApiKey(process.env.TELNYX_CONNECTION_ID);
+		resolved.telnyx.publicKey = resolved.telnyx.publicKey ?? resolveSpeechProviderApiKey(process.env.TELNYX_PUBLIC_KEY);
 	}
 	if (resolved.provider === "twilio") {
-		resolved.fromNumber = resolved.fromNumber ?? process.env.TWILIO_FROM_NUMBER;
+		resolved.fromNumber = resolved.fromNumber ?? resolveSpeechProviderApiKey(process.env.TWILIO_FROM_NUMBER);
 		resolved.twilio = resolved.twilio ?? {};
-		resolved.twilio.accountSid = resolved.twilio.accountSid ?? process.env.TWILIO_ACCOUNT_SID;
-		resolved.twilio.authToken = resolved.twilio.authToken ?? process.env.TWILIO_AUTH_TOKEN;
+		resolved.twilio.accountSid = resolved.twilio.accountSid ?? resolveSpeechProviderApiKey(process.env.TWILIO_ACCOUNT_SID);
+		resolved.twilio.authToken = resolved.twilio.authToken ?? resolveSpeechProviderApiKey(process.env.TWILIO_AUTH_TOKEN);
 	}
 	if (resolved.provider === "plivo") {
 		resolved.plivo = resolved.plivo ?? {};
-		resolved.plivo.authId = resolved.plivo.authId ?? process.env.PLIVO_AUTH_ID;
-		resolved.plivo.authToken = resolved.plivo.authToken ?? process.env.PLIVO_AUTH_TOKEN;
+		resolved.plivo.authId = resolved.plivo.authId ?? resolveSpeechProviderApiKey(process.env.PLIVO_AUTH_ID);
+		resolved.plivo.authToken = resolved.plivo.authToken ?? resolveSpeechProviderApiKey(process.env.PLIVO_AUTH_TOKEN);
 	}
 	resolved.tunnel = resolved.tunnel ?? {
 		provider: "none",
 		allowNgrokFreeTierLoopbackBypass: false
 	};
 	resolved.tunnel.allowNgrokFreeTierLoopbackBypass = resolved.tunnel.allowNgrokFreeTierLoopbackBypass ?? false;
-	resolved.tunnel.ngrokAuthToken = resolved.tunnel.ngrokAuthToken ?? process.env.NGROK_AUTHTOKEN;
-	resolved.tunnel.ngrokDomain = resolved.tunnel.ngrokDomain ?? process.env.NGROK_DOMAIN;
+	resolved.tunnel.ngrokAuthToken = resolved.tunnel.ngrokAuthToken ?? resolveSpeechProviderApiKey(process.env.NGROK_AUTHTOKEN);
+	resolved.tunnel.ngrokDomain = resolved.tunnel.ngrokDomain ?? resolveSpeechProviderApiKey(process.env.NGROK_DOMAIN);
 	resolved.webhookSecurity = resolved.webhookSecurity ?? {
 		allowedHosts: [],
 		trustForwardingHeaders: false,
@@ -1552,14 +1552,7 @@ function resolveRestoredMaxDurationAnchor(call) {
 function resolveDefaultStoreBase(config, storePath) {
 	const rawOverride = storePath?.trim() || config.store?.trim();
 	if (rawOverride) return resolveUserPath(rawOverride);
-	const preferred = path.join(os.homedir(), ".openclaw", "voice-calls");
-	return [preferred].map((dir) => resolveUserPath(dir)).find((dir) => {
-		try {
-			return fs.existsSync(path.join(dir, "calls.jsonl")) || fs.existsSync(dir);
-		} catch {
-			return false;
-		}
-	}) ?? resolveUserPath(preferred);
+	return resolveDefaultVoiceCallStoreDir();
 }
 /**
 * Manages voice calls: state ownership and delegation to manager helper modules.
@@ -1919,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");
@@ -1950,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;
@@ -2165,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));
@@ -2200,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));
 			}
 		};
@@ -2225,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}`);
@@ -2234,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);
 		});
@@ -2276,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}`));
 			}
@@ -3119,15 +3034,19 @@ function startStaleCallReaper(params) {
 	const maxAgeSeconds = params.staleCallReaperSeconds;
 	if (!maxAgeSeconds || maxAgeSeconds <= 0) return null;
 	const maxAgeMs = maxAgeSeconds * 1e3;
+	const callsBeingReaped = /* @__PURE__ */ new Set();
 	const interval = setInterval(() => {
 		const now = Date.now();
 		for (const call of params.manager.getActiveCalls()) {
 			if (call.answeredAt || TerminalStates.has(call.state) || LiveConversationStates.has(call.state)) continue;
 			const age = now - call.startedAt;
-			if (age > maxAgeMs) {
+			if (age > maxAgeMs && !callsBeingReaped.has(call.callId)) {
+				callsBeingReaped.add(call.callId);
 				console.log(`[voice-call] Reaping stale call ${call.callId} (age: ${Math.round(age / 1e3)}s, state: ${call.state})`);
 				params.manager.endCall(call.callId).catch((err) => {
 					console.warn(`[voice-call] Reaper failed to end call ${call.callId}:`, err);
+				}).finally(() => {
+					callsBeingReaped.delete(call.callId);
 				});
 			}
 		}
@@ -3143,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-hmAdGp5h.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)) : [];
@@ -3818,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-B9tF5jeJ.js"));
-const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-U_myvowz.js"));
-const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-BICQA_yK.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,
@@ -4103,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-DhTLZ2uB.js";
+import { t as createVoiceCallRuntime } from "./runtime-entry-D8Mkwy8G.js";
 export { createVoiceCallRuntime };

package/dist/{store-C1pl3avP.js → store-path-nYL-yM0S.js}

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
+import path from "node:path";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 //#region extensions/voice-call/src/types.ts
 const ProviderNameSchema = z.enum([
 	"telnyx",
@@ -124,7 +125,7 @@ const CallRecordSchema = z.object({
 });
 //#endregion
 //#region extensions/voice-call/src/runtime-state.ts
-const { setRuntime: setVoiceCallStateRuntime, clearRuntime: clearVoiceCallStateRuntime, tryGetRuntime: getOptionalVoiceCallStateRuntime } = createPluginRuntimeStore({
+const { setRuntime: setVoiceCallStateRuntime, tryGetRuntime: getOptionalVoiceCallStateRuntime } = createPluginRuntimeStore({
 	pluginId: "voice-call-state",
 	errorMessage: "Voice Call state runtime not initialized"
 });
@@ -400,4 +401,10 @@ async function getCallHistoryFromStore(storePath, limit = 50) {
 	return readCallHistoryFromStore(storePath).slice(-limit);
 }
 //#endregion
-export { MAX_CALL_RECORD_EVENTS as a, findCallMatchesInStore as c, parseVoiceCallRecordLine as d, persistCallRecord as f, TerminalStates as g, setVoiceCallStateRuntime as h, CALL_RECORD_EVENT_META_MAX_ENTRIES as i, getCallHistoryFromStore as l, resolveVoiceCallLegacyCallLogPath as m, CALL_RECORD_EVENTS_NAMESPACE as n, RAW_CALL_RECORD_CHUNK_BYTES as o, prepareVoiceCallRecordForStorage as p, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as r, buildVoiceCallLegacyJsonlEventKey as s, CALL_RECORD_CHUNK_MAX_ENTRIES as t, loadActiveCallsFromStore as u };
+//#region extensions/voice-call/src/store-path.ts
+/** Resolve the plugin-owned store below OpenClaw's canonical state directory. */
+function resolveDefaultVoiceCallStoreDir(env = process.env) {
+	return path.join(resolveStateDir(env), "voice-calls");
+}
+//#endregion
+export { TerminalStates as _, CALL_RECORD_EVENT_META_MAX_ENTRIES as a, buildVoiceCallLegacyJsonlEventKey as c, loadActiveCallsFromStore as d, parseVoiceCallRecordLine as f, setVoiceCallStateRuntime as g, resolveVoiceCallLegacyCallLogPath as h, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as i, findCallMatchesInStore as l, prepareVoiceCallRecordForStorage as m, CALL_RECORD_CHUNK_MAX_ENTRIES as n, MAX_CALL_RECORD_EVENTS as o, persistCallRecord as p, CALL_RECORD_EVENTS_NAMESPACE as r, RAW_CALL_RECORD_CHUNK_BYTES as s, resolveDefaultVoiceCallStoreDir as t, getCallHistoryFromStore as u };

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

@@ -1,4 +1,4 @@
-import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-DoLAoIRF.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-U_myvowz.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-DhTLZ2uB.js";
-import { c as verifyTwilioWebhook, i as readProviderJsonResponseText, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-DoLAoIRF.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.1",
+  "version": "2026.7.2-beta.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/voice-call",
-      "version": "2026.7.2-beta.1",
+      "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.1"
+        "openclaw": ">=2026.7.2-beta.3"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.7.2-beta.1",
+  "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.1"
+    "openclaw": ">=2026.7.2-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -30,10 +30,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.1"
+      "pluginApi": ">=2026.7.2-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.1"
+      "openclawVersion": "2026.7.2-beta.3"
     },
     "release": {
       "publishToClawHub": true,