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

package/dist/{plivo-wmeT9r_t.js → plivo-BnCuAGwj.js}

@@ -1,5 +1,5 @@
-import { a as getHeader, m as escapeXml } from "./runtime-entry-DN7HllXj.js";
-import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-7ITxTL6G.js";
+import { g as escapeXml, o as getHeader } from "./runtime-entry-kCq5Xjph.js";
+import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-BrBbW_RJ.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/plivo.ts
@@ -75,9 +75,17 @@ var PlivoProvider = class PlivoProvider {
 			const callId = this.getCallIdFromQuery(ctx);
 			const pending = callId ? this.pendingSpeakByCallId.get(callId) : void 0;
 			if (callId) this.pendingSpeakByCallId.delete(callId);
+			const actionUrl = pending?.listenAfterPlayback && callId ? this.buildActionUrl(ctx, {
+				flow: "getinput",
+				callId
+			}) : null;
 			return {
 				events: [],
-				providerResponseBody: pending ? PlivoProvider.xmlSpeak(pending.text, pending.locale) : PlivoProvider.xmlKeepAlive(),
+				providerResponseBody: pending ? actionUrl ? PlivoProvider.xmlSpeakAndListen({
+					text: pending.text,
+					language: pending.locale,
+					actionUrl
+				}) : PlivoProvider.xmlSpeak(pending.text, pending.locale) : PlivoProvider.xmlKeepAlive(),
 				providerResponseHeaders: { "Content-Type": "text/xml" },
 				statusCode: 200
 			};
@@ -244,7 +252,8 @@ var PlivoProvider = class PlivoProvider {
 		});
 		this.pendingSpeakByCallId.set(input.callId, {
 			text: input.text,
-			locale: input.locale
+			locale: input.locale,
+			listenAfterPlayback: input.listenAfterPlayback
 		});
 		await this.transferCallLeg({
 			callUuid,
@@ -269,7 +278,7 @@ var PlivoProvider = class PlivoProvider {
 	}
 	async stopListening(_input) {}
 	async getCallStatus(input) {
-		const terminalStatuses = new Set([
+		const terminalStatuses = /* @__PURE__ */ new Set([
 			"completed",
 			"busy",
 			"failed",
@@ -331,7 +340,17 @@ var PlivoProvider = class PlivoProvider {
 		const language = params.language || "en-US";
 		return `<?xml version="1.0" encoding="UTF-8"?>
 <Response>
-  <GetInput inputType="speech" method="POST" action="${escapeXml(params.actionUrl)}" language="${escapeXml(language)}" executionTimeout="30" speechEndTimeout="1" redirect="false">
+  <GetInput inputType="speech" method="POST" action="${escapeXml(params.actionUrl)}" language="${escapeXml(language)}" executionTimeout="30" speechEndTimeout="2" redirect="false">
+  </GetInput>
+  <Wait length="300" />
+</Response>`;
+	}
+	static xmlSpeakAndListen(params) {
+		const language = params.language || "en-US";
+		return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <GetInput inputType="speech" method="POST" action="${escapeXml(params.actionUrl)}" language="${escapeXml(language)}" executionTimeout="30" speechEndTimeout="2" redirect="false">
+    <Speak language="${escapeXml(language)}">${escapeXml(params.text)}</Speak>
   </GetInput>
   <Wait length="300" />
 </Response>`;

package/dist/{realtime-handler-DdViwdCW.js → realtime-handler-Bz-MNWtD.js}

@@ -1,12 +1,12 @@
-import { l as normalizePath } from "./config-DNtTB7Iw.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, buildRealtimeVoiceAgentConsultWorkingResponse, createRealtimeVoiceBridgeSession, createRealtimeVoiceForcedConsultCoordinator, createTalkSessionController, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult, recordTalkObservabilityEvent } from "openclaw/plugin-sdk/realtime-voice";
+import { normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import { randomUUID } from "node:crypto";
-import "node:http";
-import WebSocket, { WebSocketServer } from "ws";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import "node:http";
+import WebSocket$1, { WebSocketServer } from "ws";
 //#region extensions/voice-call/src/webhook/realtime-audio-pacer.ts
 const TELEPHONY_SAMPLE_RATE = 8e3;
 const TELEPHONY_CHUNK_BYTES = 160;
@@ -16,7 +16,7 @@ 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 = new Int16Array(256);
+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 {
@@ -65,6 +65,10 @@ var RealtimeAudioPacer = class {
 		this.params.send(this.params.serializer.clear());
 		return clearedAudioBytes;
 	}
+	/** True while queued audio or a paced send timer can still reach the telephony stream. */
+	hasPendingAudio() {
+		return !this.closed && (this.queuedAudioBytes > 0 || this.timer !== null);
+	}
 	/** Stop sending and discard queued frames. */
 	close() {
 		this.closed = true;
@@ -378,6 +382,21 @@ function appendTranscriptText(base, fragment) {
 	if (overlap >= 6 || overlap >= 3 && next.length <= 12) return `${current}${next.slice(overlap)}`.trim();
 	return `${current}${shouldInsertTranscriptSpace(current, next) ? " " : ""}${next}`.trim();
 }
+function resolveFinalTranscriptText(params) {
+	const final = normalizeTranscriptText(params.final);
+	const rawPartial = params.rawPartial ?? "";
+	const partial = normalizeTranscriptText(params.partial ?? rawPartial);
+	if (!partial) return final;
+	if (!final) return partial;
+	const compact = (value) => value.toLowerCase().replaceAll(/\s/g, "");
+	const compactFinal = compact(final);
+	const compactRaw = compact(rawPartial);
+	const compactPartial = compact(partial);
+	if (compactFinal.startsWith(compactPartial) || compactFinal.endsWith(compactPartial)) return final;
+	if (compactPartial.endsWith(compactFinal)) return partial;
+	if (compactRaw !== compactPartial) return appendTranscriptText(partial, params.final);
+	return normalizeTranscriptText(`${rawPartial}${params.final}`);
+}
 function limitPartialUserTranscript(text) {
 	if (text.length <= MAX_PARTIAL_USER_TRANSCRIPT_CHARS) return text;
 	const tail = sliceUtf16Safe(text, -1200);
@@ -438,7 +457,7 @@ function appendRecentTalkEventMetadata(call, event) {
 	call.metadata = metadata;
 }
 var RealtimeCallHandler = class {
-	constructor(config, manager, provider, realtimeProvider, providerConfig, servePath, coreConfig) {
+	constructor(config, manager, provider, realtimeProvider, providerConfig, servePath, coreConfig, resolveInstructions) {
 		this.config = config;
 		this.manager = manager;
 		this.provider = provider;
@@ -446,11 +465,13 @@ var RealtimeCallHandler = class {
 		this.providerConfig = providerConfig;
 		this.servePath = servePath;
 		this.coreConfig = coreConfig;
+		this.resolveInstructions = resolveInstructions;
 		this.toolHandlers = /* @__PURE__ */ new Map();
 		this.pendingStreamTokens = /* @__PURE__ */ new Map();
 		this.activeBridgesByCallId = /* @__PURE__ */ new Map();
 		this.activeTelephonyClosersByCallId = /* @__PURE__ */ new Map();
 		this.partialUserTranscriptsByCallId = /* @__PURE__ */ new Map();
+		this.rawPartialUserTranscriptsByCallId = /* @__PURE__ */ new Map();
 		this.partialUserTranscriptUpdatedAtByCallId = /* @__PURE__ */ new Map();
 		this.recentFinalUserTranscriptsByCallId = /* @__PURE__ */ new Map();
 		this.recentFinalUserTranscriptTimersByCallId = /* @__PURE__ */ new Map();
@@ -464,8 +485,8 @@ var RealtimeCallHandler = class {
 		try {
 			const parsed = new URL(url);
 			this.publicOrigin = parsed.host;
-			const normalizedServePath = normalizePath(this.servePath);
-			const normalizedPublicPath = normalizePath(parsed.pathname);
+			const normalizedServePath = normalizeWebhookPath(this.servePath);
+			const normalizedPublicPath = normalizeWebhookPath(parsed.pathname);
 			const idx = normalizedPublicPath.indexOf(normalizedServePath);
 			this.publicPathPrefix = idx > 0 ? normalizedPublicPath.slice(0, idx) : "";
 		} catch {
@@ -474,7 +495,7 @@ var RealtimeCallHandler = class {
 		}
 	}
 	getStreamPathPattern() {
-		return `${this.publicPathPrefix}${normalizePath(this.config.streamPath ?? "/voice/stream/realtime")}`;
+		return `${this.publicPathPrefix}${normalizeWebhookPath(this.config.streamPath ?? "/voice/stream/realtime")}`;
 	}
 	buildTwiMLPayload(req, params) {
 		const rawDirection = params?.get("Direction");
@@ -638,7 +659,7 @@ var RealtimeCallHandler = class {
 			ws.close(1008, "Caller rejected by policy");
 			return null;
 		}
-		const { callId, initialGreetingInstructions } = registration;
+		const { callId, instructions, initialGreetingInstructions } = registration;
 		const callRecord = this.manager.getCallByProviderCallId(callSid);
 		const talk = createTalkSessionController({
 			sessionId: `voice-call:${callId}:realtime`,
@@ -677,6 +698,28 @@ var RealtimeCallHandler = class {
 				reason
 			} }));
 		};
+		const providerHandlesInputAudioBargeIn = this.realtimeProvider.capabilities?.handlesInputAudioBargeIn === true;
+		const cancelOutputAudioForBargeIn = (source, interruptProvider, clearedAudioBytes = 0) => {
+			const outputAudioActive = talk.outputAudioActive;
+			const pendingTelephonyAudio = audioPacer.hasPendingAudio();
+			if (source === "provider" && !outputAudioActive && !pendingTelephonyAudio && clearedAudioBytes === 0) return;
+			const interruptedTurnId = talk.activeTurnId;
+			interruptProvider?.(outputAudioActive || pendingTelephonyAudio);
+			const clearedBytes = clearedAudioBytes + (source === "local" || pendingTelephonyAudio ? audioPacer.clearAudio() : 0);
+			console.log(`[voice-call] realtime outbound audio cleared by ${source} barge-in callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
+			if (!outputAudioActive || !interruptedTurnId) return;
+			const reason = `${source}-barge-in`;
+			finishOutputAudio(reason);
+			const cancelled = talk.cancelTurn({
+				turnId: interruptedTurnId,
+				payload: {
+					callId,
+					providerCallId: callSid,
+					reason
+				}
+			});
+			if (cancelled.ok) rememberTalkEvent(cancelled.event);
+		};
 		emitTalkEvent({
 			type: "session.started",
 			payload: {
@@ -693,7 +736,7 @@ var RealtimeCallHandler = class {
 			this.endCallInManager(callSid, callId, reason);
 		};
 		const sendString = (message) => {
-			if (ws.readyState !== WebSocket.OPEN) return false;
+			if (ws.readyState !== WebSocket$1.OPEN) return false;
 			if (ws.bufferedAmount > MAX_REALTIME_WS_BUFFERED_BYTES) {
 				console.warn(`[voice-call] realtime outbound websocket backpressure before send callId=${callId} providerCallId=${callSid} bufferedBytes=${ws.bufferedAmount}`);
 				ws.close(1013, "Backpressure: send buffer exceeded");
@@ -716,20 +759,22 @@ var RealtimeCallHandler = class {
 			},
 			onBackpressure: () => {
 				console.warn(`[voice-call] realtime paced audio backpressure callId=${callId} providerCallId=${callSid}`);
-				if (ws.readyState === WebSocket.OPEN) ws.close(1013, "Backpressure: paced audio queue exceeded");
+				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 interruptResponseOnInputAudio = typeof this.providerConfig.interruptResponseOnInputAudio === "boolean" ? this.providerConfig.interruptResponseOnInputAudio : void 0;
 		const session = createRealtimeVoiceBridgeSession({
 			provider: this.realtimeProvider,
 			cfg: this.coreConfig,
 			providerConfig: this.providerConfig,
-			instructions: this.config.instructions,
+			interruptResponseOnInputAudio,
+			instructions,
 			tools: this.config.tools,
 			initialGreetingInstructions,
 			triggerGreetingOnReady: Boolean(initialGreetingInstructions),
 			audioSink: {
-				isOpen: () => ws.readyState === WebSocket.OPEN,
+				isOpen: () => ws.readyState === WebSocket$1.OPEN,
 				sendAudio: (muLaw) => {
 					const turnId = ensureTalkTurn();
 					rememberTalkEvent(talk.startOutputAudio({
@@ -746,8 +791,12 @@ var RealtimeCallHandler = class {
 					});
 					audioPacer.sendAudio(muLaw);
 				},
-				clearAudio: () => {
+				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");
 				},
@@ -783,7 +832,11 @@ var RealtimeCallHandler = class {
 					return;
 				}
 				if (role === "user") {
-					const transcript = this.recordPartialUserTranscript(callId, text);
+					const transcript = resolveFinalTranscriptText({
+						partial: this.partialUserTranscriptsByCallId.get(callId),
+						rawPartial: this.rawPartialUserTranscriptsByCallId.get(callId),
+						final: text
+					});
 					this.clearPartialUserTranscript(callId);
 					this.setRecentFinalUserTranscript(callId, transcript);
 					console.log(`[voice-call] realtime input transcript callId=${callId} providerCallId=${callSid} final=true chars=${text.trim().length} aggregateChars=${transcript.length}`);
@@ -811,11 +864,11 @@ var RealtimeCallHandler = class {
 				}
 				this.manager.processEvent({
 					id: `realtime-bot-${callSid}-${Date.now()}`,
-					type: "call.speaking",
+					type: "call.assistant-speech",
 					callId,
 					providerCallId: callSid,
 					timestamp: Date.now(),
-					text
+					transcript: text
 				});
 			},
 			onToolCall: (toolEvent, sessionLocal) => {
@@ -895,7 +948,7 @@ var RealtimeCallHandler = class {
 				});
 				if (reason !== "error") return;
 				emitCallEnd("error");
-				if (ws.readyState === WebSocket.OPEN) ws.close(1011, "Bridge disconnected");
+				if (ws.readyState === WebSocket$1.OPEN) ws.close(1011, "Bridge disconnected");
 				this.provider.hangupCall({
 					callId,
 					providerCallId: callSid,
@@ -906,8 +959,11 @@ var RealtimeCallHandler = class {
 			}
 		});
 		const closeTelephony = (reason) => {
-			emitCallEnd(reason);
-			session.close();
+			try {
+				session.close();
+			} finally {
+				emitCallEnd(reason);
+			}
 		};
 		this.activeBridgesByCallId.set(callId, session);
 		this.activeBridgesByCallId.set(callSid, session);
@@ -916,19 +972,10 @@ var RealtimeCallHandler = class {
 		const sendAudioToSession = session.sendAudio.bind(session);
 		session.sendAudio = (audio) => {
 			if (speechDetector.accept(audio)) {
-				const interruptedTurnId = ensureTalkTurn();
-				const clearedBytes = audioPacer.clearAudio();
-				console.log(`[voice-call] realtime outbound audio cleared by barge-in callId=${callId} providerCallId=${callSid} queuedBytes=${clearedBytes}`);
-				finishOutputAudio("barge-in");
-				const cancelled = talk.cancelTurn({
-					turnId: interruptedTurnId,
-					payload: {
-						callId,
-						providerCallId: callSid,
-						reason: "barge-in"
-					}
+				console.log(`[voice-call] realtime local speech detected callId=${callId} providerCallId=${callSid}`);
+				if (!providerHandlesInputAudioBargeIn) cancelOutputAudioForBargeIn("local", (audioPlaybackActive) => {
+					session.handleBargeIn({ audioPlaybackActive });
 				});
-				if (cancelled.ok) rememberTalkEvent(cancelled.event);
 			}
 			emitTalkEvent({
 				type: "input.audio.delta",
@@ -938,15 +985,21 @@ var RealtimeCallHandler = class {
 			sendAudioToSession(audio);
 		};
 		const closeSession = session.close.bind(session);
+		let sessionClosed = false;
 		session.close = () => {
-			this.activeBridgesByCallId.delete(callId);
-			this.activeBridgesByCallId.delete(callSid);
-			this.activeTelephonyClosersByCallId.delete(callId);
-			this.activeTelephonyClosersByCallId.delete(callSid);
-			this.clearUserTranscriptState(callId);
-			this.clearForcedConsultState(callId);
-			audioPacer.close();
-			closeSession();
+			if (sessionClosed) return;
+			sessionClosed = true;
+			try {
+				closeSession();
+			} finally {
+				this.activeBridgesByCallId.delete(callId);
+				this.activeBridgesByCallId.delete(callSid);
+				this.activeTelephonyClosersByCallId.delete(callId);
+				this.activeTelephonyClosersByCallId.delete(callSid);
+				this.clearUserTranscriptState(callId);
+				this.clearForcedConsultState(callId);
+				audioPacer.close();
+			}
 		};
 		session.connect().catch((error) => {
 			console.error("[voice-call] Failed to connect realtime bridge:", error);
@@ -958,12 +1011,15 @@ var RealtimeCallHandler = class {
 	}
 	recordPartialUserTranscript(callId, text) {
 		const next = limitPartialUserTranscript(appendTranscriptText(this.partialUserTranscriptsByCallId.get(callId), text));
+		const raw = limitPartialUserTranscript(`${this.rawPartialUserTranscriptsByCallId.get(callId) ?? ""}${text}`);
 		this.partialUserTranscriptsByCallId.set(callId, next);
+		this.rawPartialUserTranscriptsByCallId.set(callId, raw);
 		this.partialUserTranscriptUpdatedAtByCallId.set(callId, Date.now());
 		return next;
 	}
 	clearPartialUserTranscript(callId) {
 		this.partialUserTranscriptsByCallId.delete(callId);
+		this.rawPartialUserTranscriptsByCallId.delete(callId);
 		this.partialUserTranscriptUpdatedAtByCallId.delete(callId);
 	}
 	setRecentFinalUserTranscript(callId, text) {
@@ -1002,8 +1058,10 @@ var RealtimeCallHandler = class {
 		}
 		if (current.toLowerCase().startsWith(text.toLowerCase())) {
 			const remaining = current.slice(text.length).trimStart();
-			if (remaining) this.partialUserTranscriptsByCallId.set(callId, remaining);
-			else this.clearPartialUserTranscript(callId);
+			if (remaining) {
+				this.partialUserTranscriptsByCallId.set(callId, remaining);
+				this.rawPartialUserTranscriptsByCallId.set(callId, remaining);
+			} else this.clearPartialUserTranscript(callId);
 		}
 		const recent = this.recentFinalUserTranscriptsByCallId.get(callId);
 		if (!recent) return;
@@ -1125,9 +1183,11 @@ var RealtimeCallHandler = class {
 			type: "call.answered",
 			...baseFields
 		});
+		const instructions = this.resolveInstructions?.(callRecord) ?? this.config.instructions;
 		return {
 			callId: callRecord.callId,
-			initialGreetingInstructions: buildGreetingInstructions(this.config.instructions, initialGreeting)
+			instructions,
+			initialGreetingInstructions: buildGreetingInstructions(instructions, initialGreeting)
 		};
 	}
 	resolveRealtimeCall(callSid, callerMeta, baseFields) {

package/dist/response-generator-PXuisI3L.js

@@ -0,0 +1,272 @@
+import { s as resolveVoiceCallSessionKey } from "./config-CgigQDrF.js";
+import { m as resolveCallAgentId, p as resolveVoiceResponseModel } from "./runtime-entry-kCq5Xjph.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";
+//#region extensions/voice-call/src/response-generator.ts
+/**
+* Voice call response generator - uses the embedded OpenClaw agent for tool support.
+* Routes voice responses through the same agent infrastructure as messaging.
+*/
+function readExplicitToolsAllow(value) {
+	if (!isRecord(value)) return;
+	const allow = value.allow;
+	if (!Array.isArray(allow)) return;
+	return allow.filter((entry) => typeof entry === "string");
+}
+function resolveVoiceAgentToolsAllow(config, agentId) {
+	const agents = isRecord(config.agents) ? config.agents : void 0;
+	const agent = (Array.isArray(agents?.list) ? agents.list : []).find((entry) => isRecord(entry) && entry.id === agentId);
+	if (!isRecord(agent)) return;
+	return readExplicitToolsAllow(isRecord(agent.tools) ? agent.tools : void 0);
+}
+const VOICE_SPOKEN_OUTPUT_CONTRACT = [
+	"Output format requirements:",
+	"- Return only valid JSON in this exact shape: {\"spoken\":\"...\"}",
+	"- Do not include markdown, code fences, planning text, or extra keys.",
+	"- Put exactly what should be spoken to the caller into \"spoken\".",
+	"- If there is nothing to say, return {\"spoken\":\"\"}."
+].join("\n");
+function normalizeSpokenText(value) {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	return normalized.length > 0 ? normalized : null;
+}
+function tryParseSpokenJson(text) {
+	const candidates = [];
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	candidates.push(trimmed);
+	const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+	if (fenced?.[1]) candidates.push(fenced[1]);
+	const firstBrace = trimmed.indexOf("{");
+	const lastBrace = trimmed.lastIndexOf("}");
+	if (firstBrace >= 0 && lastBrace > firstBrace) candidates.push(trimmed.slice(firstBrace, lastBrace + 1));
+	for (const candidate of candidates) try {
+		const parsed = JSON.parse(candidate);
+		if (typeof parsed?.spoken !== "string") continue;
+		return normalizeSpokenText(parsed.spoken) ?? "";
+	} catch {}
+	const inlineSpokenMatch = trimmed.match(/"spoken"\s*:\s*"((?:[^"\\]|\\.)*)"/i);
+	if (!inlineSpokenMatch) return null;
+	try {
+		return normalizeSpokenText(JSON.parse(`"${inlineSpokenMatch[1] ?? ""}"`)) ?? "";
+	} catch {
+		return null;
+	}
+}
+function isLikelyMetaReasoningParagraph(paragraph) {
+	const lower = normalizeLowercaseStringOrEmpty(paragraph);
+	if (!lower) return false;
+	if (lower.startsWith("thinking process")) return true;
+	if (lower.startsWith("reasoning:") || lower.startsWith("analysis:")) return true;
+	if (lower.startsWith("the user ") && (lower.includes("i should") || lower.includes("i need to") || lower.includes("i will"))) return true;
+	if (lower.includes("this is a natural continuation of the conversation") || lower.includes("keep the conversation flowing")) return true;
+	return false;
+}
+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();
+	return normalizeSpokenText(paragraphs.join(" "));
+}
+function extractSpokenTextFromPayloads(payloads) {
+	const spokenSegments = [];
+	for (const payload of payloads) {
+		if (payload.isError || payload.isReasoning) continue;
+		const rawText = payload.text?.trim() ?? "";
+		if (!rawText) continue;
+		const structured = tryParseSpokenJson(rawText);
+		if (structured !== null) {
+			if (structured.length > 0) spokenSegments.push(structured);
+			continue;
+		}
+		const plain = sanitizePlainSpokenText(rawText);
+		if (plain) spokenSegments.push(plain);
+	}
+	return spokenSegments.length > 0 ? spokenSegments.join(" ").trim() : null;
+}
+async function deliverEarlyText(callback, text) {
+	try {
+		return await callback(text);
+	} catch (error) {
+		console.error("[voice-call] Early TTS delivery failed:", error);
+		return false;
+	}
+}
+function resolveVoiceSandboxSessionKey(agentId, sessionKey) {
+	const trimmed = sessionKey.trim();
+	if (trimmed.toLowerCase().startsWith("agent:")) return trimmed;
+	return `agent:${agentId}:${trimmed}`;
+}
+/**
+* Generate a voice response using the embedded OpenClaw agent with full tool support.
+* Uses the same agent infrastructure as messaging for consistent behavior.
+*/
+async function generateVoiceResponse(params) {
+	const { voiceConfig, callId, sessionKey, from, transcript, userMessage, coreConfig, agentRuntime, onEarlyText } = params;
+	if (!coreConfig) return {
+		text: null,
+		deliveredEarly: false,
+		error: "Core config unavailable for voice response"
+	};
+	const cfg = coreConfig;
+	const agentId = resolveCallAgentId({ agentId: params.agentId }, voiceConfig);
+	const resolvedSessionKey = resolveVoiceCallSessionKey({
+		config: {
+			...voiceConfig,
+			agentId
+		},
+		callId,
+		phone: from,
+		explicitSessionKey: sessionKey,
+		coreSession: coreConfig.session
+	});
+	const toolsAllow = resolveVoiceAgentToolsAllow(cfg, agentId);
+	const storePath = agentRuntime.session.resolveStorePath(cfg.session?.store, { agentId });
+	try {
+		return await agentRuntime.session.runWithWorkAdmission({
+			storePath,
+			sessionKey: resolvedSessionKey
+		}, async (abortSignal) => {
+			const agentDir = agentRuntime.resolveAgentDir(cfg, agentId);
+			const workspaceDir = agentRuntime.resolveAgentWorkspaceDir(cfg, agentId);
+			await agentRuntime.ensureAgentWorkspace({ dir: workspaceDir });
+			const now = Date.now();
+			const existingSessionEntry = agentRuntime.session.getSessionEntry({
+				storePath,
+				sessionKey: resolvedSessionKey
+			});
+			const { provider, model } = resolveVoiceResponseModel({
+				voiceConfig,
+				agentRuntime
+			});
+			let sessionEntry = existingSessionEntry;
+			if (!sessionEntry?.sessionId || voiceConfig.responseModel) sessionEntry = await agentRuntime.session.patchSessionEntry({
+				storePath,
+				sessionKey: resolvedSessionKey,
+				replaceEntry: true,
+				fallbackEntry: sessionEntry ?? {
+					sessionId: crypto.randomUUID(),
+					updatedAt: now
+				},
+				update: (entry) => {
+					const next = entry.sessionId ? { ...entry } : {
+						...entry,
+						sessionId: crypto.randomUUID(),
+						updatedAt: now
+					};
+					if (voiceConfig.responseModel) applyModelOverrideToSessionEntry({
+						entry: next,
+						selection: {
+							provider,
+							model
+						},
+						selectionSource: "auto"
+					});
+					return next;
+				}
+			}) ?? void 0;
+			if (!sessionEntry?.sessionId) return {
+				text: null,
+				deliveredEarly: false,
+				error: "Voice response session could not be initialized"
+			};
+			const sessionId = sessionEntry.sessionId;
+			const thinkLevel = agentRuntime.resolveThinkingDefault({
+				cfg,
+				provider,
+				model
+			});
+			const agentName = agentRuntime.resolveAgentIdentity(cfg, agentId)?.name?.trim() || "assistant";
+			const basePrompt = voiceConfig.responseSystemPrompt ?? `You are ${agentName}, a helpful voice assistant on a phone call. Keep responses brief and conversational (1-2 sentences max). Be natural and friendly. The caller's phone number is ${from}. You have access to tools - use them when helpful.`;
+			let extraSystemPrompt = basePrompt;
+			if (transcript.length > 0) extraSystemPrompt = `${basePrompt}\n\nConversation so far:\n${transcript.map((entry) => `${entry.speaker === "bot" ? "You" : "Caller"}: ${entry.text}`).join("\n")}`;
+			extraSystemPrompt = `${extraSystemPrompt}\n\n${VOICE_SPOKEN_OUTPUT_CONTRACT}`;
+			const timeoutMs = voiceConfig.responseTimeoutMs ?? agentRuntime.resolveAgentTimeoutMs({ cfg });
+			const runId = `voice:${callId}:${Date.now()}`;
+			const blockReplyPayloads = [];
+			let latestToolBoundaryMessageIndex;
+			let blockReplyBoundariesReliable = true;
+			let deliveredEarly = false;
+			let lastFlushedText = null;
+			const result = await agentRuntime.runEmbeddedAgent({
+				sessionId,
+				sessionKey: resolvedSessionKey,
+				sessionTarget: {
+					agentId,
+					sessionId,
+					sessionKey: resolvedSessionKey,
+					storePath
+				},
+				sandboxSessionKey: resolveVoiceSandboxSessionKey(agentId, resolvedSessionKey),
+				agentId,
+				messageProvider: "voice",
+				workspaceDir,
+				config: cfg,
+				prompt: userMessage,
+				provider,
+				model,
+				thinkLevel,
+				verboseLevel: "off",
+				timeoutMs,
+				runId,
+				lane: "voice",
+				extraSystemPrompt,
+				agentDir,
+				toolsAllow,
+				abortSignal,
+				blockReplyBreak: "text_end",
+				onBlockReply: (payload, context) => {
+					if (latestToolBoundaryMessageIndex !== void 0) {
+						const messageIndex = context?.assistantMessageIndex;
+						if (messageIndex === void 0) {
+							blockReplyBoundariesReliable = false;
+							return;
+						}
+						if (messageIndex <= latestToolBoundaryMessageIndex) return;
+					}
+					blockReplyPayloads.push(payload);
+				},
+				onBlockReplyFlush: async (context) => {
+					if (context.reason === "tool_start") {
+						blockReplyPayloads.length = 0;
+						latestToolBoundaryMessageIndex = context.assistantMessageIndex;
+						blockReplyBoundariesReliable = true;
+						return;
+					}
+					if (context.reason !== "pre_compaction") return;
+					const pendingPayloads = blockReplyPayloads.splice(0);
+					const boundariesReliable = blockReplyBoundariesReliable;
+					latestToolBoundaryMessageIndex = void 0;
+					blockReplyBoundariesReliable = true;
+					if (!context.attemptAccepted) return;
+					if (deliveredEarly || !onEarlyText || !boundariesReliable) return;
+					const text = extractSpokenTextFromPayloads(pendingPayloads);
+					if (!text) return;
+					lastFlushedText = text;
+					deliveredEarly = await deliverEarlyText(onEarlyText, text);
+				}
+			});
+			const text = extractSpokenTextFromPayloads(result.payloads ?? []) ?? lastFlushedText ?? extractSpokenTextFromPayloads(blockReplyPayloads);
+			if (!text && result.meta?.aborted) return {
+				text: null,
+				deliveredEarly: false,
+				error: "Response generation was aborted"
+			};
+			return {
+				text,
+				deliveredEarly
+			};
+		});
+	} catch (err) {
+		console.error(`[voice-call] Response generation failed:`, err);
+		return {
+			text: null,
+			deliveredEarly: false,
+			error: String(err)
+		};
+	}
+}
+//#endregion
+export { generateVoiceResponse };