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

package/README.md

@@ -101,7 +101,7 @@ Notes:
 - Twilio defaults to US1. For a non-US Region, set `twilio.region` to `ie1` or `au1` and use credentials created in that Region; see [Twilio's regional REST API guide](https://www.twilio.com/docs/global-infrastructure/using-the-twilio-rest-api-in-a-non-us-region).
 - `mock` is a local dev provider (no network calls).
 - Telnyx requires `telnyx.publicKey` (or `TELNYX_PUBLIC_KEY`) unless `skipSignatureVerification` is true.
-- If older configs still use `provider: "log"`, `twilio.from`, or legacy `streaming.*` OpenAI keys, run `openclaw doctor --fix` to rewrite them.
+- Runtime accepts canonical config only. If older configs still use `provider: "log"`, `twilio.from`, or legacy `streaming.*` OpenAI keys, run `openclaw doctor --fix` to rewrite them.
 - advanced webhook, streaming, and tunnel notes: `https://docs.openclaw.ai/plugins/voice-call`
 - `responseModel` is optional. When unset, voice responses use the runtime default model.
 - `sessionScope` defaults to `per-phone`, preserving caller memory across calls. Use `per-call` for reception, booking, IVR, and bridge flows where each carrier call should start fresh.
@@ -163,4 +163,3 @@ Actions:
 - Outbound conversation calls suppress barge-in only while the initial greeting is actively speaking, then re-enable normal interruption.
 - Twilio stream disconnect auto-end uses a short grace window so quick reconnects do not end the call.
 - Realtime provider selection is generic. Configure `streaming.provider` / `realtime.provider` and put provider-owned options under `providers.<id>`.
-- Runtime fallback still accepts the old voice-call keys for now, but migration is a doctor step and the compat shim is scheduled to go away in a future release.

package/dist/doctor-contract-api.js

@@ -1,9 +1,9 @@
-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-DtewuuOb.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 } from "openclaw/plugin-sdk/runtime-doctor";
+import { archiveLegacyStateSource, detectOpenClawStateDatabaseSchemaMigrations, repairOpenClawStateDatabaseSchema } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/voice-call/doctor-contract-api.ts
 /** Resolve home from doctor env with OS fallback. */
 function resolveHome(env) {
@@ -50,7 +50,22 @@ 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 {
+		...params.env,
+		OPENCLAW_STATE_DIR: resolveVoiceCallStorePath(params)
+	};
+}
+function describeVoiceCallSchemaMigration(migration) {
+	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 "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. */
@@ -170,24 +185,31 @@ const stateMigrations = [{
 	label: "Voice Call call log",
 	async detectLegacyState(params) {
 		const { entries } = await readLegacyCallRecords(resolveVoiceCallLegacyCallLogPath(resolveVoiceCallStorePath(params)));
-		if (entries.length === 0) return null;
-		return { preview: [`- Voice Call call log: ${entries.length} ${entries.length === 1 ? "record" : "records"} -> plugin state (${CALL_RECORD_EVENTS_NAMESPACE})`] };
+		const schemaMigrations = detectOpenClawStateDatabaseSchemaMigrations({ env: resolveVoiceCallStateDatabaseEnv(params) });
+		if (entries.length === 0 && schemaMigrations.length === 0) return null;
+		return { preview: [...schemaMigrations.map((migration) => `- Voice Call SQLite schema: ${describeVoiceCallSchemaMigration(migration)}`), ...entries.length > 0 ? [`- Voice Call call log: ${entries.length} ${entries.length === 1 ? "record" : "records"} -> plugin state (${CALL_RECORD_EVENTS_NAMESPACE})`] : []] };
 	},
 	async migrateLegacyState(params) {
 		const changes = [];
 		const warnings = [];
-		const storePath = resolveVoiceCallStorePath(params);
-		const filePath = resolveVoiceCallLegacyCallLogPath(storePath);
+		const filePath = resolveVoiceCallLegacyCallLogPath(resolveVoiceCallStorePath(params));
 		const { entries, warnings: readWarnings } = await readLegacyCallRecords(filePath);
 		warnings.push(...readWarnings);
+		const stateDatabaseEnv = resolveVoiceCallStateDatabaseEnv(params);
+		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(...repaired.changes.map((change) => change.replace(/^Migrated shared state /, "Migrated Voice Call SQLite ").replaceAll("→", "->")));
+		}
 		if (entries.length === 0) return {
 			changes,
 			warnings
 		};
-		const env = {
-			...params.env,
-			OPENCLAW_STATE_DIR: storePath
-		};
+		const env = stateDatabaseEnv;
 		const imported = await importLegacyCallRecords({
 			entries,
 			eventStore: params.context.openPluginStateKeyedStore({

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

@@ -1,12 +1,13 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
-import { n as normalizeProxyIp, o as getHeader } from "./runtime-entry-DwMgbq2p.js";
+import { n as normalizeProxyIp, o as getHeader } from "./runtime-entry-DSgyqIwE.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";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
+import { readResponseTextPrefix, readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 //#region extensions/voice-call/src/webhook-security.ts
 const twilioReplayCache = createWebhookReplayCache();
 const plivoReplayCache = createWebhookReplayCache();
@@ -53,16 +54,14 @@ function isValidHostname(hostname) {
 */
 function extractHostname(hostHeader) {
 	if (!hostHeader) return null;
-	let hostname;
 	if (hostHeader.startsWith("[")) {
 		const endBracket = hostHeader.indexOf("]");
 		if (endBracket === -1) return null;
-		hostname = hostHeader.slice(1, endBracket);
-		return normalizeLowercaseStringOrEmpty(hostname);
+		return normalizeLowercaseStringOrEmpty(hostHeader.slice(1, endBracket));
 	}
 	if (hostHeader.includes("@")) return null;
-	hostname = hostHeader.split(":")[0];
-	if (!isValidHostname(hostname)) return null;
+	const hostname = hostHeader.split(":").at(0);
+	if (!hostname || !isValidHostname(hostname)) return null;
 	return normalizeLowercaseStringOrEmpty(hostname);
 }
 function extractHostnameFromHeader(headerValue) {
@@ -162,6 +161,18 @@ function buildTwilioVerificationUrl(ctx, publicUrl, urlOptions) {
 		return publicUrl;
 	}
 }
+function redactTwilioVerificationUrlForDiagnostics(url) {
+	try {
+		const parsed = new URL(url);
+		parsed.username = parsed.username ? "***" : "";
+		parsed.password = parsed.password ? "***" : "";
+		parsed.hash = parsed.hash ? "#***" : "";
+		for (const key of Array.from(parsed.searchParams.keys())) parsed.searchParams.set(key, "***");
+		return parsed.toString();
+	} catch {
+		return "<invalid verification URL>";
+	}
+}
 function stripPortFromUrl(url) {
 	try {
 		const parsed = new URL(url);
@@ -347,8 +358,7 @@ function verifyTwilioWebhook(ctx, authToken, options) {
 	const isNgrokFreeTier = verificationUrl.includes(".ngrok-free.app") || verificationUrl.includes(".ngrok.io");
 	return {
 		ok: false,
-		reason: `Invalid signature for URL: ${verificationUrl}`,
-		verificationUrl,
+		reason: `Invalid signature for URL: ${redactTwilioVerificationUrlForDiagnostics(verificationUrl)}`,
 		isNgrokFreeTier
 	};
 }
@@ -383,16 +393,18 @@ function toParamMapFromSearchParams(sp) {
 }
 function sortedQueryString(params) {
 	const parts = [];
-	for (const key of Object.keys(params).toSorted()) {
-		const values = [...params[key]].toSorted();
+	const entries = Object.entries(params).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+	for (const [key, entryValues] of entries) {
+		const values = [...entryValues].toSorted();
 		for (const value of values) parts.push(`${key}=${value}`);
 	}
 	return parts.join("&");
 }
 function sortedParamsString(params) {
 	const parts = [];
-	for (const key of Object.keys(params).toSorted()) {
-		const values = [...params[key]].toSorted();
+	const entries = Object.entries(params).toSorted(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+	for (const [key, entryValues] of entries) {
+		const values = [...entryValues].toSorted();
 		for (const value of values) parts.push(`${key}${value}`);
 	}
 	return parts.join("");
@@ -533,35 +545,12 @@ function appendTruncatedSuffix(text) {
 	return `${text.trimEnd()}${TRUNCATED_SUFFIX}`;
 }
 async function readProviderResponseTextWithLimit(params) {
-	if (!params.response.body) return "";
-	const reader = params.response.body.getReader();
-	const decoder = new TextDecoder();
-	let totalBytes = 0;
-	let text = "";
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) return text + decoder.decode();
-			if (!value?.byteLength) continue;
-			const remainingBytes = params.maxBytes - totalBytes;
-			if (value.byteLength > remainingBytes) {
-				if (params.truncateOnLimit) {
-					const clipped = remainingBytes > 0 ? value.slice(0, remainingBytes) : void 0;
-					if (clipped) text += decoder.decode(clipped, { stream: true });
-					await reader.cancel().catch(() => void 0);
-					return appendTruncatedSuffix(text + decoder.decode());
-				}
-				await reader.cancel().catch(() => void 0);
-				throw new Error(`provider response body too large: ${totalBytes + value.byteLength} bytes (limit: ${params.maxBytes} bytes)`);
-			}
-			text += decoder.decode(value, { stream: true });
-			totalBytes += value.byteLength;
-		}
-	} finally {
-		try {
-			reader.releaseLock();
-		} catch {}
+	if (params.truncateOnLimit) {
+		const prefix = await readResponseTextPrefix(params.response, params.maxBytes);
+		return prefix.truncated ? appendTruncatedSuffix(prefix.text) : prefix.text;
 	}
+	const body = await readResponseWithLimit(params.response, params.maxBytes, { onOverflow: ({ size, maxBytes }) => /* @__PURE__ */ new Error(`provider response body too large: ${size} bytes (limit: ${maxBytes} bytes)`) });
+	return new TextDecoder().decode(body);
 }
 async function readProviderJsonResponseText(response) {
 	return await readProviderResponseTextWithLimit({
@@ -578,6 +567,7 @@ async function readProviderErrorResponseSnippet(response) {
 }
 //#endregion
 //#region extensions/voice-call/src/providers/shared/guarded-json-api.ts
+const VOICE_CALL_PROVIDER_API_TIMEOUT_MS = 3e4;
 /** Send a provider JSON request through the SSRF guard and parse bounded JSON responses. */
 async function guardedJsonApiRequest(params) {
 	const { response, release } = await fetchWithSsrFGuard({
@@ -588,7 +578,8 @@ async function guardedJsonApiRequest(params) {
 			body: params.body ? JSON.stringify(params.body) : void 0
 		},
 		policy: { allowedHostnames: params.allowedHostnames },
-		auditContext: params.auditContext
+		auditContext: params.auditContext,
+		timeoutMs: VOICE_CALL_PROVIDER_API_TIMEOUT_MS
 	});
 	try {
 		if (!response.ok) {

package/dist/index.js

@@ -1,27 +1,23 @@
 import { definePluginEntry, sleep } from "./runtime-api.js";
 import "./api.js";
-import { c as validateProviderConfig, i as resolveVoiceCallConfig } from "./config-CDSeuGp3.js";
-import { c as cleanupTailscaleExposureRoute, h as resolveUserPath, l as getTailscaleSelfInfo, s as resolveWebhookExposureStatus, t as createVoiceCallRuntime, u as setupTailscaleExposureRoute } from "./runtime-entry-DwMgbq2p.js";
-import { h as setVoiceCallStateRuntime, l as getCallHistoryFromStore } from "./store-DtewuuOb.js";
-import { i as parseVoiceCallPluginConfig, r as normalizeVoiceCallLegacyConfigInput, t as formatVoiceCallLegacyConfigWarnings } from "./config-compat-D8fcjOHp.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 { 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";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-import { isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asOptionalRecord, isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 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`);
 }
@@ -43,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 })
@@ -107,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) {
@@ -658,12 +646,12 @@ const VOICE_CALL_WRITE_METHOD_SCOPE = { scope: "operator.write" };
 const VOICE_CALL_READ_METHOD_SCOPE = { scope: "operator.read" };
 const voiceCallConfigSchema = {
 	parse(value) {
-		const normalized = normalizeVoiceCallLegacyConfigInput(value);
-		const enabled = typeof normalized.enabled === "boolean" ? normalized.enabled : true;
-		return parseVoiceCallPluginConfig({
-			...normalized,
+		const config = asOptionalRecord(value) ?? {};
+		const enabled = typeof config.enabled === "boolean" ? config.enabled : true;
+		return VoiceCallConfigSchema.parse({
+			...config,
 			enabled,
-			provider: normalized.provider ?? (enabled ? "mock" : void 0)
+			provider: config.provider ?? (enabled ? "mock" : void 0)
 		});
 	},
 	uiHints: {
@@ -743,6 +731,7 @@ const voiceCallConfigSchema = {
 		},
 		"streaming.enabled": {
 			label: "Enable Streaming",
+			help: "Classic streaming transcription currently requires the Twilio call provider.",
 			advanced: true
 		},
 		"streaming.provider": {
@@ -952,11 +941,6 @@ var voice_call_default = definePluginEntry({
 	register(api) {
 		const config = resolveVoiceCallConfig(voiceCallConfigSchema.parse(api.pluginConfig));
 		const validation = validateProviderConfig(config);
-		if (api.pluginConfig && typeof api.pluginConfig === "object") for (const warning of formatVoiceCallLegacyConfigWarnings({
-			value: api.pluginConfig,
-			configPathPrefix: "plugins.entries.voice-call.config",
-			doctorFixCommand: "openclaw doctor --fix"
-		})) api.logger.warn(warning);
 		const runtimeState = getVoiceCallRuntimeGlobalState();
 		const continueOperationStore = createVoiceCallContinueOperationStore({
 			config,

package/dist/{plivo-D5wI4-pi.js → plivo-ByAIoPFp.js}

@@ -1,5 +1,5 @@
-import { g as escapeXml, o as getHeader } from "./runtime-entry-DwMgbq2p.js";
-import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-CLVDU_h1.js";
+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 { 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-Bz-MNWtD.js → realtime-handler-DJk-eYyf.js}

@@ -884,7 +884,7 @@ var RealtimeCallHandler = class {
 					}
 				});
 				console.log(`[voice-call] realtime tool call received callId=${callId} providerCallId=${callSid} tool=${toolEvent.name}`);
-				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, emitTalkEvent);
 			},
 			onEvent: (event) => {
 				if (event.type === "input_audio_buffer.speech_started") {
@@ -1234,12 +1234,13 @@ var RealtimeCallHandler = class {
 				final: true
 			});
 		};
-		const submitFinalToolResult = (result) => {
-			bridge.submitToolResult(bridgeCallId, result);
+		const submitFinalToolResult = async (result) => {
+			await bridge.submitToolResult(bridgeCallId, result);
 			emitFinalToolEvent(result);
 		};
-		const submitWorkingResponse = () => {
+		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?.({
 					type: "tool.progress",
 					turnId,
@@ -1249,7 +1250,6 @@ var RealtimeCallHandler = class {
 						status: "working"
 					}
 				});
-				bridge.submitToolResult(bridgeCallId, buildRealtimeVoiceAgentConsultWorkingResponse("caller"), { willContinue: true });
 			}
 		};
 		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME) {
@@ -1260,45 +1260,56 @@ var RealtimeCallHandler = class {
 				if (pending) coordinator.remove(pending);
 			}
 			const forcedConsult = this.forcedConsultsByCallId.get(callId);
+			if (forcedMatch.kind === "already_delivered" && coordinator.isCancelled(forcedMatch.handle)) {
+				if (forcedConsult) forcedConsult.sendSpeechPrompt = false;
+				await submitFinalToolResult({
+					status: "cancelled",
+					message: "OpenClaw cancelled this consult before completion. Do not restart it."
+				});
+				return;
+			}
 			if (forcedConsult) {
 				if (forcedConsult.completedAt || forcedMatch.kind === "already_delivered") {
-					submitFinalToolResult({
+					await submitFinalToolResult({
 						status: "already_delivered",
 						message: "OpenClaw already delivered this consult result internally. Do not repeat it."
 					});
 					return;
 				}
 				forcedConsult.sendSpeechPrompt = false;
-				submitFinalToolResult(await forcedConsult.promise.catch((error) => ({ error: formatErrorMessage(error) })));
+				await submitFinalToolResult(await forcedConsult.promise.catch((error) => ({ error: formatErrorMessage(error) })));
 				return;
 			}
 			const existingNativeConsult = this.nativeConsultsInFlightByCallId.get(callId);
 			if (existingNativeConsult) {
 				console.log(`[voice-call] realtime tool call sharing in-flight agent consult callId=${callId} ageMs=${Date.now() - existingNativeConsult.startedAt}`);
-				submitWorkingResponse();
-				submitFinalToolResult(await existingNativeConsult.promise);
+				await submitWorkingResponse();
+				await submitFinalToolResult(await existingNativeConsult.promise);
 				return;
 			}
-			submitWorkingResponse();
 			const state = {
 				startedAt,
 				promise: Promise.resolve()
 			};
-			state.promise = (async () => {
-				await this.waitForConsultTranscriptSettle(callId, startedAt);
-				const context = { partialUserTranscript: this.resolveUserTranscriptContext(callId) };
-				state.partialUserTranscript = context.partialUserTranscript;
-				const handlerArgs = withFallbackConsultQuestion(args, context.partialUserTranscript);
-				console.log(`[voice-call] realtime tool call executing callId=${callId} tool=${name} hasHandler=${Boolean(handler)}`);
-				return !handler ? { error: `Tool "${name}" not available` } : await handler(handlerArgs, callId, context);
-			})().catch((error) => ({ error: formatErrorMessage(error) }));
+			state.promise = submitWorkingResponse().then(async () => {
+				try {
+					await this.waitForConsultTranscriptSettle(callId, startedAt);
+					const context = { partialUserTranscript: this.resolveUserTranscriptContext(callId) };
+					state.partialUserTranscript = context.partialUserTranscript;
+					const handlerArgs = withFallbackConsultQuestion(args, context.partialUserTranscript);
+					console.log(`[voice-call] realtime tool call executing callId=${callId} tool=${name} hasHandler=${Boolean(handler)}`);
+					return !handler ? { error: `Tool "${name}" not available` } : await handler(handlerArgs, callId, context);
+				} catch (error) {
+					return { error: formatErrorMessage(error) };
+				}
+			});
 			this.nativeConsultsInFlightByCallId.set(callId, state);
 			try {
 				const result = await state.promise;
 				const status = result && typeof result === "object" && !Array.isArray(result) && "error" in result ? "error" : "ok";
 				const error = status === "error" && result && typeof result === "object" && !Array.isArray(result) ? formatErrorMessage(result.error ?? "unknown") : void 0;
 				console.log(`[voice-call] realtime tool call completed callId=${callId} tool=${name} status=${status} elapsedMs=${Date.now() - startedAt}${error ? ` error=${error}` : ""}`);
-				submitFinalToolResult(result);
+				await submitFinalToolResult(result);
 				if (status === "ok") this.consumePartialUserTranscript(callId, state.partialUserTranscript);
 			} finally {
 				if (this.nativeConsultsInFlightByCallId.get(callId) === state) this.nativeConsultsInFlightByCallId.delete(callId);
@@ -1312,7 +1323,7 @@ var RealtimeCallHandler = class {
 		const status = result && typeof result === "object" && !Array.isArray(result) && "error" in result ? "error" : "ok";
 		const error = status === "error" && result && typeof result === "object" && !Array.isArray(result) ? formatErrorMessage(result.error ?? "unknown") : void 0;
 		console.log(`[voice-call] realtime tool call completed callId=${callId} tool=${name} status=${status} elapsedMs=${Date.now() - startedAt}${error ? ` error=${error}` : ""}`);
-		submitFinalToolResult(result);
+		await submitFinalToolResult(result);
 		if (name === REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME && status === "ok") this.consumePartialUserTranscript(callId, context.partialUserTranscript);
 	}
 };

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

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