@openclaw/voice-call 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/index.js

@@ -1,40 +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-D0UJiLfi.js";
-import { g as setVoiceCallStateRuntime, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-nYL-yM0S.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-DK8kPCGC.js";
+import { b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, l as findCallMatchesInStore, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-51_oC_xn.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 { asOptionalRecord, isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-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 { 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 {
@@ -51,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");
@@ -87,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();
@@ -103,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;
@@ -112,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);
@@ -177,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;
@@ -226,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);
@@ -234,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
 			});
@@ -243,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,
@@ -263,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,
@@ -294,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 });
-					return;
-				}
-			}
-			writeStdoutJson(gateway.payload);
-			return;
-		}
-		const rt = await ensureRuntime();
-		if (options.callId) {
-			writeStdoutJson(await rt.manager.getCallFromMemoryOrStore(options.callId) ?? { found: false });
-			return;
-		}
-		writeStdoutJson({
-			found: true,
-			calls: rt.manager.getActiveCalls()
-		});
-	});
-	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;
+					writeCliJson({ found: false });
+					return;
+				}
 			}
-		}).filter((call) => call !== null));
-		else {
-			ensureHistoryStateRuntime();
-			writeVoiceCallLatencySummary(await getCallHistoryFromStore(path.dirname(file), last));
+			writeCliJson(gateway.payload);
+			return;
 		}
-	});
-	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);
+		ensureHistoryStateRuntime();
+		const storePath = path.dirname(resolveDefaultStorePath(config));
+		if (options.callId) {
+			const persisted = await findCallMatchesInStore(storePath, options.callId);
+			writeCliJson(persisted.byCallId ?? persisted.byProviderCallId ?? { found: false });
+			return;
 		}
-		writeStdoutJson({
-			recordsScanned: calls.length,
-			turnLatency: summarizeSeries(turnLatencyMs),
-			listenWait: summarizeSeries(listenWaitMs)
+		writeCliJson({
+			found: true,
+			calls: Array.from(loadActiveCallsFromStore(storePath).activeCalls.values())
 		});
-	}
+	});
+	registerVoiceCallLogs({
+		root,
+		defaultFile: resolveDefaultStorePath(config),
+		ensureHistoryStateRuntime
+	});
 	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
+			for (const exposurePath of [tsPath, ...streamPaths]) for (const tailscaleMode of ["serve", "funnel"]) await cleanupTailscaleExposureRoute({
+				mode: tailscaleMode,
+				port: config.tailscale.port,
+				path: exposurePath
 			});
-			await cleanupTailscaleExposureRoute({
-				mode: "funnel",
-				path: tsPath
-			});
-			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 : {
@@ -543,6 +580,126 @@ function registerVoiceCallCli(params) {
 	});
 }
 //#endregion
+//#region extensions/voice-call/src/command-service.ts
+var VoiceCallCommandInputError = class extends Error {};
+function toVoiceCallStatus(call) {
+	return {
+		callId: call.callId,
+		...call.providerCallId !== void 0 ? { providerCallId: call.providerCallId } : {},
+		provider: call.provider,
+		direction: call.direction,
+		state: call.state,
+		startedAt: call.startedAt,
+		...call.answeredAt !== void 0 ? { answeredAt: call.answeredAt } : {},
+		...call.endedAt !== void 0 ? { endedAt: call.endedAt } : {},
+		...call.endReason !== void 0 ? { endReason: call.endReason } : {}
+	};
+}
+function requireInput(value, message) {
+	if (!value) throw new VoiceCallCommandInputError(message);
+	return value;
+}
+function requireSuccess(result, fallback) {
+	if (!result.success) throw new Error(result.error || fallback);
+}
+function createVoiceCallCommandService(ensureRuntime) {
+	const describeHistoricalCall = async (rt, callId) => {
+		const call = await rt.manager.getCallFromMemoryOrStore(callId);
+		if (!call) return;
+		const endedAt = timestampMsToIsoString(call.endedAt);
+		return `call is not active (${[
+			`last state=${call.state}`,
+			call.endReason ? `endReason=${call.endReason}` : void 0,
+			endedAt ? `endedAt=${endedAt}` : void 0
+		].filter(Boolean).join(", ")})`;
+	};
+	const resolveCallMessage = async (callId, message) => {
+		const resolvedCallId = requireInput(callId, "callId and message required");
+		const resolvedMessage = requireInput(message, "callId and message required");
+		const rt = await ensureRuntime();
+		const activeCall = rt.manager.getCall(resolvedCallId) ?? rt.manager.getCallByProviderCallId(resolvedCallId);
+		if (!activeCall) throw new VoiceCallCommandInputError(await describeHistoricalCall(rt, resolvedCallId) ?? "Call not found");
+		return {
+			rt,
+			callId: activeCall.callId,
+			message: resolvedMessage
+		};
+	};
+	const prepareContinue = async (callId, message) => {
+		const request = await resolveCallMessage(callId, message);
+		return {
+			rt: request.rt,
+			callId: request.callId,
+			run: async () => {
+				const result = await request.rt.manager.continueCall(request.callId, request.message);
+				requireSuccess(result, "continue failed");
+				return {
+					success: true,
+					transcript: result.transcript
+				};
+			}
+		};
+	};
+	return {
+		prepareContinue,
+		async initiate(params, missingToMessage = "to required") {
+			const rt = await ensureRuntime();
+			const to = requireInput(params.to ?? rt.config.toNumber, missingToMessage);
+			const result = await rt.manager.initiateCall(to, params.sessionKey, {
+				message: params.message,
+				mode: params.mode,
+				dtmfSequence: params.dtmfSequence,
+				...params.requesterSessionKey ? { requesterSessionKey: params.requesterSessionKey } : {},
+				...params.agentId ? { agentId: params.agentId } : {}
+			});
+			requireSuccess(result, "initiate failed");
+			return {
+				callId: result.callId,
+				initiated: true
+			};
+		},
+		async continueCall(callId, message) {
+			return await (await prepareContinue(callId, message)).run();
+		},
+		async speak(params) {
+			const request = await resolveCallMessage(params.callId, params.message);
+			if (request.rt.config.realtime.enabled) {
+				const realtimeResult = request.rt.webhookServer.speakRealtime(request.callId, request.message);
+				if (realtimeResult.success) return { success: true };
+				if (params.allowTwimlFallback === false) return {
+					success: false,
+					error: realtimeResult.error ?? "Realtime bridge is not active"
+				};
+			}
+			requireSuccess(await request.rt.manager.speak(request.callId, request.message), "speak failed");
+			return { success: true };
+		},
+		async sendDtmf(callId, digits) {
+			const resolvedCallId = requireInput(callId, "callId and digits required");
+			const resolvedDigits = requireInput(digits, "callId and digits required");
+			requireSuccess(await (await ensureRuntime()).manager.sendDtmf(resolvedCallId, resolvedDigits), "dtmf failed");
+			return { success: true };
+		},
+		async endCall(callId) {
+			const resolvedCallId = requireInput(callId, "callId required");
+			requireSuccess(await (await ensureRuntime()).manager.endCall(resolvedCallId), "end failed");
+			return { success: true };
+		},
+		async status(callId) {
+			const rt = await ensureRuntime();
+			if (!callId) return {
+				found: true,
+				calls: rt.manager.getActiveCalls().map(toVoiceCallStatus)
+			};
+			const call = await rt.manager.getCallFromMemoryOrStore(callId);
+			return call ? {
+				found: true,
+				call: toVoiceCallStatus(call)
+			} : { found: false };
+		}
+	};
+}
+//#endregion
 //#region extensions/voice-call/src/gateway-continue-operation.ts
 const VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS = 3e4;
 const VOICE_CALL_CONTINUE_OPERATION_CLEANUP_MS = 300 * 1e3;
@@ -569,21 +726,9 @@ function createVoiceCallContinueOperationStore(params) {
 			startedAtMs,
 			pollTimeoutMs
 		});
-		request.rt.manager.continueCall(request.callId, request.message).then((result) => {
+		request.run().then((result) => {
 			const current = operations.get(operationId);
 			if (!current || current.status !== "pending") return;
-			if (!result.success) {
-				operations.set(operationId, {
-					operationId,
-					status: "failed",
-					callId: request.callId,
-					startedAtMs,
-					completedAtMs: Date.now(),
-					pollTimeoutMs,
-					error: result.error || "continue failed"
-				});
-				return;
-			}
 			operations.set(operationId, {
 				operationId,
 				status: "completed",
@@ -661,223 +806,15 @@ function createVoiceCallContinueOperationStore(params) {
 //#region extensions/voice-call/index.ts
 const VOICE_CALL_WRITE_METHOD_SCOPE = { scope: "operator.write" };
 const VOICE_CALL_READ_METHOD_SCOPE = { scope: "operator.read" };
-const voiceCallConfigSchema = {
-	parse(value) {
-		const config = asOptionalRecord(value) ?? {};
-		const enabled = typeof config.enabled === "boolean" ? config.enabled : true;
-		return VoiceCallConfigSchema.parse({
-			...config,
-			enabled,
-			provider: config.provider ?? (enabled ? "mock" : void 0)
-		});
-	},
-	uiHints: {
-		provider: {
-			label: "Provider",
-			help: "Use twilio, telnyx, or mock for dev/no-network."
-		},
-		fromNumber: {
-			label: "From Number",
-			placeholder: "+15550001234"
-		},
-		toNumber: {
-			label: "Default To Number",
-			placeholder: "+15550001234"
-		},
-		inboundPolicy: { label: "Inbound Policy" },
-		allowFrom: { label: "Inbound Allowlist" },
-		inboundGreeting: {
-			label: "Inbound Greeting",
-			advanced: true
-		},
-		numbers: {
-			label: "Per-number Routing",
-			help: "Inbound overrides keyed by dialed E.164 number.",
-			advanced: true
-		},
-		"telnyx.apiKey": {
-			label: "Telnyx API Key",
-			sensitive: true
-		},
-		"telnyx.connectionId": { label: "Telnyx Connection ID" },
-		"telnyx.publicKey": {
-			label: "Telnyx Public Key",
-			sensitive: true
-		},
-		"twilio.accountSid": { label: "Twilio Account SID" },
-		"twilio.authToken": {
-			label: "Twilio Auth Token",
-			sensitive: true
-		},
-		"twilio.region": {
-			label: "Twilio Region",
-			advanced: true
-		},
-		"outbound.defaultMode": { label: "Default Call Mode" },
-		"outbound.notifyHangupDelaySec": {
-			label: "Notify Hangup Delay (sec)",
-			advanced: true
-		},
-		"serve.port": { label: "Webhook Port" },
-		"serve.bind": { label: "Webhook Bind" },
-		"serve.path": { label: "Webhook Path" },
-		"tailscale.mode": {
-			label: "Tailscale Mode",
-			advanced: true
-		},
-		"tailscale.path": {
-			label: "Tailscale Path",
-			advanced: true
-		},
-		"tunnel.provider": {
-			label: "Tunnel Provider",
-			advanced: true
-		},
-		"tunnel.ngrokAuthToken": {
-			label: "ngrok Auth Token",
-			sensitive: true,
-			advanced: true
-		},
-		"tunnel.ngrokDomain": {
-			label: "ngrok Domain",
-			advanced: true
-		},
-		"tunnel.allowNgrokFreeTierLoopbackBypass": {
-			label: "Allow ngrok Free Tier (Loopback Bypass)",
-			advanced: true
-		},
-		"streaming.enabled": {
-			label: "Enable Streaming",
-			help: "Classic streaming transcription currently requires the Twilio call provider.",
-			advanced: true
-		},
-		"streaming.provider": {
-			label: "Streaming Provider",
-			help: "Uses the first registered realtime transcription provider when unset.",
-			advanced: true
-		},
-		"streaming.providers": {
-			label: "Streaming Provider Config",
-			advanced: true
-		},
-		"streaming.streamPath": {
-			label: "Media Stream Path",
-			advanced: true
-		},
-		"realtime.enabled": {
-			label: "Enable Realtime Voice",
-			advanced: true
-		},
-		"realtime.provider": {
-			label: "Realtime Voice Provider",
-			help: "Uses the first registered realtime voice provider when unset.",
-			advanced: true
-		},
-		"realtime.streamPath": {
-			label: "Realtime Stream Path",
-			advanced: true
-		},
-		"realtime.instructions": {
-			label: "Realtime Instructions",
-			advanced: true
-		},
-		"realtime.toolPolicy": {
-			label: "Realtime Tool Policy",
-			help: "Controls the shared openclaw_agent_consult tool.",
-			advanced: true
-		},
-		"realtime.consultPolicy": {
-			label: "Realtime Consult Policy",
-			help: "Guides when the realtime voice model should call openclaw_agent_consult.",
-			advanced: true
-		},
-		"realtime.fastContext.enabled": {
-			label: "Enable Fast Realtime Context",
-			help: "Searches memory/session context before the full consult agent.",
-			advanced: true
-		},
-		"realtime.fastContext.timeoutMs": {
-			label: "Fast Context Timeout",
-			advanced: true
-		},
-		"realtime.fastContext.maxResults": {
-			label: "Fast Context Result Limit",
-			advanced: true
-		},
-		"realtime.fastContext.sources": {
-			label: "Fast Context Sources",
-			advanced: true
-		},
-		"realtime.fastContext.fallbackToConsult": {
-			label: "Fallback To Full Consult",
-			advanced: true
-		},
-		"realtime.agentContext.enabled": {
-			label: "Enable Agent Voice Context",
-			help: "Injects a compact agent identity and workspace context capsule into realtime voice instructions.",
-			advanced: true
-		},
-		"realtime.agentContext.maxChars": {
-			label: "Agent Voice Context Limit",
-			advanced: true
-		},
-		"realtime.agentContext.includeIdentity": {
-			label: "Include Agent Identity",
-			advanced: true
-		},
-		"realtime.agentContext.includeWorkspaceFiles": {
-			label: "Include Agent Workspace Files",
-			advanced: true
-		},
-		"realtime.agentContext.files": {
-			label: "Agent Voice Context Files",
-			advanced: true
-		},
-		"realtime.providers": {
-			label: "Realtime Provider Config",
-			advanced: true
-		},
-		"tts.provider": {
-			label: "TTS Provider Override",
-			help: "Deep-merges with tts (Microsoft is ignored for calls).",
-			advanced: true
-		},
-		"tts.providers": {
-			label: "TTS Provider Config",
-			advanced: true
-		},
-		publicUrl: {
-			label: "Public Webhook URL",
-			advanced: true
-		},
-		skipSignatureVerification: {
-			label: "Skip Signature Verification",
-			advanced: true
-		},
-		store: {
-			label: "Call Log Store Path",
-			advanced: true
-		},
-		agentId: {
-			label: "Response Agent ID",
-			help: "Agent workspace used for voice response generation. Defaults to \"main\".",
-			advanced: true
-		},
-		responseModel: {
-			label: "Response Model",
-			help: "Optional override. Falls back to the runtime default model when unset.",
-			advanced: true
-		},
-		responseSystemPrompt: {
-			label: "Response System Prompt",
-			advanced: true
-		},
-		responseTimeoutMs: {
-			label: "Response Timeout (ms)",
-			advanced: true
-		}
-	}
-};
+const voiceCallConfigSchema = { parse(value) {
+	const config = asOptionalRecord(value) ?? {};
+	const enabled = typeof config.enabled === "boolean" ? config.enabled : true;
+	return VoiceCallConfigSchema.parse({
+		...config,
+		enabled,
+		provider: config.provider ?? (enabled ? "mock" : void 0)
+	});
+} };
 const VoiceCallToolSchema = Type.Union([
 	Type.Object({
 		action: Type.Literal("initiate_call"),
@@ -885,7 +822,6 @@ const VoiceCallToolSchema = Type.Union([
 		message: Type.String({ description: "Intro message" }),
 		mode: Type.Optional(Type.Union([Type.Literal("notify"), Type.Literal("conversation")])),
 		sessionKey: Type.Optional(Type.String({ description: "OpenClaw session key for the call" })),
-		requesterSessionKey: Type.Optional(Type.String({ description: "OpenClaw session key that initiated the call" })),
 		dtmfSequence: Type.Optional(Type.String({ description: "DTMF digits to play before connect" }))
 	}),
 	Type.Object({
@@ -917,38 +853,40 @@ const VoiceCallToolSchema = Type.Union([
 		sid: Type.Optional(Type.String({ description: "Call SID" })),
 		message: Type.Optional(Type.String({ description: "Optional intro message" })),
 		sessionKey: Type.Optional(Type.String({ description: "OpenClaw session key for the call" })),
-		requesterSessionKey: Type.Optional(Type.String({ description: "OpenClaw session key that initiated the call" })),
 		dtmfSequence: Type.Optional(Type.String({ description: "DTMF digits to play before connect" }))
 	})
 ]);
-function asParamRecord(params) {
-	return params && typeof params === "object" && !Array.isArray(params) ? params : {};
-}
 function isCliOnlyProcess() {
 	return process.env.OPENCLAW_CLI === "1" && !process.argv.slice(2).includes("gateway");
 }
-function toVoiceCallStatus(call) {
-	return {
-		callId: call.callId,
-		...call.providerCallId !== void 0 ? { providerCallId: call.providerCallId } : {},
-		provider: call.provider,
-		direction: call.direction,
-		state: call.state,
-		startedAt: call.startedAt,
-		...call.answeredAt !== void 0 ? { answeredAt: call.answeredAt } : {},
-		...call.endedAt !== void 0 ? { endedAt: call.endedAt } : {},
-		...call.endReason !== void 0 ? { endReason: call.endReason } : {}
-	};
+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 }));
+}
+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 !== registration) {
+		if (coordinator.current) coordinator.current.generation.retired = true;
+		coordinator.current = registration;
+	}
 }
-const VOICE_CALL_RUNTIME_KEY = Symbol.for("openclaw.voice-call.runtime");
-const VOICE_CALL_RUNTIME_PROMISE_KEY = Symbol.for("openclaw.voice-call.runtimePromise");
-const VOICE_CALL_RUNTIME_STOP_PROMISE_KEY = Symbol.for("openclaw.voice-call.runtimeStopPromise");
-function getVoiceCallRuntimeGlobalState() {
-	const state = globalThis;
-	state[VOICE_CALL_RUNTIME_KEY] ??= null;
-	state[VOICE_CALL_RUNTIME_PROMISE_KEY] ??= null;
-	state[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] ??= null;
-	return state;
+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",
@@ -958,24 +896,56 @@ var voice_call_default = definePluginEntry({
 	register(api) {
 		const config = resolveVoiceCallConfig(voiceCallConfigSchema.parse(api.pluginConfig));
 		const validation = validateProviderConfig(config);
-		const runtimeState = getVoiceCallRuntimeGlobalState();
+		const runtimeCoordinator = getVoiceCallRuntimeCoordinator();
+		const runtimeRegistration = api.registrationMode !== "full" && runtimeCoordinator.current ? runtimeCoordinator.current : {
+			epoch: ++runtimeCoordinator.epochCounter,
+			generation: { retired: false }
+		};
 		const continueOperationStore = createVoiceCallContinueOperationStore({
 			config,
 			coreConfig: api.config
 		});
-		const ensureRuntime = async () => {
+		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) {
-				if (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY]) {
-					await runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY];
-					continue;
+				activateRuntimeGeneration(runtimeGeneration);
+				const slot = runtimeCoordinator.slot;
+				if (slot) {
+					if (slot.owner !== runtimeGeneration) {
+						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");
+					}
+					if (slot.state === "running") return slot.runtime;
+					if (slot.state === "stopping") {
+						await slot.promise;
+						continue;
+					}
+					let createdRuntime;
+					try {
+						createdRuntime = await slot.promise;
+					} catch (err) {
+						if (runtimeCoordinator.slot === slot) runtimeCoordinator.slot = void 0;
+						throw err;
+					}
+					activateRuntimeGeneration(runtimeGeneration);
+					if (runtimeCoordinator.slot !== slot) continue;
+					runtimeCoordinator.slot = {
+						state: "running",
+						owner: runtimeGeneration,
+						runtime: createdRuntime
+					};
+					return createdRuntime;
 				}
-				const runtime = runtimeState[VOICE_CALL_RUNTIME_KEY];
-				if (runtime) return runtime;
-				let runtimePromise = runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY];
-				if (!runtimePromise) {
-					runtimePromise = createVoiceCallRuntime({
+				const startingSlot = {
+					state: "starting",
+					owner: runtimeGeneration,
+					promise: createVoiceCallRuntime({
 						config,
 						coreConfig: api.config,
 						fullConfig: api.config,
@@ -983,279 +953,76 @@ var voice_call_default = definePluginEntry({
 						stateRuntime: api.runtime.state,
 						ttsRuntime: api.runtime.tts,
 						logger: api.logger
-					});
-					runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] = runtimePromise;
-				}
-				try {
-					const createdRuntime = await runtimePromise;
-					if (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY]) continue;
-					if (runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] !== runtimePromise) continue;
-					runtimeState[VOICE_CALL_RUNTIME_KEY] = createdRuntime;
-					return createdRuntime;
-				} catch (err) {
-					if (runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] === runtimePromise) {
-						runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] = null;
-						runtimeState[VOICE_CALL_RUNTIME_KEY] = null;
-					}
-					throw err;
-				}
-			}
-		};
-		const respondError = (respond, message, code = ErrorCodes.UNAVAILABLE) => {
-			respond(false, void 0, errorShape(code, message));
-		};
-		const sendError = (respond, err) => {
-			respondError(respond, formatErrorMessage(err));
-		};
-		const describeHistoricalCall = async (rt, callId) => {
-			const call = await rt.manager.getCallFromMemoryOrStore(callId);
-			if (!call) return;
-			const endedAt = timestampMsToIsoString(call.endedAt);
-			return `call is not active (${[
-				`last state=${call.state}`,
-				call.endReason ? `endReason=${call.endReason}` : void 0,
-				endedAt ? `endedAt=${endedAt}` : void 0
-			].filter(Boolean).join(", ")})`;
-		};
-		const resolveCallMessageRequest = async (params) => {
-			const callId = normalizeOptionalString(params?.callId) ?? "";
-			const message = normalizeOptionalString(params?.message) ?? "";
-			if (!callId || !message) return { error: "callId and message required" };
-			const rt = await ensureRuntime();
-			const activeCall = rt.manager.getCall(callId) ?? rt.manager.getCallByProviderCallId(callId);
-			if (activeCall) return {
-				rt,
-				callId: activeCall.callId,
-				message
-			};
-			return { error: await describeHistoricalCall(rt, callId) ?? "Call not found" };
-		};
-		const initiateCallAndRespond = async (params) => {
-			const result = await params.rt.manager.initiateCall(params.to, params.sessionKey, {
-				message: params.message,
-				mode: params.mode,
-				dtmfSequence: params.dtmfSequence,
-				...params.requesterSessionKey ? { requesterSessionKey: params.requesterSessionKey } : {},
-				...params.agentId ? { agentId: params.agentId } : {}
-			});
-			if (!result.success) {
-				respondError(params.respond, result.error || "initiate failed");
-				return;
-			}
-			params.respond(true, {
-				callId: result.callId,
-				initiated: true
-			});
-		};
-		const respondToCallMessageAction = async (params) => {
-			const request = await resolveCallMessageRequest(params.requestParams);
-			if ("error" in request) {
-				respondError(params.respond, request.error ?? "callId and message required", ErrorCodes.INVALID_REQUEST);
-				return;
-			}
-			const result = await params.action(request);
-			if (!result.success) {
-				respondError(params.respond, result.error || params.failure);
-				return;
+					})
+				};
+				runtimeCoordinator.slot = startingSlot;
 			}
-			params.respond(true, params.includeTranscript ? {
-				success: true,
-				transcript: result.transcript
-			} : { success: true });
 		};
-		api.registerGatewayMethod("voicecall.initiate", async ({ params, respond }) => {
-			try {
-				const message = normalizeOptionalString(params?.message) ?? "";
-				if (!message) {
-					respondError(respond, "message required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const rt = await ensureRuntime();
-				const to = normalizeOptionalString(params?.to) ?? rt.config.toNumber;
-				if (!to) {
-					respondError(respond, "to required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const mode = params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0;
-				await initiateCallAndRespond({
-					rt,
-					respond,
-					to,
-					message,
-					mode,
-					sessionKey: normalizeOptionalString(params?.sessionKey),
-					requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey)
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.continue", async ({ params, respond }) => {
-			try {
-				await respondToCallMessageAction({
-					requestParams: params,
-					respond,
-					action: (request) => request.rt.manager.continueCall(request.callId, request.message),
-					failure: "continue failed",
-					includeTranscript: true
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.continue.start", async ({ params, respond }) => {
-			try {
-				const request = await resolveCallMessageRequest(params);
-				if ("error" in request) {
-					respondError(respond, request.error ?? "callId and message required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				respond(true, continueOperationStore.start(request));
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.continue.result", async ({ params, respond }) => {
+		const ensureRuntime = async (runtimeGeneration = runtimeRegistration.generation) => {
 			try {
-				const operationId = normalizeOptionalString(params?.operationId) ?? "";
-				if (!operationId) {
-					respondError(respond, "operationId required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const operation = continueOperationStore.read(operationId);
-				if (!operation.ok) {
-					respondError(respond, operation.error, ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				respond(true, operation.payload);
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_READ_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.speak", async ({ params, respond }) => {
-			try {
-				const request = await resolveCallMessageRequest(params);
-				if ("error" in request) {
-					respondError(respond, request.error ?? "callId and message required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				if (request.rt.config.realtime.enabled) {
-					const realtimeResult = request.rt.webhookServer.speakRealtime(request.callId, request.message);
-					if (realtimeResult.success) {
-						respond(true, { success: true });
-						return;
-					}
-					if (params?.allowTwimlFallback === false) {
-						respond(true, {
-							success: false,
-							error: realtimeResult.error ?? "Realtime bridge is not active"
-						});
-						return;
-					}
-				}
-				const result = await request.rt.manager.speak(request.callId, request.message);
-				if (!result.success) {
-					respondError(respond, result.error || "speak failed");
-					return;
-				}
-				respond(true, { success: true });
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.dtmf", async ({ params, respond }) => {
-			try {
-				const callId = normalizeOptionalString(params?.callId) ?? "";
-				const digits = normalizeOptionalString(params?.digits) ?? "";
-				if (!callId || !digits) {
-					respondError(respond, "callId and digits required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const result = await (await ensureRuntime()).manager.sendDtmf(callId, digits);
-				if (!result.success) {
-					respondError(respond, result.error || "dtmf failed");
-					return;
-				}
-				respond(true, { success: true });
+				const runtime = await ensureRuntimeForGeneration(runtimeGeneration);
+				runtimeGeneration.serviceHealth?.clearFailure();
+				return runtime;
 			} catch (err) {
-				sendError(respond, err);
+				if (!(err instanceof VoiceCallRuntimeLifecycleError)) runtimeGeneration.serviceHealth?.reportFailure(err);
+				throw err;
 			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.end", async ({ params, respond }) => {
-			try {
-				const callId = normalizeOptionalString(params?.callId) ?? "";
-				if (!callId) {
-					respondError(respond, "callId required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const result = await (await ensureRuntime()).manager.endCall(callId);
-				if (!result.success) {
-					respondError(respond, result.error || "end failed");
-					return;
+		};
+		const commands = createVoiceCallCommandService(ensureRuntime);
+		const registerGatewayCommand = (method, handler, scope) => {
+			api.registerGatewayMethod(method, async (options) => {
+				try {
+					options.respond(true, await handler(options));
+				} catch (err) {
+					const code = err instanceof VoiceCallCommandInputError ? ErrorCodes.INVALID_REQUEST : ErrorCodes.UNAVAILABLE;
+					options.respond(false, void 0, errorShape(code, formatErrorMessage(err)));
 				}
-				respond(true, { success: true });
-			} catch (err) {
-				sendError(respond, err);
-			}
+			}, scope);
+		};
+		registerGatewayCommand("voicecall.initiate", async ({ params }) => {
+			const message = normalizeOptionalString(params?.message);
+			if (!message) throw new VoiceCallCommandInputError("message required");
+			return await commands.initiate({
+				to: normalizeOptionalString(params?.to),
+				message,
+				mode: params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0,
+				sessionKey: normalizeOptionalString(params?.sessionKey),
+				requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey)
+			});
 		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.status", async ({ params, respond }) => {
-			try {
-				const raw = normalizeOptionalString(params?.callId) ?? normalizeOptionalString(params?.sid) ?? "";
-				const rt = await ensureRuntime();
-				if (!raw) {
-					respond(true, {
-						found: true,
-						calls: rt.manager.getActiveCalls().map(toVoiceCallStatus)
-					});
-					return;
-				}
-				const call = await rt.manager.getCallFromMemoryOrStore(raw);
-				if (!call) {
-					respond(true, { found: false });
-					return;
-				}
-				respond(true, {
-					found: true,
-					call: toVoiceCallStatus(call)
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
+		registerGatewayCommand("voicecall.continue", ({ params }) => commands.continueCall(normalizeOptionalString(params?.callId), normalizeOptionalString(params?.message)), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.continue.start", async ({ params }) => continueOperationStore.start(await commands.prepareContinue(normalizeOptionalString(params?.callId), normalizeOptionalString(params?.message))), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.continue.result", ({ params }) => {
+			const operationId = normalizeOptionalString(params?.operationId);
+			if (!operationId) throw new VoiceCallCommandInputError("operationId required");
+			const operation = continueOperationStore.read(operationId);
+			if (!operation.ok) throw new VoiceCallCommandInputError(operation.error);
+			return operation.payload;
 		}, VOICE_CALL_READ_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.start", async ({ params, client, respond }) => {
-			try {
-				const to = normalizeOptionalString(params?.to) ?? "";
-				const message = normalizeOptionalString(params?.message) ?? "";
-				const dtmfSequence = normalizeOptionalString(params?.dtmfSequence);
-				const sessionKey = normalizeOptionalString(params?.sessionKey);
-				const requesterSessionKey = normalizeOptionalString(params?.requesterSessionKey);
-				const requestedAgentId = normalizeOptionalString(params?.agentId);
-				const normalizedAgentId = requestedAgentId ? normalizeAgentId(requestedAgentId) : void 0;
-				const pluginOwnerId = normalizeOptionalString(client?.internal?.pluginRuntimeOwnerId);
-				if (requestedAgentId && (!pluginOwnerId || normalizedAgentId !== requestedAgentId.toLowerCase())) {
-					respondError(respond, "agentId requires a trusted plugin caller and a valid agent id", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				if (!to) {
-					respondError(respond, "to required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const mode = params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0;
-				const rt = await ensureRuntime();
-				await initiateCallAndRespond({
-					rt,
-					respond,
-					to,
-					message: message || void 0,
-					mode,
-					dtmfSequence,
-					sessionKey,
-					...requesterSessionKey ? { requesterSessionKey } : {},
-					...normalizedAgentId ? { agentId: normalizedAgentId } : {}
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
+		registerGatewayCommand("voicecall.speak", ({ params }) => commands.speak({
+			callId: normalizeOptionalString(params?.callId),
+			message: normalizeOptionalString(params?.message),
+			allowTwimlFallback: params?.allowTwimlFallback !== false
+		}), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.dtmf", ({ params }) => commands.sendDtmf(normalizeOptionalString(params?.callId), normalizeOptionalString(params?.digits)), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.end", ({ params }) => commands.endCall(normalizeOptionalString(params?.callId)), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.status", ({ params }) => commands.status(normalizeOptionalString(params?.callId) ?? normalizeOptionalString(params?.sid)), VOICE_CALL_READ_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.start", async ({ params, client }) => {
+			const to = normalizeOptionalString(params?.to);
+			const requestedAgentId = normalizeOptionalString(params?.agentId);
+			const normalizedAgentId = requestedAgentId ? normalizeAgentId(requestedAgentId) : void 0;
+			const pluginOwnerId = normalizeOptionalString(client?.internal?.pluginRuntimeOwnerId);
+			if (requestedAgentId && (!pluginOwnerId || normalizedAgentId !== requestedAgentId.toLowerCase())) throw new VoiceCallCommandInputError("agentId requires a trusted plugin caller and a valid agent id");
+			if (!to) throw new VoiceCallCommandInputError("to required");
+			return await commands.initiate({
+				to,
+				message: normalizeOptionalString(params?.message),
+				mode: params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0,
+				dtmfSequence: normalizeOptionalString(params?.dtmfSequence),
+				sessionKey: normalizeOptionalString(params?.sessionKey),
+				requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey),
+				agentId: normalizedAgentId
+			});
 		}, VOICE_CALL_WRITE_METHOD_SCOPE);
 		api.registerTool((toolContext) => ({
 			name: "voice_call",
@@ -1263,94 +1030,52 @@ var voice_call_default = definePluginEntry({
 			description: "Make phone calls and have voice conversations via the voice-call plugin.",
 			parameters: VoiceCallToolSchema,
 			async execute(_toolCallId, params) {
-				const rawParams = asParamRecord(params);
-				const agentId = normalizeOptionalString(toolContext.agentId);
+				const rawParams = asNonArrayRecord(params);
+				const requesterSessionKey = normalizeOptionalString(toolContext.sessionKey);
+				const contextAgentId = normalizeOptionalString(toolContext.agentId) ?? parseAgentSessionKey(requesterSessionKey)?.agentId;
+				const agentId = contextAgentId ? normalizeAgentId(contextAgentId) : void 0;
 				try {
-					const rt = await ensureRuntime();
+					await ensureRuntime();
 					if (typeof rawParams.action === "string") switch (rawParams.action) {
 						case "initiate_call": {
-							const message = normalizeOptionalString(rawParams.message) ?? "";
-							if (!message) throw new Error("message required");
-							const to = normalizeOptionalString(rawParams.to) ?? rt.config.toNumber;
-							if (!to) throw new Error("to required");
-							const result = await rt.manager.initiateCall(to, void 0, {
+							const message = normalizeOptionalString(rawParams.message);
+							if (!message) throw new VoiceCallCommandInputError("message required");
+							return jsonResult(await commands.initiate({
+								to: normalizeOptionalString(rawParams.to),
 								message,
 								dtmfSequence: normalizeOptionalString(rawParams.dtmfSequence),
 								mode: rawParams.mode === "notify" || rawParams.mode === "conversation" ? rawParams.mode : void 0,
-								...agentId ? { agentId } : {}
-							});
-							if (!result.success) throw new Error(result.error || "initiate failed");
-							return jsonResult({
-								callId: result.callId,
-								initiated: true
-							});
-						}
-						case "continue_call": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							const message = normalizeOptionalString(rawParams.message) ?? "";
-							if (!callId || !message) throw new Error("callId and message required");
-							const result = await rt.manager.continueCall(callId, message);
-							if (!result.success) throw new Error(result.error || "continue failed");
-							return jsonResult({
-								success: true,
-								transcript: result.transcript
-							});
-						}
-						case "speak_to_user": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							const message = normalizeOptionalString(rawParams.message) ?? "";
-							if (!callId || !message) throw new Error("callId and message required");
-							const result = await rt.manager.speak(callId, message);
-							if (!result.success) throw new Error(result.error || "speak failed");
-							return jsonResult({ success: true });
-						}
-						case "send_dtmf": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							const digits = normalizeOptionalString(rawParams.digits) ?? "";
-							if (!callId || !digits) throw new Error("callId and digits required");
-							const result = await rt.manager.sendDtmf(callId, digits);
-							if (!result.success) throw new Error(result.error || "dtmf failed");
-							return jsonResult({ success: true });
-						}
-						case "end_call": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							if (!callId) throw new Error("callId required");
-							const result = await rt.manager.endCall(callId);
-							if (!result.success) throw new Error(result.error || "end failed");
-							return jsonResult({ success: true });
+								sessionKey: normalizeOptionalString(rawParams.sessionKey),
+								agentId,
+								requesterSessionKey
+							}));
 						}
+						case "continue_call": return jsonResult(await commands.continueCall(normalizeOptionalString(rawParams.callId), normalizeOptionalString(rawParams.message)));
+						case "speak_to_user": return jsonResult(await commands.speak({
+							callId: normalizeOptionalString(rawParams.callId),
+							message: normalizeOptionalString(rawParams.message)
+						}));
+						case "send_dtmf": return jsonResult(await commands.sendDtmf(normalizeOptionalString(rawParams.callId), normalizeOptionalString(rawParams.digits)));
+						case "end_call": return jsonResult(await commands.endCall(normalizeOptionalString(rawParams.callId)));
 						case "get_status": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							if (!callId) throw new Error("callId required");
-							const call = await rt.manager.getCallFromMemoryOrStore(callId);
-							return jsonResult(call ? {
-								found: true,
-								call: toVoiceCallStatus(call)
-							} : { found: false });
+							const callId = normalizeOptionalString(rawParams.callId);
+							if (!callId) throw new VoiceCallCommandInputError("callId required");
+							return jsonResult(await commands.status(callId));
 						}
 					}
 					if ((rawParams.mode ?? "call") === "status") {
 						const sid = normalizeOptionalString(rawParams.sid) ?? "";
 						if (!sid) throw new Error("sid required for status");
-						const call = await rt.manager.getCallFromMemoryOrStore(sid);
-						return jsonResult(call ? {
-							found: true,
-							call: toVoiceCallStatus(call)
-						} : { found: false });
+						return jsonResult(await commands.status(sid));
 					}
-					const to = normalizeOptionalString(rawParams.to) ?? rt.config.toNumber;
-					if (!to) throw new Error("to required for call");
-					const result = await rt.manager.initiateCall(to, normalizeOptionalString(rawParams.sessionKey), {
+					return jsonResult(await commands.initiate({
+						to: normalizeOptionalString(rawParams.to),
 						dtmfSequence: normalizeOptionalString(rawParams.dtmfSequence),
 						message: normalizeOptionalString(rawParams.message),
-						...agentId ? { agentId } : {},
-						...normalizeOptionalString(rawParams.requesterSessionKey) ? { requesterSessionKey: normalizeOptionalString(rawParams.requesterSessionKey) } : {}
-					});
-					if (!result.success) throw new Error(result.error || "initiate failed");
-					return jsonResult({
-						callId: result.callId,
-						initiated: true
-					});
+						sessionKey: normalizeOptionalString(rawParams.sessionKey),
+						agentId,
+						requesterSessionKey
+					}, "to required for call"));
 				} catch (err) {
 					return jsonResult({ error: formatErrorMessage(err) });
 				}
@@ -1368,35 +1093,41 @@ var voice_call_default = definePluginEntry({
 		});
 		api.registerService({
 			id: "voicecall",
-			start: () => {
+			start: (ctx) => {
 				if (isCliOnlyProcess()) return;
+				try {
+					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) {
+					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 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 (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY]) {
-					await runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY];
-					return;
-				}
-				const runtime = runtimeState[VOICE_CALL_RUNTIME_KEY];
-				const runtimePromise = runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY];
-				if (!runtime && !runtimePromise) return;
-				runtimeState[VOICE_CALL_RUNTIME_KEY] = null;
-				runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] = null;
-				const stopPromise = (async () => {
-					await (runtime ?? await runtimePromise).stop();
-				})();
-				runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] = stopPromise;
+				const runtimeGeneration = runtimeRegistration.generation;
+				runtimeGeneration.retired = true;
 				try {
-					await stopPromise;
+					await stopVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
 				} finally {
-					if (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] === stopPromise) runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] = null;
+					runtimeGeneration.serviceHealth = void 0;
 				}
 			}
 		});