@openclaw/voice-call 2026.9.6 → 2026.9.7

package/dist/.setup/{telnyx-BV56PXr-.mjs → telnyx-DjFGCfy1.mjs}

@@ -1,4 +1,4 @@
-import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-exU4Hutw.mjs";
+import { c as verifyTelnyxWebhook, n as readProviderCallStatus, t as guardedJsonApiRequest } from "./guarded-json-api-Bqc6QS8A.mjs";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/telnyx.ts
 function normalizeTelnyxDirection(direction) {
@@ -30,9 +30,6 @@ var TelnyxProvider = class {
 		this.publicKey = config.publicKey;
 		this.options = options;
 	}
-	/**
-	* Make an authenticated request to the Telnyx API.
-	*/
 	async apiRequest(endpoint, body, options) {
 		return await guardedJsonApiRequest({
 			url: `${this.baseUrl}${endpoint}`,
@@ -48,9 +45,6 @@ var TelnyxProvider = class {
 			errorPrefix: "Telnyx API error"
 		});
 	}
-	/**
-	* Verify Telnyx webhook signature using Ed25519.
-	*/
 	verifyWebhook(ctx) {
 		const result = verifyTelnyxWebhook(ctx, this.publicKey, { skipVerification: this.options.skipVerification });
 		return {
@@ -61,9 +55,6 @@ var TelnyxProvider = class {
 			releaseReplay: result.releaseReplay
 		};
 	}
-	/**
-	* Parse Telnyx webhook event into normalized format.
-	*/
 	parseWebhookEvent(ctx, options) {
 		try {
 			const data = JSON.parse(ctx.rawBody).data;
@@ -83,9 +74,6 @@ var TelnyxProvider = class {
 			};
 		}
 	}
-	/**
-	* Convert Telnyx event to normalized event format.
-	*/
 	normalizeEvent(data, dedupeKey) {
 		let callId = "";
 		if (data.payload?.client_state) callId = decodeClientStateBase64(data.payload.client_state) ?? data.payload.client_state;
@@ -190,9 +178,6 @@ var TelnyxProvider = class {
 			status: "initiated"
 		};
 	}
-	/**
-	* Hang up a call via Telnyx API.
-	*/
 	async hangupCall(input) {
 		await this.apiRequest(`/calls/${input.providerCallId}/actions/hangup`, { command_id: crypto.randomUUID() }, { allowNotFound: true });
 	}
@@ -203,9 +188,6 @@ var TelnyxProvider = class {
 		};
 		await this.apiRequest(`/calls/${input.providerCallId}/actions/answer`, body);
 	}
-	/**
-	* Play TTS audio via Telnyx speak action.
-	*/
 	async playTts(input) {
 		await this.apiRequest(`/calls/${input.providerCallId}/actions/speak`, {
 			command_id: crypto.randomUUID(),
@@ -214,57 +196,39 @@ var TelnyxProvider = class {
 			language: input.locale || "en-US"
 		});
 	}
-	/**
-	* Start transcription (STT) via Telnyx.
-	*/
 	async startListening(input) {
 		await this.apiRequest(`/calls/${input.providerCallId}/actions/transcription_start`, {
 			command_id: crypto.randomUUID(),
 			language: input.language || "en"
 		});
 	}
-	/**
-	* Stop transcription via Telnyx.
-	*/
 	async stopListening(input) {
 		await this.apiRequest(`/calls/${input.providerCallId}/actions/transcription_stop`, { command_id: crypto.randomUUID() }, { allowNotFound: true });
 	}
 	async getCallStatus(input) {
-		try {
-			const data = await guardedJsonApiRequest({
-				url: `${this.baseUrl}/calls/${input.providerCallId}`,
-				method: "GET",
-				headers: {
-					Authorization: `Bearer ${this.apiKey}`,
-					"Content-Type": "application/json"
-				},
-				allowNotFound: true,
-				allowedHostnames: [this.apiHost],
-				auditContext: "telnyx-get-call-status",
-				errorPrefix: "Telnyx get call status error"
-			});
-			if (!data) return {
-				status: "not-found",
-				isTerminal: true
-			};
-			const state = data.data?.state ?? "unknown";
+		return readProviderCallStatus(() => guardedJsonApiRequest({
+			url: `${this.baseUrl}/calls/${input.providerCallId}`,
+			method: "GET",
+			headers: {
+				Authorization: `Bearer ${this.apiKey}`,
+				"Content-Type": "application/json"
+			},
+			allowNotFound: true,
+			allowedHostnames: [this.apiHost],
+			auditContext: "telnyx-get-call-status",
+			errorPrefix: "Telnyx get call status error"
+		}), (data) => {
+			const status = data.data?.state ?? "unknown";
 			const isAlive = data.data?.is_alive;
-			if (isAlive === void 0) return {
-				status: state,
+			return isAlive === void 0 ? {
+				status,
 				isTerminal: false,
 				isUnknown: true
-			};
-			return {
-				status: state,
+			} : {
+				status,
 				isTerminal: !isAlive
 			};
-		} catch {
-			return {
-				status: "error",
-				isTerminal: false,
-				isUnknown: true
-			};
-		}
+		});
 	}
 };
 function buildTelnyxStreamingFields(streamUrl, streamAuthToken) {

package/dist/.setup/{twilio-BMb-7cu-.mjs → twilio-Bp3gfmUB.mjs}

@@ -1,8 +1,7 @@
-import { fetchWithSsrFGuard } from "../runtime-api.js";
-import "../api.js";
+import { fetchWithSsrFGuard } from "../api.js";
 import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-4fkgz3UG.mjs";
-import { a as normalizeProviderStatus, b as escapeXml, h as chunkAudio, i as mapProviderStatusToEndReason, l as getHeader, r as isProviderStatusTerminal, x as mapVoiceToPolly } from "./runtime-entry-dDRm6RgA.mjs";
-import { c as verifyTwilioWebhook, i as readVoiceCallProviderJsonResponse, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-exU4Hutw.mjs";
+import { a as normalizeProviderStatus, b as mapVoiceToPolly, h as chunkAudio, i as mapProviderStatusToEndReason, l as getHeader, r as isProviderStatusTerminal, y as escapeXml } from "./runtime-entry-BNOQRXii.mjs";
+import { a as readVoiceCallProviderJsonResponse, i as readProviderErrorResponseSnippet, l as verifyTwilioWebhook, n as readProviderCallStatus, r as cancelProviderResponseBody, t as guardedJsonApiRequest } from "./guarded-json-api-Bqc6QS8A.mjs";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
@@ -75,10 +74,6 @@ async function twilioApiRequest(params) {
 }
 //#endregion
 //#region extensions/voice-call/src/providers/twilio/twiml-policy.ts
-/** Return true for Twilio outbound call directions. */
-function isOutboundDirection(direction) {
-	return direction?.startsWith("outbound") ?? false;
-}
 /** Read the Twilio request fields needed by TwiML decision logic. */
 function readTwimlRequestView(ctx) {
 	const params = new URLSearchParams(ctx.rawBody);
@@ -95,23 +90,17 @@ function readTwimlRequestView(ctx) {
 /** Decide the TwiML response kind for a Twilio webhook request. */
 function decideTwimlResponse(input) {
 	if (input.callIdFromQuery && !input.isStatusCallback) {
-		if (input.hasStoredTwiml) return {
-			kind: "stored",
-			consumeStoredTwimlCallId: input.callIdFromQuery
-		};
-		if (isOutboundDirection(input.direction)) return input.canStream ? { kind: "stream" } : { kind: "pause" };
+		if (input.hasStoredTwiml) return "stored";
+		if (input.direction?.startsWith("outbound")) return input.canStream ? "stream" : "pause";
 	}
-	if (input.isStatusCallback) return { kind: "empty" };
+	if (input.isStatusCallback) return "empty";
 	if (input.direction === "inbound") {
-		if (input.hasActiveStreams) return { kind: "queue" };
-		if (input.canStream && input.callSid) return {
-			kind: "stream",
-			activateStreamCallSid: input.callSid
-		};
-		return { kind: "pause" };
+		if (input.hasActiveStreams) return "queue";
+		if (input.canStream && input.callSid) return "stream";
+		return "pause";
 	}
-	if (input.callStatus !== "in-progress") return { kind: "empty" };
-	return input.canStream ? { kind: "stream" } : { kind: "pause" };
+	if (input.callStatus !== "in-progress") return "empty";
+	return input.canStream ? "stream" : "pause";
 }
 //#endregion
 //#region extensions/voice-call/src/providers/twilio/webhook.ts
@@ -155,15 +144,6 @@ function createTwilioRequestDedupeKey(ctx, verifiedRequestKey) {
 	return `twilio:fallback:${crypto.createHash("sha256").update(`${signature}\n${callSid}\n${callStatus}\n${direction}\n${callId}\n${flow}\n${turnToken}\n${ctx.rawBody}`).digest("hex")}`;
 }
 var TwilioProvider = class TwilioProvider {
-	/**
-	* Delete stored TwiML for a given `callId`.
-	*
-	* We keep TwiML in-memory only long enough to satisfy the initial Twilio
-	* webhook request before streaming. Subsequent webhooks should not reuse it.
-	*/
-	deleteStoredTwiml(callId) {
-		this.twimlStorage.delete(callId);
-	}
 	/**
 	* Release all process-local metadata owned by one Twilio call.
 	* Terminal webhooks can be replayed, so this must stay idempotent.
@@ -174,7 +154,7 @@ var TwilioProvider = class TwilioProvider {
 		if (!resolvedCallId && webhookUrl) try {
 			resolvedCallId = new URL(webhookUrl).searchParams.get("callId") || void 0;
 		} catch {}
-		if (resolvedCallId) this.deleteStoredTwiml(resolvedCallId);
+		if (resolvedCallId) this.twimlStorage.delete(resolvedCallId);
 		this.callWebhookUrls.delete(providerCallId);
 		this.callStreamMap.delete(providerCallId);
 		this.streamAuthTokens.delete(providerCallId);
@@ -246,9 +226,6 @@ var TwilioProvider = class TwilioProvider {
 		if (!streamSid || !this.mediaStreamHandler) return;
 		this.mediaStreamHandler.clearTtsQueue(streamSid, reason);
 	}
-	/**
-	* Make an authenticated request to the Twilio API.
-	*/
 	async apiRequest(endpoint, params, options) {
 		return await twilioApiRequest({
 			baseUrl: this.baseUrl,
@@ -287,9 +264,6 @@ var TwilioProvider = class TwilioProvider {
 			options: this.options
 		});
 	}
-	/**
-	* Parse Twilio webhook event into normalized format.
-	*/
 	parseWebhookEvent(ctx, options) {
 		try {
 			const params = new URLSearchParams(ctx.rawBody);
@@ -316,9 +290,6 @@ var TwilioProvider = class TwilioProvider {
 			};
 		}
 	}
-	/**
-	* Parse Twilio direction to normalized format.
-	*/
 	static parseDirection(direction) {
 		if (direction === "inbound") return "inbound";
 		if (direction === "outbound-api" || direction === "outbound-dial") return "outbound";
@@ -328,9 +299,6 @@ var TwilioProvider = class TwilioProvider {
 		if (!trimmed || !/^\d+(?:\.\d+)?$/.test(trimmed)) return .9;
 		return Number(trimmed);
 	}
-	/**
-	* Convert Twilio webhook params to normalized event format.
-	*/
 	normalizeEvent(params, options) {
 		const callSid = params.get("CallSid") || "";
 		const callIdOverride = options?.callIdOverride;
@@ -408,15 +376,15 @@ var TwilioProvider = class TwilioProvider {
 		if (!ctx) return TwilioProvider.EMPTY_TWIML;
 		const view = readTwimlRequestView(ctx);
 		const storedTwiml = view.callIdFromQuery ? this.twimlStorage.get(view.callIdFromQuery) : void 0;
-		const decision = decideTwimlResponse({
+		switch (decideTwimlResponse({
 			...view,
 			hasStoredTwiml: Boolean(storedTwiml),
 			hasActiveStreams: this.activeStreamCalls.size > 0,
 			canStream: Boolean(view.callSid && this.getStreamUrl())
-		});
-		if (decision.consumeStoredTwimlCallId) this.deleteStoredTwiml(decision.consumeStoredTwimlCallId);
-		switch (decision.kind) {
-			case "stored": return storedTwiml ?? TwilioProvider.EMPTY_TWIML;
+		})) {
+			case "stored":
+				if (view.callIdFromQuery) this.twimlStorage.delete(view.callIdFromQuery);
+				return storedTwiml ?? TwilioProvider.EMPTY_TWIML;
 			case "queue": return TwilioProvider.QUEUE_TWIML;
 			case "pause": return TwilioProvider.PAUSE_TWIML;
 			case "stream": {
@@ -431,7 +399,7 @@ var TwilioProvider = class TwilioProvider {
 		if (!view.callIdFromQuery || view.isStatusCallback) return null;
 		const storedTwiml = this.twimlStorage.get(view.callIdFromQuery);
 		if (!storedTwiml) return null;
-		this.deleteStoredTwiml(view.callIdFromQuery);
+		this.twimlStorage.delete(view.callIdFromQuery);
 		console.log(`[voice-call] Twilio initial TwiML consumed for call ${view.callIdFromQuery} (kind=pre-connect, callSid=${view.callSid ?? "unknown"})`);
 		return storedTwiml;
 	}
@@ -516,9 +484,6 @@ var TwilioProvider = class TwilioProvider {
 			status: result.status === "queued" ? "queued" : "initiated"
 		};
 	}
-	/**
-	* Hang up a call via Twilio API.
-	*/
 	async hangupCall(input) {
 		await this.apiRequest(`/Calls/${input.providerCallId}.json`, { Status: "completed" }, { allowNotFound: true });
 		this.releaseCallState(input.providerCallId, input.callId);
@@ -621,7 +586,7 @@ var TwilioProvider = class TwilioProvider {
 			for (const chunk of chunkAudio(muLawAudio, CHUNK_SIZE)) {
 				if (signal.aborted) break;
 				chunkAttempts += 1;
-				if (!handler.sendAudio(streamSid, chunk).sent) {
+				if (!handler.sendAudio(streamSid, chunk)) {
 					handler.clearAudio(streamSid);
 					throw new Error(`Telephony stream playback failed: audio chunk ${chunkAttempts} not delivered`);
 				}
@@ -642,9 +607,6 @@ var TwilioProvider = class TwilioProvider {
 			await handler.sendMarkAndWait(streamSid, markName, muLawAudio.length / 8, signal);
 		});
 	}
-	/**
-	* Start listening for speech via Twilio <Gather>.
-	*/
 	async startListening(input) {
 		const webhookUrl = this.callWebhookUrls.get(input.providerCallId);
 		if (!webhookUrl) throw new Error("Missing webhook URL for this call (provider state not initialized)");
@@ -662,32 +624,21 @@ var TwilioProvider = class TwilioProvider {
 	*/
 	async stopListening(_input) {}
 	async getCallStatus(input) {
-		try {
-			const data = await guardedJsonApiRequest({
-				url: `${this.baseUrl}/Calls/${input.providerCallId}.json`,
-				method: "GET",
-				headers: { Authorization: `Basic ${Buffer.from(`${this.accountSid}:${this.authToken}`).toString("base64")}` },
-				allowNotFound: true,
-				allowedHostnames: [new URL(this.baseUrl).hostname],
-				auditContext: "twilio-get-call-status",
-				errorPrefix: "Twilio get call status error"
-			});
-			if (!data) return {
-				status: "not-found",
-				isTerminal: true
-			};
+		return readProviderCallStatus(() => guardedJsonApiRequest({
+			url: `${this.baseUrl}/Calls/${input.providerCallId}.json`,
+			method: "GET",
+			headers: { Authorization: `Basic ${Buffer.from(`${this.accountSid}:${this.authToken}`).toString("base64")}` },
+			allowNotFound: true,
+			allowedHostnames: [new URL(this.baseUrl).hostname],
+			auditContext: "twilio-get-call-status",
+			errorPrefix: "Twilio get call status error"
+		}), (data) => {
 			const status = normalizeProviderStatus(data.status);
 			return {
 				status,
 				isTerminal: isProviderStatusTerminal(status)
 			};
-		} catch {
-			return {
-				status: "error",
-				isTerminal: false,
-				isUnknown: true
-			};
-		}
+		});
 	}
 };
 //#endregion

package/dist/.setup/{store-path-B1j1up4_.mjs → utils-B5pnM_Ij.mjs}

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+import os from "node:os";
 //#region extensions/voice-call/src/types.ts
 const ProviderNameSchema = z.enum([
 	"telnyx",
@@ -373,11 +374,6 @@ async function loadActiveCallsFromStore(storePath, stateRuntime) {
 	} catch (err) {
 		console.error("[voice-call] Failed to read SQLite call records:", err);
 	}
-	if (calls.length === 0) return {
-		activeCalls: /* @__PURE__ */ new Map(),
-		providerCallIdMap: /* @__PURE__ */ new Map(),
-		processedEventIds: /* @__PURE__ */ new Set()
-	};
 	const callMap = /* @__PURE__ */ new Map();
 	for (const call of calls) {
 		callMap.delete(call.callId);
@@ -426,4 +422,16 @@ function resolveDefaultVoiceCallStoreDir(env = process.env) {
 	return path.join(resolveStateDir(env), "voice-calls");
 }
 //#endregion
-export { releaseRejectedProviderCall as _, CALL_RECORD_EVENT_META_MAX_ENTRIES as a, setVoiceCallStateRuntime as b, buildVoiceCallLegacyJsonlEventKey as c, getCallHistoryFromStore as d, loadActiveCallsFromStore as f, appendCallReplayKey as g, resolveVoiceCallLegacyCallLogPath as h, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as i, encodeCallRecordEvent as l, persistCallRecord as m, CALL_RECORD_CHUNK_MAX_ENTRIES as n, MAX_CALL_RECORD_EVENTS as o, parseVoiceCallRecordLine as p, CALL_RECORD_EVENTS_NAMESPACE as r, buildChunkKey as s, resolveDefaultVoiceCallStoreDir as t, findCallInStore as u, rememberManagerReplayKey as v, TerminalStates as x, reserveRejectedProviderCall as y };
+//#region extensions/voice-call/src/utils.ts
+/** Runtime uses the OS home; Doctor supplies the home from its migration environment. */
+function resolveUserPath(input, homedir = os.homedir) {
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = trimmed.replace(/^~(?=$|[\\/])/, homedir);
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+//#endregion
+export { TerminalStates as S, appendCallReplayKey as _, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as a, reserveRejectedProviderCall as b, buildChunkKey as c, findCallInStore as d, getCallHistoryFromStore as f, resolveVoiceCallLegacyCallLogPath as g, persistCallRecord as h, CALL_RECORD_EVENTS_NAMESPACE as i, buildVoiceCallLegacyJsonlEventKey as l, parseVoiceCallRecordLine as m, resolveDefaultVoiceCallStoreDir as n, CALL_RECORD_EVENT_META_MAX_ENTRIES as o, loadActiveCallsFromStore as p, CALL_RECORD_CHUNK_MAX_ENTRIES as r, MAX_CALL_RECORD_EVENTS as s, resolveUserPath as t, encodeCallRecordEvent as u, releaseRejectedProviderCall as v, setVoiceCallStateRuntime as x, rememberManagerReplayKey as y };

package/dist/api.js

@@ -1,2 +1,6 @@
-import { TtsAutoSchema, TtsConfigSchema, TtsModeSchema, TtsProviderSchema, definePluginEntry, fetchWithSsrFGuard, isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, sendHttpRequestRejection, sleep } from "./runtime-api.js";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, sendHttpRequestRejection } from "openclaw/plugin-sdk/webhook-request-guards";
+import { fetchWithSsrFGuard, isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
+import { TtsAutoSchema, TtsConfigSchema, TtsModeSchema, TtsProviderSchema } from "openclaw/plugin-sdk/tts-runtime";
+import { sleep } from "openclaw/plugin-sdk/runtime-env";
 export { TtsAutoSchema, TtsConfigSchema, TtsModeSchema, TtsProviderSchema, definePluginEntry, fetchWithSsrFGuard, isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, sendHttpRequestRejection, sleep };

package/dist/doctor-contract-api.js

@@ -1,23 +1,194 @@
-import { a as CALL_RECORD_EVENT_META_MAX_ENTRIES, c as buildVoiceCallLegacyJsonlEventKey, h as resolveVoiceCallLegacyCallLogPath, i as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, l as encodeCallRecordEvent, n as CALL_RECORD_CHUNK_MAX_ENTRIES, o as MAX_CALL_RECORD_EVENTS, p as parseVoiceCallRecordLine, r as CALL_RECORD_EVENTS_NAMESPACE, s as buildChunkKey, t as resolveDefaultVoiceCallStoreDir } from "./.setup/store-path-B1j1up4_.mjs";
+import { a as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, c as buildChunkKey, g as resolveVoiceCallLegacyCallLogPath, i as CALL_RECORD_EVENTS_NAMESPACE, l as buildVoiceCallLegacyJsonlEventKey, m as parseVoiceCallRecordLine, n as resolveDefaultVoiceCallStoreDir, o as CALL_RECORD_EVENT_META_MAX_ENTRIES, r as CALL_RECORD_CHUNK_MAX_ENTRIES, s as MAX_CALL_RECORD_EVENTS, t as resolveUserPath, u as encodeCallRecordEvent } from "./.setup/utils-B5pnM_Ij.mjs";
+import "node:module";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { existsSync } from "node:fs";
-import path from "node:path";
 import os from "node:os";
 import fs$1 from "node:fs/promises";
-import { archiveLegacyStateSource } from "openclaw/plugin-sdk/runtime-doctor-migrations";
-//#region extensions/voice-call/doctor-contract-api.ts
-/** Resolve home from doctor env with OS fallback. */
-function resolveHome(env) {
-	return env.HOME?.trim() || os.homedir();
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-/** Resolve config paths, including "~", against the doctor env home. */
-function resolveUserPath(input, env) {
-	const trimmed = input.trim();
-	if (!trimmed) return trimmed;
-	if (trimmed.startsWith("~")) return path.resolve(trimmed.replace(/^~(?=$|[\\/])/, () => resolveHome(env)));
-	return path.resolve(trimmed);
+/** Returns a non-array record or null. */
+function asNullableRecord$1(value) {
+	return isRecord$1(value) ? value : null;
+}
+//#endregion
+//#region src/config/channel-config-normalization.ts
+/** Applies one channel-specific doctor migration to every object-shaped account. */
+function normalizeChannelAccounts(params) {
+	const rawAccounts = asNullableRecord$1(params.entry.accounts);
+	if (!rawAccounts) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const accounts = { ...rawAccounts };
+	for (const [accountId, value] of Object.entries(rawAccounts)) {
+		const account = asNullableRecord$1(value);
+		if (!account) continue;
+		const normalized = params.normalizeAccount({
+			account,
+			accountId,
+			pathPrefix: `${params.pathPrefix}.accounts.${accountId}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			accounts[accountId] = normalized.entry;
+			changed = true;
+		}
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			accounts
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
 }
+/** Applies the same channel-specific doctor migration at root and account scope. */
+function normalizeChannelConfigEntries(params) {
+	const changes = params.changes ?? [];
+	const channels = params.cfg.channels;
+	const entry = asNullableRecord$1(channels?.[params.channelId]);
+	if (!entry) return {
+		config: params.cfg,
+		changes
+	};
+	const channelPath = `channels.${params.channelId}`;
+	const root = params.normalizeEntry({
+		entry,
+		pathPrefix: channelPath,
+		changes
+	});
+	const accounts = normalizeChannelAccounts({
+		entry: root.entry,
+		pathPrefix: channelPath,
+		changes,
+		normalizeAccount: (accountParams) => params.normalizeEntry({
+			entry: accountParams.account,
+			accountId: accountParams.accountId,
+			pathPrefix: accountParams.pathPrefix,
+			changes: accountParams.changes
+		})
+	});
+	if (!root.changed && !accounts.changed) return {
+		config: params.cfg,
+		changes
+	};
+	return {
+		config: {
+			...params.cfg,
+			channels: {
+				...channels,
+				[params.channelId]: accounts.entry
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region src/plugin-sdk/legacy-webhook-listener-migration.ts
+/** Preserve explicitly configured webhook listeners while moving ingress onto Gateway routes. */
+function createLegacyWebhookListenerDoctorContract(params) {
+	const portKey = params.portKey ?? "webhookPort";
+	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
+	const source = (entry) => params.webhookKey ? asNullableRecord$1(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord$1(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		legacyConfigRules: [{
+			path: ["channels", params.channelKey],
+			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
+			match: (value) => {
+				const accounts = asNullableRecord$1(asNullableRecord$1(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord$1(asNullableRecord$1(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord$1(root?.legacyWebhook);
+			return normalizeChannelConfigEntries({
+				cfg,
+				channelId: params.channelKey,
+				normalizeEntry: ({ entry, accountId, pathPrefix, changes }) => {
+					const listener = source(entry);
+					if (!listener || !hasLegacy(entry)) return {
+						entry,
+						changed: false
+					};
+					const next = { ...entry };
+					const port = Object.hasOwn(listener, portKey) ? listener[portKey] : (accountId ? canonicalRoot?.port ?? inherited?.[portKey] : void 0) ?? params.defaultPort;
+					const inheritedHost = accountId ? canonicalRoot ? canonicalRoot.host : (hostKey ? inherited?.[hostKey] : void 0) ?? params.defaultHost : params.defaultHost;
+					const host = hostKey ? listener[hostKey] ?? inheritedHost : inheritedHost;
+					const legacyPath = [pathPrefix, params.webhookKey].filter(Boolean).join(".");
+					if (Object.hasOwn(entry, "legacyWebhook")) changes.push(`Removed ${legacyPath} legacy listener keys; ${pathPrefix}.legacyWebhook is already configured.`);
+					else if (accountId && root?.legacyWebhook === false) changes.push(`Removed ${legacyPath} legacy listener keys; ${prefix}.legacyWebhook: false keeps this account's inherited listener disabled.`);
+					else {
+						next.legacyWebhook = {
+							port,
+							...host !== void 0 ? { host } : {}
+						};
+						changes.push(`Moved ${legacyPath} listener settings to ${pathPrefix}.legacyWebhook. Point the external callback or reverse proxy at the Gateway port and webhook path, verify delivery, then set legacyWebhook: false to disable legacy forwarding.`);
+					}
+					const updated = params.webhookKey ? { ...listener } : next;
+					delete updated[portKey];
+					if (hostKey) delete updated[hostKey];
+					if (params.webhookKey) {
+						if (Object.keys(updated).length) next[params.webhookKey] = updated;
+						else delete next[params.webhookKey];
+					}
+					return {
+						entry: next,
+						changed: true
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/runtime-doctor-migrations
+var runtime_doctor_migrations_exports = /* @__PURE__ */ __exportAll({ createLegacyWebhookListenerDoctorContract: () => createLegacyWebhookListenerDoctorContract });
+import * as import_openclaw_plugin_sdk_runtime_doctor_migrations from "openclaw/plugin-sdk/runtime-doctor-migrations";
+__reExport(runtime_doctor_migrations_exports, import_openclaw_plugin_sdk_runtime_doctor_migrations);
+//#endregion
+//#region extensions/voice-call/doctor-contract-api.ts
 /** Read the configured voice-call store path from either package id. */
 function getVoiceCallConfigStore(config) {
 	for (const pluginId of ["voice-call", "@openclaw/voice-call"]) {
@@ -48,7 +219,7 @@ function resolveSessionStoreAgentIds(params) {
 /** Resolve the voice-call store path used by legacy and plugin-state call records. */
 function resolveVoiceCallStorePath(params) {
 	const configuredStore = getVoiceCallConfigStore(params.config);
-	if (configuredStore) return resolveUserPath(configuredStore, params.env);
+	if (configuredStore) return resolveUserPath(configuredStore, () => params.env.HOME?.trim() || os.homedir());
 	return resolveDefaultVoiceCallStoreDir(params.env);
 }
 function resolveVoiceCallStateDatabaseEnv(params) {
@@ -226,7 +397,7 @@ const stateMigrations = [{
 				warnings
 			};
 		}
-		await archiveLegacyStateSource({
+		await (0, runtime_doctor_migrations_exports.archiveLegacyStateSource)({
 			filePath,
 			label: "Voice Call call-log",
 			changes,