@openclaw/voice-call 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/state-retention-api-ONgqE-_V.mjs

@@ -0,0 +1,201 @@
+import { n as resolveVoiceCallStorePath } from "./store-path-Cfwff6j7.mjs";
+import path from "node:path";
+//#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(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord(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(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(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(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(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		historicalWebhookListener: {
+			channelId: params.channelKey,
+			port: params.defaultPort,
+			preserveAuthoredActivation: params.preserveAuthoredActivation,
+			...params.defaultHost === void 0 ? {} : { host: params.defaultHost }
+		},
+		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(asNullableRecord(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord(asNullableRecord(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord(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/state-retention-api.ts
+const packageName = "@openclaw/voice-call";
+const stateMigrations = [(0, runtime_doctor_migrations_exports.defineRetiredPluginStateMigration)({
+	id: "voice-call-calls-jsonl-to-plugin-state",
+	label: "Voice Call JSONL call log",
+	intermediateVersion: "2026.9.7",
+	findSources: (input) => [path.join(resolveVoiceCallStorePath(input), "calls.jsonl")]
+})];
+//#endregion
+export { stateMigrations as n, packageName as t };

package/dist/.setup/store-path-Cfwff6j7.mjs

@@ -0,0 +1,33 @@
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+//#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;
+	return path.resolve(trimmed.replace(/^~(?=$|[\\/])/, homedir));
+}
+//#endregion
+//#region extensions/voice-call/src/store-path.ts
+/** Resolve the plugin-owned store below OpenClaw's canonical state directory. */
+function resolveDefaultVoiceCallStoreDir(env = process.env) {
+	return path.join(resolveStateDir(env), "voice-calls");
+}
+/** Read the configured voice-call store path from either package id. */
+function getVoiceCallConfigStore(config) {
+	for (const pluginId of ["voice-call", "@openclaw/voice-call"]) {
+		const store = asOptionalRecord(config.plugins?.entries?.[pluginId]?.config)?.store;
+		if (typeof store === "string" && store.trim()) return store.trim();
+	}
+	return "";
+}
+/** 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.HOME?.trim() || os.homedir());
+	return resolveDefaultVoiceCallStoreDir(params.env);
+}
+//#endregion
+export { resolveVoiceCallStorePath as n, resolveUserPath as r, resolveDefaultVoiceCallStoreDir as t };

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

@@ -1,14 +1,9 @@
-import { c as verifyTelnyxWebhook, n as readProviderCallStatus, t as guardedJsonApiRequest } from "./guarded-json-api-Bqc6QS8A.mjs";
+import { a as verifyTelnyxWebhook, n as readProviderCallStatus, t as guardedJsonApiRequest } from "./guarded-json-api-x55yqHvW.mjs";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/telnyx.ts
 function normalizeTelnyxDirection(direction) {
-	switch (direction) {
-		case "incoming":
-		case "inbound": return "inbound";
-		case "outgoing":
-		case "outbound": return "outbound";
-		default: return;
-	}
+	if (direction === "incoming" || direction === "inbound") return "inbound";
+	if (direction === "outgoing" || direction === "outbound") return "outbound";
 }
 function normalizeBase64ForCompare(value) {
 	return value.replace(/=+$/u, "").replace(/-/gu, "+").replace(/_/gu, "/");
@@ -46,14 +41,7 @@ var TelnyxProvider = class {
 		});
 	}
 	verifyWebhook(ctx) {
-		const result = verifyTelnyxWebhook(ctx, this.publicKey, { skipVerification: this.options.skipVerification });
-		return {
-			ok: result.ok,
-			reason: result.reason,
-			isReplay: result.isReplay,
-			verifiedRequestKey: result.verifiedRequestKey,
-			releaseReplay: result.releaseReplay
-		};
+		return verifyTelnyxWebhook(ctx, this.publicKey, { skipVerification: this.options.skipVerification });
 	}
 	parseWebhookEvent(ctx, options) {
 		try {
@@ -89,17 +77,11 @@ var TelnyxProvider = class {
 			to: data.payload?.to
 		};
 		switch (data.event_type) {
-			case "call.initiated": return {
-				...baseEvent,
-				type: "call.initiated"
-			};
-			case "call.ringing": return {
-				...baseEvent,
-				type: "call.ringing"
-			};
+			case "call.initiated":
+			case "call.ringing":
 			case "call.answered": return {
 				...baseEvent,
-				type: "call.answered"
+				type: data.event_type
 			};
 			case "call.bridged": return {
 				...baseEvent,
@@ -131,8 +113,6 @@ var TelnyxProvider = class {
 				type: "call.dtmf",
 				digits: data.payload?.digit || ""
 			};
-			case "streaming.started":
-			case "streaming.stopped": return null;
 			default: return null;
 		}
 	}
@@ -171,7 +151,7 @@ var TelnyxProvider = class {
 			webhook_url_method: "POST",
 			client_state: Buffer.from(input.callId).toString("base64"),
 			timeout_secs: 30,
-			...input.streamUrl ? buildTelnyxStreamingFields(input.streamUrl, input.streamAuthToken) : {}
+			...buildTelnyxStreamingFields(input.streamUrl, input.streamAuthToken)
 		};
 		return {
 			providerCallId: (await this.apiRequest("/calls", body)).data.call_control_id,
@@ -184,7 +164,7 @@ var TelnyxProvider = class {
 	async answerCall(input) {
 		const body = {
 			command_id: `openclaw-answer-${input.callId}`,
-			...input.streamUrl ? buildTelnyxStreamingFields(input.streamUrl, input.streamAuthToken) : {}
+			...buildTelnyxStreamingFields(input.streamUrl, input.streamAuthToken)
 		};
 		await this.apiRequest(`/calls/${input.providerCallId}/actions/answer`, body);
 	}
@@ -232,6 +212,7 @@ var TelnyxProvider = class {
 	}
 };
 function buildTelnyxStreamingFields(streamUrl, streamAuthToken) {
+	if (!streamUrl) return {};
 	return {
 		stream_url: streamUrl,
 		stream_track: "inbound_track",