@openclaw/voice-call 2026.10.10 → 2026.11.5-beta.1

package/dist/.setup/{carrier-api-BgJdQC-e.mjs → carrier-api-CZQtPnYQ.mjs}

@@ -1,20 +1,18 @@
 import { fetchWithSsrFGuard } from "../api.js";
-import { c as getHeader, r as normalizeProxyIp } from "./runtime-entry-CKPPin7r.mjs";
-import { n as reserveWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-B0Eo3Ll5.mjs";
+import { n as normalizeProxyIp, s as getHeader } from "./runtime-entry-Br7ttAwq.mjs";
+import { n as reserveWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-DnlMxw4z.mjs";
+import crypto from "node:crypto";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import crypto from "node:crypto";
 import { isIP } from "node:net";
+import { sha256Hex } from "openclaw/plugin-sdk/node-crypto-runtime";
 import { redactSensitiveText, safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { readResponseTextPrefix, readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 // extensions/voice-call/src/webhook-security.ts
 const twilioReplayCache = createWebhookReplayCache();
 const plivoReplayCache = createWebhookReplayCache();
 const telnyxReplayCache = createWebhookReplayCache();
-function sha256Hex(input) {
-	return crypto.createHash("sha256").update(input).digest("hex");
-}
 function skipWebhookVerification(provider, ctx, cache) {
 	const replayKey = `${provider}:skip:${sha256Hex(`${ctx.method}\n${ctx.url}\n${ctx.rawBody}`)}`;
 	return {
@@ -254,9 +252,8 @@ function verifyTelnyxWebhook(ctx, publicKey, options) {
 			ok: false,
 			reason: "Invalid signature"
 		};
-		const maxSkewMs = options?.maxSkewMs ?? 3e5;
 		const eventTimeMs = eventTimeSec * 1e3;
-		if (Math.abs(Date.now() - eventTimeMs) > maxSkewMs) return {
+		if (Math.abs(Date.now() - eventTimeMs) > 3e5) return {
 			ok: false,
 			reason: "Timestamp too old"
 		};
@@ -297,7 +294,6 @@ function verifyTwilioWebhook(ctx, authToken, options) {
 		});
 		return {
 			ok: true,
-			verificationUrl: candidateUrl,
 			...reserveWebhookReplay(twilioReplayCache, replayKey)
 		};
 	};
@@ -317,11 +313,9 @@ function verifyTwilioWebhook(ctx, authToken, options) {
 		const result = verifyUrl(candidateUrl);
 		if (result) return result;
 	}
-	const isNgrokFreeTier = verificationUrl.includes(".ngrok-free.app") || verificationUrl.includes(".ngrok.io");
 	return {
 		ok: false,
-		reason: `Invalid signature for URL: ${redactTwilioVerificationUrlForDiagnostics(verificationUrl)}`,
-		isNgrokFreeTier
+		reason: `Invalid signature for URL: ${redactTwilioVerificationUrlForDiagnostics(verificationUrl)}`
 	};
 }
 function normalizeSignatureBase64(input) {
@@ -352,19 +346,13 @@ function constructPlivoV3BaseUrl(params) {
 function verifyPlivoSignature(params) {
 	const hmacBase = `${params.baseUrl}${params.version === "v3" ? "." : ""}${params.nonce}`;
 	const expected = normalizeSignatureBase64(crypto.createHmac("sha256", params.authToken).update(hmacBase).digest("base64"));
-	const ok = params.signatures.map(normalizeSignatureBase64).some((signature) => safeEqualSecret(expected, signature));
-	const result = {
-		ok,
-		version: params.version,
-		verificationUrl: params.verificationUrl
-	};
-	if (!ok) return {
-		...result,
+	if (!params.signatures.map(normalizeSignatureBase64).some((signature) => safeEqualSecret(expected, signature))) return {
+		ok: false,
 		reason: `Invalid Plivo ${params.version.toUpperCase()} signature`
 	};
 	const replayKey = `plivo:${params.version}:${sha256Hex(`${params.baseUrl}\n${params.nonce}`)}`;
 	return {
-		...result,
+		ok: true,
 		...reserveWebhookReplay(plivoReplayCache, replayKey)
 	};
 }
@@ -400,8 +388,6 @@ function verifyPlivoWebhook(ctx, authToken, options) {
 		const method = ctx.method === "GET" || ctx.method === "POST" ? ctx.method : null;
 		if (!method) return {
 			ok: false,
-			version: "v3",
-			verificationUrl,
 			reason: `Unsupported HTTP method for Plivo V3 signature: ${ctx.method}`
 		};
 		const postParams = new URLSearchParams(ctx.rawBody);
@@ -413,7 +399,6 @@ function verifyPlivoWebhook(ctx, authToken, options) {
 		return verifyPlivoSignature({
 			authToken,
 			version: "v3",
-			verificationUrl,
 			signatures: normalizeStringEntries(signatureV3.split(",")),
 			nonce: nonceV3,
 			baseUrl
@@ -422,17 +407,19 @@ function verifyPlivoWebhook(ctx, authToken, options) {
 	if (signatureV2 && nonceV2) return verifyPlivoSignature({
 		authToken,
 		version: "v2",
-		verificationUrl,
 		signatures: [signatureV2],
 		nonce: nonceV2,
 		baseUrl: getBaseUrlNoQuery(verificationUrl)
 	});
 	return {
 		ok: false,
-		reason: "Missing Plivo signature headers (V3 or V2)",
-		verificationUrl
+		reason: "Missing Plivo signature headers (V3 or V2)"
 	};
 }
+// extensions/voice-call/src/providers/base.ts
+function assertVoiceCallProviderSetting(value, message) {
+	if (!value) throw new Error(message);
+}
 // extensions/voice-call/src/providers/shared/guarded-json-api.ts
 const VOICE_CALL_PROVIDER_API_TIMEOUT_MS = 3e4;
 const PROVIDER_JSON_RESPONSE_MAX_BYTES = 1048576;
@@ -524,4 +511,4 @@ function createCarrierApi(name, baseUrl, authorization, options = {}) {
 		}
 	};
 }
-export { verifyTwilioWebhook as a, verifyTelnyxWebhook as i, reconstructWebhookUrl as n, verifyPlivoWebhook as r, createCarrierApi as t };
+export { verifyTelnyxWebhook as a, verifyPlivoWebhook as i, assertVoiceCallProviderSetting as n, verifyTwilioWebhook as o, reconstructWebhookUrl as r, createCarrierApi as t };

package/dist/.setup/{cli-CI9QzIaT.mjs → cli-BUVmNuk8.mjs}

@@ -1,18 +1,19 @@
-import { sleep } from "../api.js";
-import { g as CallBriefSchema, l as resolveVoiceCallStreamExposurePaths, u as validateProviderConfig } from "./config-BxESUUSm.mjs";
-import { S as resolveVoiceCallAgentId, _ as findCallInStore, b as setVoiceCallStateRuntime, d as getTailscaleSelfInfo, f as setupTailscaleExposureRoutes, g as MAX_CALL_RECORD_EVENTS, l as resolveWebhookExposureStatus, u as cleanupTailscaleExposureRoute, v as getCallHistoryFromStore, y as loadActiveCallsFromStore } from "./runtime-entry-CKPPin7r.mjs";
-import { r as resolveUserPath, t as resolveDefaultVoiceCallStoreDir } from "./store-path-Bn3bLr8y.mjs";
+import { c as resolveVoiceCallStreamExposurePaths, h as CallBriefSchema, l as validateProviderConfig } from "./config-D_w9HzxP.mjs";
+import { _ as getCallHistoryFromStore, c as resolveWebhookExposureStatus, d as setupTailscaleExposureRoutes, g as findCallInStore, h as MAX_CALL_RECORD_EVENTS, l as cleanupTailscaleExposureRoute, u as getTailscaleSelfInfo, v as loadActiveCallsFromStore, x as resolveVoiceCallAgentId, y as setVoiceCallStateRuntime } from "./runtime-entry-Br7ttAwq.mjs";
+import { r as resolveUserPath, t as resolveDefaultVoiceCallStoreDir } from "./store-path-C0yJCDE8.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { callGatewayFromCli, isGatewayClientRequestError, isGatewayTransportError, redactSensitiveUrlLikeString } from "openclaw/plugin-sdk/gateway-runtime";
-import { isRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { MAX_TCP_PORT, MAX_TIMER_TIMEOUT_MS, addTimerTimeoutGraceMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+import { isRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import fs from "node:fs";
 import path from "node:path";
-import { realpath } from "node:fs/promises";
+import { format } from "node:util";
 import { createDeferred } from "openclaw/plugin-sdk/concurrency-runtime";
+import { realpath } from "node:fs/promises";
 import { readRegularFile } from "openclaw/plugin-sdk/file-access-runtime";
 import { once } from "node:events";
-import { format } from "node:util";
+import { setTimeout } from "node:timers/promises";
 // extensions/voice-call/src/cli-command-io.ts
 function writeCliLine(...values) {
 	process.stdout.write(`${format(...values)}\n`);
@@ -28,8 +29,9 @@ function parseCliInteger(raw, optionName, opts) {
 }
 // extensions/voice-call/src/cli-call-log.ts
 const READ_BYTES = 65536;
-async function writeLogChunk(chunk) {
-	if (!process.stdout.write(chunk)) await once(process.stdout, "drain");
+async function writeLogChunk(chunk, signal) {
+	signal.throwIfAborted();
+	if (!process.stdout.write(chunk)) await once(process.stdout, "drain", { signal });
 }
 function* readLogLine({ fd, start, end }) {
 	for (let offset = start; offset < end;) {
@@ -40,20 +42,21 @@ function* readLogLine({ fd, start, end }) {
 		yield chunk.subarray(0, bytesRead);
 	}
 }
-async function* readLogLines(file, last, pollMs) {
+async function* readLogLines(file, last, pollMs, signal) {
 	let initial = true;
 	let offset = 0;
 	let lineStart = 0;
 	let previous;
 	const buffer = Buffer.alloc(READ_BYTES);
 	for (;;) {
+		signal?.throwIfAborted();
 		let fd;
 		try {
 			const flags = process.platform === "win32" ? "r" : fs.constants.O_RDONLY | fs.constants.O_NONBLOCK;
 			fd = fs.openSync(file, flags);
 		} catch (error) {
 			if (initial || pollMs === void 0 || !isRecord(error) || error.code !== "ENOENT") throw error;
-			await sleep(pollMs);
+			await setTimeout(pollMs, void 0, { signal });
 			continue;
 		}
 		try {
@@ -95,7 +98,7 @@ async function* readLogLines(file, last, pollMs) {
 		}
 		initial = false;
 		if (pollMs === void 0) return;
-		await sleep(pollMs);
+		await setTimeout(pollMs, void 0, { signal });
 	}
 }
 function summarizeSeries(values) {
@@ -142,24 +145,43 @@ function registerVoiceCallLogs(params) {
 		const file = options.file;
 		const since = parseCliInteger(options.since, "--since", { min: 0 });
 		const pollMs = parseCliInteger(options.poll, "--poll", { min: 50 });
-		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") for await (const line of readLogLines(file, since, pollMs)) {
-			for (const chunk of readLogLine(line)) await writeLogChunk(chunk);
-			await writeLogChunk("\n");
-		}
-		else {
-			params.ensureHistoryStateRuntime();
-			let initial = true;
-			let seen = /* @__PURE__ */ new Set();
-			for (;;) {
-				const lines = (await getCallHistoryFromStore(path.dirname(file), MAX_CALL_RECORD_EVENTS)).map((call) => JSON.stringify(call));
-				for (const line of initial ? lines.slice(Math.max(0, lines.length - since)) : lines) if (!seen.has(line)) {
-					await writeLogChunk(`${line}\n`);
-					seen.add(line);
+		const cancellation = new AbortController();
+		const { signal } = cancellation;
+		const interrupt = (exitCode) => {
+			if (!signal.aborted) {
+				process.exitCode = exitCode;
+				cancellation.abort();
+			}
+		};
+		const onSigint = () => interrupt(130);
+		const onSigterm = () => interrupt(143);
+		process.on("SIGINT", onSigint);
+		process.on("SIGTERM", onSigterm);
+		try {
+			if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") for await (const line of readLogLines(file, since, pollMs, signal)) {
+				for (const chunk of readLogLine(line)) await writeLogChunk(chunk, signal);
+				await writeLogChunk("\n", signal);
+			}
+			else {
+				params.ensureHistoryStateRuntime();
+				let initial = true;
+				let seen = /* @__PURE__ */ new Set();
+				while (!signal.aborted) {
+					const lines = (await getCallHistoryFromStore(path.dirname(file), MAX_CALL_RECORD_EVENTS)).map((call) => JSON.stringify(call));
+					for (const line of initial ? lines.slice(Math.max(0, lines.length - since)) : lines) if (!seen.has(line)) {
+						await writeLogChunk(`${line}\n`, signal);
+						seen.add(line);
+					}
+					seen = new Set(lines);
+					initial = false;
+					await setTimeout(pollMs, void 0, { signal });
 				}
-				seen = new Set(lines);
-				initial = false;
-				await sleep(pollMs);
 			}
+		} catch (error) {
+			if (!signal.aborted || !(error instanceof Error) || error.name !== "AbortError") throw error;
+		} finally {
+			process.off("SIGINT", onSigint);
+			process.off("SIGTERM", onSigterm);
 		}
 	});
 	params.root.command("latency").description("Summarize turn latency metrics from voice-call history or a custom JSONL log").option("--file <path>", "Path to calls.jsonl", params.defaultFile).option("--last <n>", "Analyze last N records", "200").action(async (options) => {
@@ -187,9 +209,6 @@ 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");
 }
@@ -207,21 +226,23 @@ function gatewayOperationalError(err) {
 	})();
 	return new Error(redactSensitiveUrlLikeString(detail));
 }
-function isUnknownMethod(err, method) {
-	return formatErrorMessage(err).includes(`unknown method: ${method}`);
-}
 async function callVoiceCallGateway(method, params, opts) {
 	try {
+		opts?.signal?.throwIfAborted();
 		const timeoutMs = typeof opts?.timeoutMs === "number" && Number.isFinite(opts.timeoutMs) ? Math.max(1, Math.ceil(opts.timeoutMs)) : VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS;
 		return {
 			ok: true,
 			payload: await callGatewayFromCli(method, {
 				json: true,
 				timeout: String(timeoutMs)
-			}, params, { progress: false })
+			}, params, {
+				progress: false,
+				...opts?.signal ? { signal: opts.signal } : {}
+			})
 		};
 	} catch (err) {
-		if (isGatewayUnavailableForLocalFallback(err)) return {
+		if (opts?.signal?.aborted && err instanceof Error && err.name === "AbortError") throw err;
+		if (isGatewayTransportError(err) && err.kind === "closed" && (err.code === void 0 || err.code === 1006)) return {
 			ok: false,
 			error: err
 		};
@@ -234,25 +255,31 @@ function resolveOperationTimeout(config) {
 function resolveContinueTimeout(config) {
 	return clampTimerTimeoutMs(config.transcriptTimeoutMs + VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS + VOICE_CALL_GATEWAY_TRANSCRIPT_BUFFER_MS) ?? 1;
 }
-async function pollContinueGateway(payload, fallbackTimeoutMs) {
+async function pollContinueGateway(payload, fallbackTimeoutMs, signal) {
+	signal?.throwIfAborted();
 	if (!isRecord(payload) || typeof payload.operationId !== "string") return payload;
 	if (!payload.operationId) throw new Error("voicecall gateway response missing operationId");
 	const operationId = payload.operationId;
 	const timeoutMs = typeof payload.pollTimeoutMs === "number" ? clampTimerTimeoutMs(payload.pollTimeoutMs) ?? fallbackTimeoutMs : fallbackTimeoutMs;
 	const deadlineMs = performance.now() + (clampTimerTimeoutMs(timeoutMs) ?? MAX_TIMER_TIMEOUT_MS);
 	for (;;) {
+		signal?.throwIfAborted();
 		const remainingMs = deadlineMs - performance.now();
 		if (remainingMs <= 0) break;
-		const gateway = await callVoiceCallGateway("voicecall.continue.result", { operationId }, { timeoutMs: Math.min(VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS, remainingMs) });
+		const gateway = await callVoiceCallGateway("voicecall.continue.result", { operationId }, {
+			timeoutMs: Math.min(VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS, remainingMs),
+			signal
+		});
 		if (!gateway.ok) throw new Error(`gateway unavailable while waiting for voicecall continue result: ${formatErrorMessage(gateway.error)}`);
 		const result = gateway.payload;
 		if (!isRecord(result)) throw new Error("voicecall gateway response missing operation status");
-		if (result.status === "completed") return result.result;
 		if (result.status === "failed") throw new Error(typeof result.error === "string" ? result.error : "continue failed");
-		if (result.status !== "pending") throw new Error("voicecall gateway response has unknown operation status");
+		if (result.status !== "pending" && result.status !== "completed") throw new Error("voicecall gateway response has unknown operation status");
+		signal?.throwIfAborted();
+		if (result.status === "completed") return result.result;
 		const sleepMs = Math.min(VOICE_CALL_GATEWAY_POLL_INTERVAL_MS, deadlineMs - performance.now());
 		if (sleepMs <= 0) break;
-		await sleep(sleepMs);
+		await sleepWithAbort(sleepMs, signal);
 	}
 	throw new Error("voicecall continue timed out waiting for gateway operation");
 }
@@ -265,14 +292,20 @@ async function ensureStandaloneRuntime(params) {
 	}
 }
 async function runGatewayManagerCommand(params) {
+	params.signal?.throwIfAborted();
 	const gateway = await params.gatewayCall();
+	params.signal?.throwIfAborted();
 	if (gateway.ok) {
-		writeCliJson(params.resolveGatewayPayload ? await params.resolveGatewayPayload(gateway.payload) : gateway.payload);
+		const payload = params.resolveGatewayPayload ? await params.resolveGatewayPayload(gateway.payload) : gateway.payload;
+		params.signal?.throwIfAborted();
+		writeCliJson(payload);
 		return;
 	}
 	const runtime = await ensureStandaloneRuntime(params);
+	params.signal?.throwIfAborted();
 	const result = await params.managerFallback(runtime.manager);
 	if (!result.success) throw new Error(result.error || `${params.failureLabel} failed`);
+	params.signal?.throwIfAborted();
 	writeCliJson(result);
 }
 function readGatewayCallId(payload, invalidCallIdMessage) {
@@ -305,9 +338,21 @@ async function initiateVoiceCall(params) {
 	return result.callId;
 }
 // extensions/voice-call/src/cli.ts
+const briefFileDecoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
 async function readCliBrief(options) {
 	if (options.brief && options.briefFile) throw new Error("Use either --brief or --brief-file");
-	const raw = options.briefFile ? (await readRegularFile({ filePath: await realpath(resolveUserPath(options.briefFile)) })).buffer.toString("utf8") : options.brief;
+	let raw = options.brief;
+	if (options.briefFile) {
+		const { buffer } = await readRegularFile({ filePath: await realpath(resolveUserPath(options.briefFile)) });
+		try {
+			raw = briefFileDecoder.decode(buffer);
+		} catch (error) {
+			throw new Error(`Brief file must be valid UTF-8: ${options.briefFile}. Re-save it as UTF-8 and retry.`, { cause: error });
+		}
+	}
 	if (raw === void 0) return;
 	if (raw.length > 16e3) throw new Error("Brief input is too large");
 	const value = options.briefFile || raw.trimStart().startsWith("{") || raw.trimStart().startsWith("[") ? JSON.parse(raw) : { task: raw };
@@ -375,29 +420,40 @@ function writeSetupStatus(status) {
 	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);
 }
-async function runWithStandaloneRuntime(createRuntime, run) {
+async function runWithStandaloneRuntime(createRuntime, run, interruptGateway = false) {
 	let runtime;
 	const interrupted = createDeferred();
+	const cancellation = new AbortController();
 	let exitSignal;
 	const interrupt = (signal) => {
 		exitSignal ??= signal;
 		process.exitCode = exitSignal === "SIGINT" ? 130 : 143;
+		cancellation.abort();
 		interrupted.resolve();
 	};
 	const onSigint = () => interrupt("SIGINT");
 	const onSigterm = () => interrupt("SIGTERM");
+	const listen = () => {
+		process.on("SIGINT", onSigint);
+		process.on("SIGTERM", onSigterm);
+	};
 	try {
+		if (interruptGateway) listen();
 		await run(async () => {
 			if (!runtime) {
-				process.on("SIGINT", onSigint);
-				process.on("SIGTERM", onSigterm);
+				if (!interruptGateway) listen();
 				runtime = createRuntime();
 			}
 			const active = await runtime;
-			if (exitSignal) throw new Error(`Voice call command interrupted by ${exitSignal}`);
+			if (exitSignal) {
+				if (interruptGateway) cancellation.signal.throwIfAborted();
+				throw new Error(`Voice call command interrupted by ${exitSignal}`);
+			}
 			return active;
-		});
+		}, interruptGateway ? cancellation.signal : void 0);
 		if (runtime) await interrupted.promise;
+	} catch (error) {
+		if (!interruptGateway || !cancellation.signal.aborted || !(error instanceof Error) || error.name !== "AbortError") throw error;
 	} finally {
 		try {
 			await (await runtime?.catch(() => void 0))?.stop();
@@ -496,19 +552,15 @@ function registerVoiceCallCli(params) {
 			message: options.message
 		};
 		const continueTimeoutMs = resolveContinueTimeout(config);
-		return managerAction({
-			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),
+		return runWithStandaloneRuntime(createRuntime, (ensureRuntime, signal) => runGatewayManagerCommand({
+			config,
+			ensureRuntime,
+			signal,
+			gatewayCall: () => callVoiceCallGateway("voicecall.continue.start", gatewayParams, { timeoutMs: resolveOperationTimeout(config) }),
+			resolveGatewayPayload: (payload) => pollContinueGateway(payload, continueTimeoutMs, signal),
 			managerFallback: (manager) => manager.continueCall(options.callId, options.message),
 			failureLabel: "continue"
-		});
+		}), true);
 	});
 	root.command("speak").description("Speak a message without waiting for response").requiredOption("--call-id <id>", "Call ID").requiredOption("--message <text>", "Message to speak").action((options) => managerAction({
 		gatewayCall: () => callVoiceCallGateway("voicecall.speak", {
@@ -575,11 +627,11 @@ function registerVoiceCallCli(params) {
 	});
 	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 = parseCliInteger(options.port ?? String(config.serve.port ?? 3334), "--port", {
+		const servePort = parseCliInteger(options.port ?? String(config.serve.port), "--port", {
 			min: 1,
 			max: MAX_TCP_PORT
 		});
-		const servePath = options.servePath ?? config.serve.path ?? "/voice/webhook";
+		const servePath = options.servePath ?? config.serve.path;
 		const tsPath = options.path ?? config.tailscale?.path ?? servePath;
 		const streamExposurePaths = resolveVoiceCallStreamExposurePaths(config, {
 			publicWebhookPath: tsPath,