@openclaw/voice-call 2026.8.1-beta.2 → 2026.8.1

package/dist/index.js

@@ -1,41 +1,183 @@
 import { definePluginEntry, sleep } from "./runtime-api.js";
 import "./api.js";
 import { VOICE_CALL_CLI_DESCRIPTOR } from "./cli-output-mode.js";
-import { S as validateProviderConfig, b as resolveVoiceCallConfig, c as resolveWebhookExposureStatus, d as setupTailscaleExposureRoute, g as resolveUserPath, l as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime, u as getTailscaleSelfInfo, y as VoiceCallConfigSchema } from "./runtime-entry-F13eJ4pp.js";
-import { b as setVoiceCallStateRuntime, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-51_oC_xn.js";
+import { C as resolveVoiceCallStreamExposurePaths, b as resolveVoiceCallConfig, c as resolveWebhookExposureStatus, d as setupTailscaleExposureRoutes, g as resolveUserPath, l as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime, u as getTailscaleSelfInfo, w as validateProviderConfig, y as VoiceCallConfigSchema } from "./runtime-entry-q02qkX8F.js";
+import { b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, l as findCallMatchesInStore, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-Cf6k3F2U.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { ErrorCodes, callGatewayFromCli, errorShape } from "openclaw/plugin-sdk/gateway-runtime";
+import { ErrorCodes, callGatewayFromCli, errorShape, isGatewayClientRequestError, isGatewayTransportError, redactSensitiveUrlLikeString } from "openclaw/plugin-sdk/gateway-runtime";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { asNonArrayRecord, asOptionalRecord, isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
+import { MAX_TCP_PORT, MAX_TIMER_TIMEOUT_MS, addTimerTimeoutGraceMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
-import { MAX_TCP_PORT, MAX_TIMER_TIMEOUT_MS, addTimerTimeoutGraceMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { StringDecoder } from "node:string_decoder";
 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;
-function writeStdoutLine(...values) {
+//#region extensions/voice-call/src/cli-command-io.ts
+function writeCliLine(...values) {
 	process.stdout.write(`${format(...values)}\n`);
 }
-function writeStdoutJson(value) {
+function writeCliJson(value) {
 	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
-function parseVoiceCallIntOption(raw, optionName, opts) {
+function parseCliInteger(raw, optionName, opts) {
 	const min = opts?.min ?? 0;
 	const parsed = parseStrictNonNegativeInteger(raw?.trim() ?? "");
 	if (parsed === void 0 || parsed < min || opts?.max !== void 0 && parsed > opts.max) throw new Error(`Invalid numeric value for ${optionName}: ${raw ?? ""}`);
 	return parsed;
 }
+//#endregion
+//#region extensions/voice-call/src/cli-call-log.ts
+function percentile(values, p) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].toSorted((a, b) => a - b);
+	return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1))] ?? 0;
+}
+function summarizeSeries(values) {
+	if (values.length === 0) return {
+		count: 0,
+		minMs: 0,
+		maxMs: 0,
+		avgMs: 0,
+		p50Ms: 0,
+		p95Ms: 0
+	};
+	const minMs = values.reduce((min, value) => value < min ? value : min);
+	const maxMs = values.reduce((max, value) => value > max ? value : max);
+	const avgMs = values.reduce((sum, value) => sum + value, 0) / values.length;
+	return {
+		count: values.length,
+		minMs,
+		maxMs,
+		avgMs,
+		p50Ms: percentile(values, 50),
+		p95Ms: percentile(values, 95)
+	};
+}
+function writeVoiceCallLatencySummary(calls) {
+	const turnLatencyMs = [];
+	const listenWaitMs = [];
+	for (const call of calls) {
+		const metadata = isRecord(call) && isRecord(call.metadata) ? call.metadata : void 0;
+		const latency = metadata?.lastTurnLatencyMs;
+		const listenWait = metadata?.lastTurnListenWaitMs;
+		if (typeof latency === "number" && Number.isFinite(latency)) turnLatencyMs.push(latency);
+		if (typeof listenWait === "number" && Number.isFinite(listenWait)) listenWaitMs.push(listenWait);
+	}
+	writeCliJson({
+		recordsScanned: calls.length,
+		turnLatency: summarizeSeries(turnLatencyMs),
+		listenWait: summarizeSeries(listenWaitMs)
+	});
+}
+function registerVoiceCallLogs(params) {
+	params.root.command("tail").description("Tail voice-call JSONL logs (prints new lines; useful during provider tests)").option("--file <path>", "Path to calls.jsonl", params.defaultFile).option("--since <n>", "Print last N lines first", "25").option("--poll <ms>", "Poll interval in ms", "250").action(async (options) => {
+		const file = options.file;
+		const since = parseCliInteger(options.since, "--since", { min: 0 });
+		const pollMs = parseCliInteger(options.poll, "--poll", { min: 50 });
+		const tailSqliteHistory = async (initialLimit) => {
+			params.ensureHistoryStateRuntime();
+			const seen = /* @__PURE__ */ new Set();
+			const printCall = (call) => {
+				const line = JSON.stringify(call);
+				if (!seen.has(line)) {
+					seen.add(line);
+					writeCliLine(line);
+				}
+			};
+			if (initialLimit > 0) for (const call of await getCallHistoryFromStore(path.dirname(file), initialLimit)) printCall(call);
+			for (;;) {
+				try {
+					for (const call of await getCallHistoryFromStore(path.dirname(file), 1e3)) printCall(call);
+				} catch {}
+				await sleep(pollMs);
+			}
+		};
+		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") {
+			const initial = fs.readFileSync(file);
+			let decoder = new StringDecoder("utf8");
+			const initialLines = decoder.write(initial).split("\n");
+			let pendingLine = initialLines.pop() ?? "";
+			const lines = initialLines.filter(Boolean);
+			for (const line of lines.slice(Math.max(0, lines.length - since))) writeCliLine(line);
+			let offset = initial.length;
+			let lastObservedSize = initial.length;
+			for (;;) {
+				try {
+					const stat = fs.statSync(file);
+					if (stat.size < lastObservedSize) {
+						offset = 0;
+						decoder = new StringDecoder("utf8");
+						pendingLine = "";
+					}
+					lastObservedSize = stat.size;
+					if (stat.size > offset) {
+						const fd = fs.openSync(file, "r");
+						try {
+							const buf = Buffer.alloc(stat.size - offset);
+							const bytesRead = fs.readSync(fd, buf, 0, buf.length, offset);
+							offset += bytesRead;
+							const text = decoder.write(buf.subarray(0, bytesRead));
+							const completeLines = `${pendingLine}${text}`.split("\n");
+							pendingLine = completeLines.pop() ?? "";
+							for (const line of completeLines.filter(Boolean)) writeCliLine(line);
+						} finally {
+							fs.closeSync(fd);
+						}
+					}
+				} catch {}
+				await sleep(pollMs);
+			}
+		} else await tailSqliteHistory(since);
+	});
+	params.root.command("latency").description("Summarize turn latency metrics from voice-call JSONL logs").option("--file <path>", "Path to calls.jsonl", params.defaultFile).option("--last <n>", "Analyze last N records", "200").action(async (options) => {
+		const file = options.file;
+		const last = parseCliInteger(options.last, "--last", { min: 1 });
+		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") writeVoiceCallLatencySummary(fs.readFileSync(file, "utf8").split("\n").filter(Boolean).slice(-last).map((line) => {
+			try {
+				const parsed = JSON.parse(line);
+				return (isRecord(parsed) ? parsed.call : void 0) ?? parsed;
+			} catch {
+				return null;
+			}
+		}).filter((call) => call !== null));
+		else {
+			params.ensureHistoryStateRuntime();
+			writeVoiceCallLatencySummary(await getCallHistoryFromStore(path.dirname(file), last));
+		}
+	});
+}
+//#endregion
+//#region extensions/voice-call/src/cli-gateway-call.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;
 function isGatewayUnavailableForLocalFallback(err) {
+	return isGatewayTransportError(err) && err.kind === "closed" && (err.code === void 0 || err.code === 1006);
+}
+function isGatewayCredentialFailure(err) {
+	return err instanceof Error && (err.name === "GatewayCredentialsRequiredError" || err.name === "GatewayExplicitAuthRequiredError" || err.name === "GatewaySecretRefUnavailableError");
+}
+function gatewayOperationalError(err) {
 	const message = formatErrorMessage(err);
-	return message.includes("ECONNREFUSED") || message.includes("ECONNRESET") || message.includes("EHOSTUNREACH") || message.includes("ENOTFOUND") || message.includes("gateway closed (1006") || message.includes("gateway not connected");
+	const detail = (() => {
+		if (isGatewayClientRequestError(err)) return `Gateway responded but voicecall failed: ${message}\nThe running Gateway owns the voice-call runtime; check \`openclaw gateway status\` or restart it.`;
+		if (isGatewayCredentialFailure(err)) return `Gateway requires credentials: ${message}\nConfigure gateway.auth or pair this device with \`openclaw devices approve --latest\`.`;
+		if (isGatewayTransportError(err)) {
+			const url = err.connectionDetails.url;
+			if (err.kind === "timeout") return `Gateway at ${url} did not answer within ${err.timeoutMs === void 0 ? "the configured timeout" : `${err.timeoutMs}ms`}: ${message}\nIt may be starting or wedged; check \`openclaw gateway status\`.`;
+			return `Gateway connection at ${url} failed: ${message}\nCheck gateway.auth and \`openclaw gateway status\`, then retry.`;
+		}
+		return `Gateway voicecall request failed: ${message}\nCheck \`openclaw gateway status\`, then retry.`;
+	})();
+	return new Error(redactSensitiveUrlLikeString(detail));
+}
+function isUnknownMethod(err, method) {
+	return formatErrorMessage(err).includes(`unknown method: ${method}`);
 }
 async function callVoiceCallGateway(method, params, opts) {
 	try {
@@ -52,21 +194,18 @@ async function callVoiceCallGateway(method, params, opts) {
 			ok: false,
 			error: err
 		};
-		throw err;
+		throw gatewayOperationalError(err);
 	}
 }
-function resolveGatewayOperationTimeoutMs(config) {
+function resolveOperationTimeout(config) {
 	return Math.max(VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS, addTimerTimeoutGraceMs(config.ringTimeoutMs) ?? 1);
 }
-function resolveGatewayContinueTimeoutMs(config) {
+function resolveContinueTimeout(config) {
 	return clampTimerTimeoutMs(config.transcriptTimeoutMs + VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS + VOICE_CALL_GATEWAY_TRANSCRIPT_BUFFER_MS) ?? 1;
 }
 function resolveVoiceCallDeadlineMs(timeoutMs, nowMs = Date.now()) {
 	return nowMs + (clampTimerTimeoutMs(timeoutMs) ?? MAX_TIMER_TIMEOUT_MS);
 }
-function isUnknownGatewayMethod(err, method) {
-	return formatErrorMessage(err).includes(`unknown method: ${method}`);
-}
 function readGatewayOperationId(payload) {
 	if (isRecord(payload) && typeof payload.operationId === "string" && payload.operationId) return payload.operationId;
 	throw new Error("voicecall gateway response missing operationId");
@@ -88,7 +227,12 @@ function readCompletedContinueResult(payload) {
 	};
 	throw new Error("voicecall gateway response has unknown operation status");
 }
-async function pollVoiceCallContinueGateway(params) {
+async function pollContinueGateway(payload, fallbackTimeoutMs) {
+	if (!isRecord(payload) || typeof payload.operationId !== "string") return payload;
+	const params = {
+		operationId: readGatewayOperationId(payload),
+		timeoutMs: readGatewayPollTimeoutMs(payload, fallbackTimeoutMs)
+	};
 	const deadlineMs = resolveVoiceCallDeadlineMs(params.timeoutMs);
 	for (;;) {
 		const remainingMs = deadlineMs - Date.now();
@@ -104,6 +248,54 @@ async function pollVoiceCallContinueGateway(params) {
 	}
 	throw new Error("voicecall continue timed out waiting for gateway operation");
 }
+async function ensureStandaloneRuntime(params) {
+	try {
+		return await params.ensureRuntime();
+	} catch (err) {
+		if (err instanceof Error && "code" in err && err.code === "EADDRINUSE") throw new Error(`Voice-call webhook port ${params.config.serve.port} is already in use. A running Gateway probably already serves it; operational commands route through that Gateway. Check \`openclaw gateway status\` and retry.`, { cause: err });
+		throw err;
+	}
+}
+async function runGatewayManagerCommand(params) {
+	const gateway = await params.gatewayCall();
+	if (gateway.ok) {
+		writeCliJson(params.resolveGatewayPayload ? await params.resolveGatewayPayload(gateway.payload) : gateway.payload);
+		return;
+	}
+	const runtime = await ensureStandaloneRuntime(params);
+	const result = await params.managerFallback(runtime.manager);
+	if (!result.success) throw new Error(result.error || `${params.failureLabel} failed`);
+	writeCliJson(result);
+}
+function readGatewayCallId(payload, invalidCallIdMessage) {
+	if (isRecord(payload) && typeof payload.callId === "string") {
+		if (!invalidCallIdMessage || payload.callId) return payload.callId;
+	}
+	if (invalidCallIdMessage) throw new Error(invalidCallIdMessage);
+	if (isRecord(payload) && typeof payload.error === "string") throw new Error(payload.error);
+	throw new Error("voicecall gateway response missing callId");
+}
+async function initiateVoiceCall(params) {
+	const mode = params.mode === "notify" || params.mode === "conversation" ? params.mode : params.defaultMode;
+	const gateway = await callVoiceCallGateway(params.method, {
+		...params.to ? { to: params.to } : {},
+		...params.message ? { message: params.message } : {},
+		...mode ? { mode } : {}
+	}, { timeoutMs: resolveOperationTimeout(params.config) });
+	if (gateway.ok) return readGatewayCallId(gateway.payload, params.failureMessage);
+	const runtime = await ensureStandaloneRuntime(params);
+	const to = params.to ?? runtime.config.toNumber;
+	if (!to) throw new Error("Missing --to and no toNumber configured");
+	const result = await runtime.manager.initiateCall(to, void 0, {
+		message: params.message,
+		mode
+	});
+	if (!result.success) throw new Error(result.error || params.failureMessage || "initiate failed");
+	if (params.failureMessage && !result.callId) throw new Error(params.failureMessage);
+	return result.callId;
+}
+//#endregion
+//#region extensions/voice-call/src/cli.ts
 function resolveMode(input) {
 	const raw = normalizeOptionalLowercaseString(input) ?? "";
 	if (raw === "serve" || raw === "off") return raw;
@@ -113,35 +305,6 @@ function resolveDefaultStorePath(config) {
 	const base = config.store?.trim() ? resolveUserPath(config.store) : resolveDefaultVoiceCallStoreDir();
 	return path.join(base, "calls.jsonl");
 }
-function percentile(values, p) {
-	if (values.length === 0) return 0;
-	const sorted = [...values].toSorted((a, b) => a - b);
-	return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1))] ?? 0;
-}
-function summarizeSeries(values) {
-	if (values.length === 0) return {
-		count: 0,
-		minMs: 0,
-		maxMs: 0,
-		avgMs: 0,
-		p50Ms: 0,
-		p95Ms: 0
-	};
-	const minMs = values.reduce((min, value) => value < min ? value : min, Number.POSITIVE_INFINITY);
-	const maxMs = values.reduce((max, value) => value > max ? value : max, Number.NEGATIVE_INFINITY);
-	const avgMs = values.reduce((sum, value) => sum + value, 0) / values.length;
-	return {
-		count: values.length,
-		minMs,
-		maxMs,
-		avgMs,
-		p50Ms: percentile(values, 50),
-		p95Ms: percentile(values, 95)
-	};
-}
-function resolveCallMode(mode) {
-	return mode === "notify" || mode === "conversation" ? mode : void 0;
-}
 function buildSetupStatus(config) {
 	const validation = validateProviderConfig(config);
 	const webhookExposure = resolveWebhookExposureStatus(config);
@@ -178,45 +341,8 @@ function buildSetupStatus(config) {
 	};
 }
 function writeSetupStatus(status) {
-	writeStdoutLine("Voice Call setup: %s", status.ok ? "OK" : "needs attention");
-	for (const check of status.checks) writeStdoutLine("%s %s: %s", check.ok ? "OK" : "FAIL", check.id, check.message);
-}
-async function initiateCallAndPrintId(params) {
-	const result = await params.runtime.manager.initiateCall(params.to, void 0, {
-		message: params.message,
-		mode: resolveCallMode(params.mode)
-	});
-	if (!result.success) throw new Error(result.error || "initiate failed");
-	writeStdoutJson({ callId: result.callId });
-}
-function writeGatewayCallId(payload) {
-	if (isRecord(payload) && typeof payload.callId === "string") {
-		writeStdoutJson({ callId: payload.callId });
-		return;
-	}
-	if (isRecord(payload) && typeof payload.error === "string") throw new Error(payload.error);
-	throw new Error("voicecall gateway response missing callId");
-}
-async function initiateCallViaGatewayOrRuntime(params) {
-	const mode = resolveCallMode(params.mode);
-	const gateway = await callVoiceCallGateway(params.method, {
-		...params.to ? { to: params.to } : {},
-		...params.message ? { message: params.message } : {},
-		...mode ? { mode } : {}
-	}, { timeoutMs: resolveGatewayOperationTimeoutMs(params.config) });
-	if (gateway.ok) {
-		writeGatewayCallId(gateway.payload);
-		return;
-	}
-	const rt = await params.ensureRuntime();
-	const to = params.to ?? rt.config.toNumber;
-	if (!to) throw new Error("Missing --to and no toNumber configured");
-	await initiateCallAndPrintId({
-		runtime: rt,
-		to,
-		message: params.message,
-		mode: params.mode
-	});
+	writeCliLine("Voice Call setup: %s", status.ok ? "OK" : "needs attention");
+	for (const check of status.checks) writeCliLine("%s %s: %s", check.ok ? "OK" : "FAIL", check.id, check.message);
 }
 function registerVoiceCallCli(params) {
 	const { program, config, ensureRuntime, stateRuntime } = params;
@@ -227,7 +353,7 @@ function registerVoiceCallCli(params) {
 	root.command("setup").description("Show Voice Call provider and webhook setup status").option("--json", "Print machine-readable JSON").action((options) => {
 		const status = buildSetupStatus(config);
 		if (options.json) {
-			writeStdoutJson(status);
+			writeCliJson(status);
 			return;
 		}
 		writeSetupStatus(status);
@@ -235,7 +361,7 @@ function registerVoiceCallCli(params) {
 	root.command("smoke").description("Check Voice Call readiness and optionally place a short outbound test call").option("-t, --to <phone>", "Phone number to call for a live smoke").option("--message <text>", "Message to speak during the smoke call", "OpenClaw voice call smoke test.").option("--mode <mode>", "Call mode: notify or conversation", "notify").option("--yes", "Actually place the live outbound call").option("--json", "Print machine-readable JSON").action(async (options) => {
 		const setup = buildSetupStatus(config);
 		if (!setup.ok) {
-			if (options.json) writeStdoutJson({
+			if (options.json) writeCliJson({
 				ok: false,
 				setup
 			});
@@ -244,19 +370,19 @@ function registerVoiceCallCli(params) {
 			return;
 		}
 		if (!options.to) {
-			if (options.json) writeStdoutJson({
+			if (options.json) writeCliJson({
 				ok: true,
 				setup,
 				liveCall: false
 			});
 			else {
 				writeSetupStatus(setup);
-				writeStdoutLine("live-call: skipped (pass --to and --yes to place one)");
+				writeCliLine("live-call: skipped (pass --to and --yes to place one)");
 			}
 			return;
 		}
 		if (!options.yes) {
-			if (options.json) writeStdoutJson({
+			if (options.json) writeCliJson({
 				ok: true,
 				setup,
 				liveCall: false,
@@ -264,29 +390,22 @@ function registerVoiceCallCli(params) {
 			});
 			else {
 				writeSetupStatus(setup);
-				writeStdoutLine("live-call: dry run for %s (add --yes to place it)", options.to);
+				writeCliLine("live-call: dry run for %s (add --yes to place it)", options.to);
 			}
 			return;
 		}
-		const mode = resolveCallMode(options.mode) ?? "notify";
-		const gateway = await callVoiceCallGateway("voicecall.start", {
+		const callId = await initiateVoiceCall({
+			ensureRuntime,
+			config,
+			method: "voicecall.start",
 			to: options.to,
-			...options.message ? { message: options.message } : {},
-			mode
-		}, { timeoutMs: resolveGatewayOperationTimeoutMs(config) });
-		let callId;
-		if (gateway.ok) callId = isRecord(gateway.payload) ? gateway.payload.callId : void 0;
-		else {
-			const result = await (await ensureRuntime()).manager.initiateCall(options.to, void 0, {
-				message: options.message,
-				mode
-			});
-			if (!result.success) throw new Error(result.error || "smoke call failed");
-			callId = result.callId;
-		}
-		if (typeof callId !== "string" || !callId) throw new Error("smoke call failed");
+			message: options.message,
+			mode: options.mode,
+			defaultMode: "notify",
+			failureMessage: "smoke call failed"
+		});
 		if (options.json) {
-			writeStdoutJson({
+			writeCliJson({
 				ok: true,
 				setup,
 				liveCall: true,
@@ -295,245 +414,162 @@ function registerVoiceCallCli(params) {
 			return;
 		}
 		writeSetupStatus(setup);
-		writeStdoutLine("live-call: started %s", callId);
+		writeCliLine("live-call: started %s", callId);
 	});
 	root.command("call").description("Initiate an outbound voice call").requiredOption("-m, --message <text>", "Message to speak when call connects").option("-t, --to <phone>", "Phone number to call (E.164 format, uses config toNumber if not set)").option("--mode <mode>", "Call mode: notify (hangup after message) or conversation (stay open)", "conversation").action(async (options) => {
-		await initiateCallViaGatewayOrRuntime({
+		writeCliJson({ callId: await initiateVoiceCall({
 			ensureRuntime,
 			config,
 			method: "voicecall.initiate",
 			to: options.to,
 			message: options.message,
 			mode: options.mode
-		});
+		}) });
 	});
 	root.command("start").description("Alias for voicecall call").requiredOption("--to <phone>", "Phone number to call").option("--message <text>", "Message to speak when call connects").option("--mode <mode>", "Call mode: notify (hangup after message) or conversation (stay open)", "conversation").action(async (options) => {
-		await initiateCallViaGatewayOrRuntime({
+		writeCliJson({ callId: await initiateVoiceCall({
 			ensureRuntime,
 			config,
 			method: "voicecall.start",
 			to: options.to,
 			message: options.message,
 			mode: options.mode
-		});
+		}) });
 	});
 	root.command("continue").description("Speak a message and wait for a response").requiredOption("--call-id <id>", "Call ID").requiredOption("--message <text>", "Message to speak").action(async (options) => {
-		let gateway;
-		try {
-			gateway = await callVoiceCallGateway("voicecall.continue.start", {
-				callId: options.callId,
-				message: options.message
-			}, { timeoutMs: resolveGatewayOperationTimeoutMs(config) });
-		} catch (err) {
-			if (!isUnknownGatewayMethod(err, "voicecall.continue.start")) throw err;
-			gateway = await callVoiceCallGateway("voicecall.continue", {
-				callId: options.callId,
-				message: options.message
-			}, { timeoutMs: resolveGatewayContinueTimeoutMs(config) });
-		}
-		if (gateway.ok) {
-			if (isRecord(gateway.payload) && typeof gateway.payload.operationId === "string") {
-				writeStdoutJson(await pollVoiceCallContinueGateway({
-					operationId: readGatewayOperationId(gateway.payload),
-					timeoutMs: readGatewayPollTimeoutMs(gateway.payload, resolveGatewayContinueTimeoutMs(config))
-				}));
-				return;
-			}
-			writeStdoutJson(gateway.payload);
-			return;
-		}
-		const result = await (await ensureRuntime()).manager.continueCall(options.callId, options.message);
-		if (!result.success) throw new Error(result.error || "continue failed");
-		writeStdoutJson(result);
-	});
-	root.command("speak").description("Speak a message without waiting for response").requiredOption("--call-id <id>", "Call ID").requiredOption("--message <text>", "Message to speak").action(async (options) => {
-		const gateway = await callVoiceCallGateway("voicecall.speak", {
+		const gatewayParams = {
 			callId: options.callId,
 			message: options.message
+		};
+		const continueTimeoutMs = resolveContinueTimeout(config);
+		await runGatewayManagerCommand({
+			config,
+			ensureRuntime,
+			gatewayCall: async () => {
+				try {
+					return await callVoiceCallGateway("voicecall.continue.start", gatewayParams, { timeoutMs: resolveOperationTimeout(config) });
+				} catch (err) {
+					if (!isUnknownMethod(err, "voicecall.continue.start")) throw err;
+					return callVoiceCallGateway("voicecall.continue", gatewayParams, { timeoutMs: continueTimeoutMs });
+				}
+			},
+			resolveGatewayPayload: (payload) => pollContinueGateway(payload, continueTimeoutMs),
+			managerFallback: (manager) => manager.continueCall(options.callId, options.message),
+			failureLabel: "continue"
+		});
+	});
+	root.command("speak").description("Speak a message without waiting for response").requiredOption("--call-id <id>", "Call ID").requiredOption("--message <text>", "Message to speak").action(async (options) => {
+		await runGatewayManagerCommand({
+			config,
+			ensureRuntime,
+			gatewayCall: () => callVoiceCallGateway("voicecall.speak", {
+				callId: options.callId,
+				message: options.message
+			}),
+			managerFallback: (manager) => manager.speak(options.callId, options.message),
+			failureLabel: "speak"
 		});
-		if (gateway.ok) {
-			writeStdoutJson(gateway.payload);
-			return;
-		}
-		const result = await (await ensureRuntime()).manager.speak(options.callId, options.message);
-		if (!result.success) throw new Error(result.error || "speak failed");
-		writeStdoutJson(result);
 	});
 	root.command("dtmf").description("Send DTMF digits to an active call").requiredOption("--call-id <id>", "Call ID").requiredOption("--digits <digits>", "DTMF digits").action(async (options) => {
-		const gateway = await callVoiceCallGateway("voicecall.dtmf", {
-			callId: options.callId,
-			digits: options.digits
+		await runGatewayManagerCommand({
+			config,
+			ensureRuntime,
+			gatewayCall: () => callVoiceCallGateway("voicecall.dtmf", {
+				callId: options.callId,
+				digits: options.digits
+			}),
+			managerFallback: (manager) => manager.sendDtmf(options.callId, options.digits),
+			failureLabel: "dtmf"
 		});
-		if (gateway.ok) {
-			writeStdoutJson(gateway.payload);
-			return;
-		}
-		const result = await (await ensureRuntime()).manager.sendDtmf(options.callId, options.digits);
-		if (!result.success) throw new Error(result.error || "dtmf failed");
-		writeStdoutJson(result);
 	});
 	root.command("end").description("Hang up an active call").requiredOption("--call-id <id>", "Call ID").action(async (options) => {
-		const gateway = await callVoiceCallGateway("voicecall.end", { callId: options.callId });
-		if (gateway.ok) {
-			writeStdoutJson(gateway.payload);
-			return;
-		}
-		const result = await (await ensureRuntime()).manager.endCall(options.callId);
-		if (!result.success) throw new Error(result.error || "end failed");
-		writeStdoutJson(result);
+		await runGatewayManagerCommand({
+			config,
+			ensureRuntime,
+			gatewayCall: () => callVoiceCallGateway("voicecall.end", { callId: options.callId }),
+			managerFallback: (manager) => manager.endCall(options.callId),
+			failureLabel: "end"
+		});
 	});
 	root.command("status").description("Show call status").option("--call-id <id>", "Call ID").option("--json", "Print machine-readable JSON").action(async (options) => {
 		const gateway = await callVoiceCallGateway("voicecall.status", options.callId ? { callId: options.callId } : void 0);
 		if (gateway.ok) {
 			if (options.callId && isRecord(gateway.payload)) {
 				if (gateway.payload.found === true && "call" in gateway.payload) {
-					writeStdoutJson(gateway.payload.call);
+					writeCliJson(gateway.payload.call);
 					return;
 				}
 				if (gateway.payload.found === false) {
-					writeStdoutJson({ found: false });
+					writeCliJson({ found: false });
 					return;
 				}
 			}
-			writeStdoutJson(gateway.payload);
+			writeCliJson(gateway.payload);
 			return;
 		}
-		const rt = await ensureRuntime();
+		ensureHistoryStateRuntime();
+		const storePath = path.dirname(resolveDefaultStorePath(config));
 		if (options.callId) {
-			writeStdoutJson(await rt.manager.getCallFromMemoryOrStore(options.callId) ?? { found: false });
+			const persisted = await findCallMatchesInStore(storePath, options.callId);
+			writeCliJson(persisted.byCallId ?? persisted.byProviderCallId ?? { found: false });
 			return;
 		}
-		writeStdoutJson({
+		writeCliJson({
 			found: true,
-			calls: rt.manager.getActiveCalls()
+			calls: Array.from(loadActiveCallsFromStore(storePath).activeCalls.values())
 		});
 	});
-	root.command("tail").description("Tail voice-call JSONL logs (prints new lines; useful during provider tests)").option("--file <path>", "Path to calls.jsonl", resolveDefaultStorePath(config)).option("--since <n>", "Print last N lines first", "25").option("--poll <ms>", "Poll interval in ms", "250").action(async (options) => {
-		const file = options.file;
-		const since = parseVoiceCallIntOption(options.since, "--since", { min: 0 });
-		const pollMs = parseVoiceCallIntOption(options.poll, "--poll", { min: 50 });
-		const tailSqliteHistory = async (initialLimit) => {
-			ensureHistoryStateRuntime();
-			const seen = /* @__PURE__ */ new Set();
-			const printCall = (call) => {
-				const line = JSON.stringify(call);
-				if (!seen.has(line)) {
-					seen.add(line);
-					writeStdoutLine(line);
-				}
-			};
-			if (initialLimit > 0) for (const call of await getCallHistoryFromStore(path.dirname(file), initialLimit)) printCall(call);
-			for (;;) {
-				try {
-					for (const call of await getCallHistoryFromStore(path.dirname(file), 1e3)) printCall(call);
-				} catch {}
-				await sleep(pollMs);
-			}
-		};
-		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") {
-			const initial = fs.readFileSync(file);
-			let decoder = new StringDecoder("utf8");
-			const initialLines = decoder.write(initial).split("\n");
-			let pendingLine = initialLines.pop() ?? "";
-			const lines = initialLines.filter(Boolean);
-			for (const line of lines.slice(Math.max(0, lines.length - since))) writeStdoutLine(line);
-			let offset = initial.length;
-			let lastObservedSize = initial.length;
-			for (;;) {
-				try {
-					const stat = fs.statSync(file);
-					if (stat.size < lastObservedSize) {
-						offset = 0;
-						decoder = new StringDecoder("utf8");
-						pendingLine = "";
-					}
-					lastObservedSize = stat.size;
-					if (stat.size > offset) {
-						const fd = fs.openSync(file, "r");
-						try {
-							const buf = Buffer.alloc(stat.size - offset);
-							const bytesRead = fs.readSync(fd, buf, 0, buf.length, offset);
-							offset += bytesRead;
-							const text = decoder.write(buf.subarray(0, bytesRead));
-							const completeLines = `${pendingLine}${text}`.split("\n");
-							pendingLine = completeLines.pop() ?? "";
-							for (const line of completeLines.filter(Boolean)) writeStdoutLine(line);
-						} finally {
-							fs.closeSync(fd);
-						}
-					}
-				} catch {}
-				await sleep(pollMs);
-			}
-		} else await tailSqliteHistory(since);
-	});
-	root.command("latency").description("Summarize turn latency metrics from voice-call JSONL logs").option("--file <path>", "Path to calls.jsonl", resolveDefaultStorePath(config)).option("--last <n>", "Analyze last N records", "200").action(async (options) => {
-		const file = options.file;
-		const last = parseVoiceCallIntOption(options.last, "--last", { min: 1 });
-		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") writeVoiceCallLatencySummary(fs.readFileSync(file, "utf8").split("\n").filter(Boolean).slice(-last).map((line) => {
-			try {
-				const parsed = JSON.parse(line);
-				return parsed.call ?? parsed;
-			} catch {
-				return null;
-			}
-		}).filter((call) => call !== null));
-		else {
-			ensureHistoryStateRuntime();
-			writeVoiceCallLatencySummary(await getCallHistoryFromStore(path.dirname(file), last));
-		}
+	registerVoiceCallLogs({
+		root,
+		defaultFile: resolveDefaultStorePath(config),
+		ensureHistoryStateRuntime
 	});
-	function writeVoiceCallLatencySummary(calls) {
-		const turnLatencyMs = [];
-		const listenWaitMs = [];
-		for (const call of calls) {
-			const latency = call.metadata?.lastTurnLatencyMs;
-			const listenWait = call.metadata?.lastTurnListenWaitMs;
-			if (typeof latency === "number" && Number.isFinite(latency)) turnLatencyMs.push(latency);
-			if (typeof listenWait === "number" && Number.isFinite(listenWait)) listenWaitMs.push(listenWait);
-		}
-		writeStdoutJson({
-			recordsScanned: calls.length,
-			turnLatency: summarizeSeries(turnLatencyMs),
-			listenWait: summarizeSeries(listenWaitMs)
-		});
-	}
 	root.command("expose").description("Enable/disable Tailscale serve/funnel for the webhook").option("--mode <mode>", "off | serve (tailnet) | funnel (public)", "funnel").option("--path <path>", "Tailscale path to expose (recommend matching serve.path)").option("--port <port>", "Local webhook port").option("--serve-path <path>", "Local webhook path").action(async (options) => {
 		const mode = resolveMode(options.mode ?? "funnel");
-		const servePort = parseVoiceCallIntOption(options.port ?? String(config.serve.port ?? 3334), "--port", {
+		const servePort = parseCliInteger(options.port ?? String(config.serve.port ?? 3334), "--port", {
 			min: 1,
 			max: MAX_TCP_PORT
 		});
 		const servePath = options.servePath ?? config.serve.path ?? "/voice/webhook";
 		const tsPath = options.path ?? config.tailscale?.path ?? servePath;
-		const localUrl = `http://127.0.0.1:${servePort}`;
+		const streamExposurePaths = resolveVoiceCallStreamExposurePaths(config, {
+			publicWebhookPath: tsPath,
+			localWebhookPath: servePath
+		});
+		const streamPaths = streamExposurePaths.map(({ publicPath }) => publicPath);
+		const localUrl = `http://127.0.0.1:${servePort}${servePath}`;
 		if (mode === "off") {
-			await cleanupTailscaleExposureRoute({
-				mode: "serve",
-				path: tsPath
-			});
-			await cleanupTailscaleExposureRoute({
-				mode: "funnel",
-				path: tsPath
+			for (const exposurePath of [tsPath, ...streamPaths]) for (const tailscaleMode of ["serve", "funnel"]) await cleanupTailscaleExposureRoute({
+				mode: tailscaleMode,
+				port: config.tailscale.port,
+				path: exposurePath
 			});
-			writeStdoutJson({
+			writeCliJson({
 				ok: true,
 				mode: "off",
-				path: tsPath
+				path: tsPath,
+				streamPaths
 			});
 			return;
 		}
-		const publicUrl = await setupTailscaleExposureRoute({
+		const publicUrl = await setupTailscaleExposureRoutes({
 			mode,
-			path: tsPath,
-			localUrl
+			port: config.tailscale.port,
+			routes: [{
+				path: tsPath,
+				localUrl
+			}, ...streamExposurePaths.map(({ publicPath, localPath }) => ({
+				path: publicPath,
+				localUrl: `http://127.0.0.1:${servePort}${localPath}`
+			}))]
 		});
 		const tsInfo = publicUrl ? null : await getTailscaleSelfInfo();
 		const enableUrl = tsInfo?.nodeId ? `https://login.tailscale.com/f/${mode}?node=${tsInfo.nodeId}` : null;
-		writeStdoutJson({
+		writeCliJson({
 			ok: Boolean(publicUrl),
 			mode,
 			path: tsPath,
+			streamPaths,
 			localUrl,
 			publicUrl,
 			hint: publicUrl ? void 0 : {
@@ -826,20 +862,32 @@ function isCliOnlyProcess() {
 const VOICE_CALL_RUNTIME_COORDINATOR_KEY = Symbol.for("openclaw.voice-call.runtimeCoordinator");
 var VoiceCallRuntimeLifecycleError = class extends Error {};
 function getVoiceCallRuntimeCoordinator() {
-	return resolveGlobalSingleton(VOICE_CALL_RUNTIME_COORDINATOR_KEY, () => ({
-		epochCounter: 0,
-		registeredEpoch: 0
-	}));
+	return resolveGlobalSingleton(VOICE_CALL_RUNTIME_COORDINATOR_KEY, () => ({ epochCounter: 0 }));
 }
-function activateVoiceCallRuntimeGeneration(coordinator, generation) {
-	if (generation.epoch < coordinator.registeredEpoch) throw new VoiceCallRuntimeLifecycleError("Voice call runtime generation was superseded; use the current plugin registration");
+function activateVoiceCallRuntimeGeneration(coordinator, registration, generation) {
+	if (registration.epoch < (coordinator.current?.epoch ?? 0) || registration.generation !== generation) throw new VoiceCallRuntimeLifecycleError("Voice call runtime generation was superseded; use the current plugin registration");
 	if (generation.retired) throw new VoiceCallRuntimeLifecycleError("Voice call runtime generation is retired; use the current plugin registration");
-	if (coordinator.current !== generation) {
-		if (coordinator.current) coordinator.current.retired = true;
-		coordinator.current = generation;
-		coordinator.registeredEpoch = generation.epoch;
+	if (coordinator.current !== registration) {
+		if (coordinator.current) coordinator.current.generation.retired = true;
+		coordinator.current = registration;
 	}
 }
+function stopVoiceCallRuntimeGeneration(coordinator, generation) {
+	const ownedSlot = coordinator.slot?.owner === generation ? coordinator.slot : void 0;
+	if (!ownedSlot || ownedSlot.state === "stopping") return ownedSlot?.promise ?? Promise.resolve();
+	const stopPromise = Promise.resolve().then(async () => {
+		await (ownedSlot.state === "running" ? ownedSlot.runtime : await ownedSlot.promise).stop();
+	});
+	const stoppingSlot = {
+		state: "stopping",
+		owner: generation,
+		promise: stopPromise
+	};
+	if (coordinator.slot === ownedSlot) coordinator.slot = stoppingSlot;
+	return stopPromise.finally(() => {
+		if (coordinator.slot === stoppingSlot) coordinator.slot = void 0;
+	});
+}
 var voice_call_default = definePluginEntry({
 	id: "voice-call",
 	name: "Voice Call",
@@ -849,25 +897,26 @@ var voice_call_default = definePluginEntry({
 		const config = resolveVoiceCallConfig(voiceCallConfigSchema.parse(api.pluginConfig));
 		const validation = validateProviderConfig(config);
 		const runtimeCoordinator = getVoiceCallRuntimeCoordinator();
-		const runtimeGeneration = api.registrationMode !== "full" && runtimeCoordinator.current ? runtimeCoordinator.current : {
+		const runtimeRegistration = api.registrationMode !== "full" && runtimeCoordinator.current ? runtimeCoordinator.current : {
 			epoch: ++runtimeCoordinator.epochCounter,
-			retired: false
+			generation: { retired: false }
 		};
 		const continueOperationStore = createVoiceCallContinueOperationStore({
 			config,
 			coreConfig: api.config
 		});
-		const ensureRuntime = async () => {
-			activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
+		const activateRuntimeGeneration = (generation) => activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeRegistration, generation);
+		const ensureRuntimeForGeneration = async (runtimeGeneration) => {
+			activateRuntimeGeneration(runtimeGeneration);
 			if (!config.enabled) throw new Error("Voice call disabled in plugin config");
 			if (!validation.valid) throw new Error(validation.errors.join("; "));
 			while (true) {
-				activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
+				activateRuntimeGeneration(runtimeGeneration);
 				const slot = runtimeCoordinator.slot;
 				if (slot) {
 					if (slot.owner !== runtimeGeneration) {
-						if (slot.state === "stopping") {
-							await slot.promise;
+						if (slot.owner.retired) {
+							await stopVoiceCallRuntimeGeneration(runtimeCoordinator, slot.owner);
 							continue;
 						}
 						throw new VoiceCallRuntimeLifecycleError("A previous voice call runtime generation is still active; retry after it stops");
@@ -884,7 +933,7 @@ var voice_call_default = definePluginEntry({
 						if (runtimeCoordinator.slot === slot) runtimeCoordinator.slot = void 0;
 						throw err;
 					}
-					activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
+					activateRuntimeGeneration(runtimeGeneration);
 					if (runtimeCoordinator.slot !== slot) continue;
 					runtimeCoordinator.slot = {
 						state: "running",
@@ -893,20 +942,30 @@ var voice_call_default = definePluginEntry({
 					};
 					return createdRuntime;
 				}
-				const runtimePromise = createVoiceCallRuntime({
-					config,
-					coreConfig: api.config,
-					fullConfig: api.config,
-					agentRuntime: api.runtime.agent,
-					stateRuntime: api.runtime.state,
-					ttsRuntime: api.runtime.tts,
-					logger: api.logger
-				});
-				runtimeCoordinator.slot = {
+				const startingSlot = {
 					state: "starting",
 					owner: runtimeGeneration,
-					promise: runtimePromise
+					promise: createVoiceCallRuntime({
+						config,
+						coreConfig: api.config,
+						fullConfig: api.config,
+						agentRuntime: api.runtime.agent,
+						stateRuntime: api.runtime.state,
+						ttsRuntime: api.runtime.tts,
+						logger: api.logger
+					})
 				};
+				runtimeCoordinator.slot = startingSlot;
+			}
+		};
+		const ensureRuntime = async (runtimeGeneration = runtimeRegistration.generation) => {
+			try {
+				const runtime = await ensureRuntimeForGeneration(runtimeGeneration);
+				runtimeGeneration.serviceHealth?.clearFailure();
+				return runtime;
+			} catch (err) {
+				if (!(err instanceof VoiceCallRuntimeLifecycleError)) runtimeGeneration.serviceHealth?.reportFailure(err);
+				throw err;
 			}
 		};
 		const commands = createVoiceCallCommandService(ensureRuntime);
@@ -1034,48 +1093,41 @@ var voice_call_default = definePluginEntry({
 		});
 		api.registerService({
 			id: "voicecall",
-			start: () => {
+			start: (ctx) => {
 				if (isCliOnlyProcess()) return;
 				try {
-					activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
+					if (runtimeRegistration.generation.retired) {
+						if (runtimeCoordinator.current !== runtimeRegistration) throw new VoiceCallRuntimeLifecycleError("Voice call runtime generation was superseded; use the current plugin registration");
+						runtimeRegistration.generation = { retired: false };
+					}
+					runtimeRegistration.generation.serviceHealth = ctx.serviceHealth;
+					activateRuntimeGeneration(runtimeRegistration.generation);
 				} catch (err) {
-					if (err instanceof VoiceCallRuntimeLifecycleError) return;
-					throw err;
+					ctx.serviceHealth?.reportFailure(err);
+					api.logger.error(`[voice-call] Failed to start runtime: ${formatErrorMessage(err)}`);
+					return;
 				}
 				if (!config.enabled) return;
 				if (!validation.valid) {
-					api.logger.warn(`[voice-call] Runtime not started; setup incomplete: ${validation.errors.join("; ")}`);
+					const error = /* @__PURE__ */ new Error(`setup incomplete: ${validation.errors.join("; ")}`);
+					ctx.serviceHealth?.reportFailure(error);
+					api.logger.error(`[voice-call] Runtime not started: ${error.message}`);
 					return;
 				}
-				ensureRuntime().catch((err) => {
-					const staleGeneration = runtimeGeneration.retired || runtimeGeneration.epoch < runtimeCoordinator.registeredEpoch;
-					if (err instanceof VoiceCallRuntimeLifecycleError && staleGeneration) return;
+				const startingGeneration = runtimeRegistration.generation;
+				ensureRuntime(startingGeneration).catch((err) => {
+					if (err instanceof VoiceCallRuntimeLifecycleError) return;
+					ctx.serviceHealth?.reportFailure(err);
 					api.logger.error(`[voice-call] Failed to start runtime: ${formatErrorMessage(err)}`);
 				});
 			},
 			stop: async () => {
-				if (runtimeGeneration.stopPromise) return await runtimeGeneration.stopPromise;
+				const runtimeGeneration = runtimeRegistration.generation;
 				runtimeGeneration.retired = true;
-				const ownedSlot = runtimeCoordinator.slot?.owner === runtimeGeneration ? runtimeCoordinator.slot : void 0;
-				let stoppingSlot;
-				const stopPromise = ownedSlot?.state === "stopping" ? ownedSlot.promise : Promise.resolve().then(async () => {
-					if (!ownedSlot) return;
-					await (ownedSlot.state === "running" ? ownedSlot.runtime : await ownedSlot.promise).stop();
-				});
-				runtimeGeneration.stopPromise = stopPromise;
-				if (ownedSlot && ownedSlot.state !== "stopping") {
-					stoppingSlot = {
-						state: "stopping",
-						owner: runtimeGeneration,
-						promise: stopPromise
-					};
-					if (runtimeCoordinator.slot === ownedSlot) runtimeCoordinator.slot = stoppingSlot;
-				} else if (ownedSlot) stoppingSlot = ownedSlot;
 				try {
-					await stopPromise;
+					await stopVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
 				} finally {
-					if (stoppingSlot && runtimeCoordinator.slot === stoppingSlot) runtimeCoordinator.slot = void 0;
-					if (runtimeCoordinator.current === runtimeGeneration) runtimeCoordinator.current = void 0;
+					runtimeGeneration.serviceHealth = void 0;
 				}
 			}
 		});