@openclaw/voice-call 2026.9.4 → 2026.9.6

package/dist/{store-path-M0GXxUfv.js → .setup/store-path-B1j1up4_.mjs}

@@ -114,9 +114,12 @@ const CALL_RECORD_EVENT_CHUNKS_NAMESPACE = "call-record-event-chunks";
 const MAX_CALL_RECORD_EVENTS = 1e3;
 /** Extra metadata entries retained so pruning can safely trim oldest rows. */
 const CALL_RECORD_EVENT_META_MAX_ENTRIES = 1100;
+/** Maximum chunks allowed for one persisted call record event. */
+const MAX_CHUNKS_PER_CALL_RECORD_EVENT = 48;
 const CALL_RECORD_CHUNK_MAX_ENTRIES = 48048;
 /** Raw UTF-8 bytes stored per call record chunk before base64 encoding. */
 const RAW_CALL_RECORD_CHUNK_BYTES = 48128;
+const CALL_RECORD_READ_BATCH_KEYS = 128;
 let callRecordEventSequence = 0;
 /** Return the pre-SQLite JSONL call log path for migration/compat checks. */
 function resolveVoiceCallLegacyCallLogPath(storePath) {
@@ -130,17 +133,17 @@ function resolvePluginStateEnv(storePath) {
 	};
 }
 /** Open the plugin state stores when the runtime is available. */
-function createCallRecordStateStores(storePath) {
-	const runtime = getOptionalVoiceCallStateRuntime();
+function createCallRecordStateStores(storePath, stateRuntime) {
+	const runtime = stateRuntime ? { state: stateRuntime } : getOptionalVoiceCallStateRuntime();
 	if (!runtime) throw new Error("Voice Call state runtime not initialized");
 	const env = resolvePluginStateEnv(storePath);
 	return {
-		events: runtime.state.openSyncKeyedStore({
+		events: runtime.state.openKeyedStore({
 			namespace: CALL_RECORD_EVENTS_NAMESPACE,
 			maxEntries: CALL_RECORD_EVENT_META_MAX_ENTRIES,
 			env
 		}),
-		chunks: runtime.state.openSyncKeyedStore({
+		chunks: runtime.state.openKeyedStore({
 			namespace: CALL_RECORD_EVENT_CHUNKS_NAMESPACE,
 			maxEntries: CALL_RECORD_CHUNK_MAX_ENTRIES,
 			env
@@ -148,9 +151,9 @@ function createCallRecordStateStores(storePath) {
 	};
 }
 /** Open call stores and log failures instead of breaking restore paths. */
-function tryCreateCallRecordStateStores(storePath) {
+function tryCreateCallRecordStateStores(storePath, stateRuntime) {
 	try {
-		return createCallRecordStateStores(storePath);
+		return createCallRecordStateStores(storePath, stateRuntime);
 	} catch (err) {
 		console.error("[voice-call] Failed to open SQLite call record store:", err);
 		return null;
@@ -220,7 +223,7 @@ function prepareVoiceCallRecordForStorage(call) {
 		};
 		trimCallReplayKeys(boundedCall.processedEventIds);
 	}
-	if (countCallRecordChunks(boundedCall) <= 48) return boundedCall;
+	if (countCallRecordChunks(boundedCall) <= MAX_CHUNKS_PER_CALL_RECORD_EVENT) return boundedCall;
 	const transcriptEntries = boundedCall.transcript.length;
 	const metadata = {
 		...boundedCall.metadata,
@@ -252,88 +255,121 @@ function prepareVoiceCallRecordForStorage(call) {
 			...boundedCall,
 			...candidateInput
 		});
-		if (countCallRecordChunks(candidate) <= 48) return candidate;
+		if (countCallRecordChunks(candidate) <= MAX_CHUNKS_PER_CALL_RECORD_EVENT) return candidate;
 	}
 	return boundedCall;
 }
-/** Register a serialized call record event and its chunks, then prune old events. */
-function registerCallRecordEvent(stores, eventKey, call, order) {
+/** Encode one bounded record; chunks are produced only when requested by the writer. */
+function encodeCallRecordEvent(call) {
 	const serialized = JSON.stringify(prepareVoiceCallRecordForStorage(call));
 	const buffer = Buffer.from(serialized, "utf8");
 	const chunkCount = Math.max(1, Math.ceil(buffer.byteLength / RAW_CALL_RECORD_CHUNK_BYTES));
-	if (chunkCount > 48) throw new Error(`voice-call record exceeds SQLite chunk limit (${chunkCount}/48)`);
-	for (let index = 0; index < chunkCount; index += 1) {
-		const chunk = buffer.subarray(index * RAW_CALL_RECORD_CHUNK_BYTES, (index + 1) * RAW_CALL_RECORD_CHUNK_BYTES);
-		stores.chunks.register(buildChunkKey(eventKey, index), {
-			index,
-			dataBase64: chunk.toString("base64")
-		});
-	}
-	stores.events.register(eventKey, {
-		chunkCount,
-		byteLength: buffer.byteLength,
-		persistedAt: order?.persistedAt,
-		sequence: order?.sequence
+	if (chunkCount > MAX_CHUNKS_PER_CALL_RECORD_EVENT) throw new Error(`voice-call record exceeds SQLite chunk limit (${chunkCount}/${MAX_CHUNKS_PER_CALL_RECORD_EVENT})`);
+	return {
+		meta: {
+			chunkCount,
+			byteLength: buffer.byteLength
+		},
+		chunk(index) {
+			return {
+				index,
+				dataBase64: buffer.subarray(index * RAW_CALL_RECORD_CHUNK_BYTES, (index + 1) * RAW_CALL_RECORD_CHUNK_BYTES).toString("base64")
+			};
+		}
+	};
+}
+/** Register a serialized call record event and its chunks, then prune old events. */
+async function registerCallRecordEvent(stores, eventKey, call, order) {
+	const encoded = encodeCallRecordEvent(call);
+	for (let index = 0; index < encoded.meta.chunkCount; index += 1) await stores.chunks.register(buildChunkKey(eventKey, index), encoded.chunk(index));
+	await stores.events.register(eventKey, {
+		...encoded.meta,
+		persistedAt: order.persistedAt,
+		sequence: order.sequence
 	});
-	pruneCallRecordEvents(stores);
+	await pruneCallRecordEvents(stores);
 }
 /** Delete metadata and all chunk rows for one call record event. */
-function deleteCallRecordEventRows(stores, eventKey) {
-	const meta = stores.events.lookup(eventKey);
-	stores.events.delete(eventKey);
+async function deleteCallRecordEventRows(stores, eventKey) {
+	const meta = await stores.events.lookup(eventKey);
+	await stores.events.delete(eventKey);
 	if (!meta) return;
-	for (let index = 0; index < meta.chunkCount; index += 1) stores.chunks.delete(buildChunkKey(eventKey, index));
+	for (let index = 0; index < meta.chunkCount; index += 1) await stores.chunks.delete(buildChunkKey(eventKey, index));
 }
 /** Keep only the newest bounded call record events. */
-function pruneCallRecordEvents(stores) {
-	const rows = stores.events.entries();
+async function pruneCallRecordEvents(stores) {
+	if (stores.events.count && await stores.events.count() <= 1e3) return;
+	const rows = await stores.events.entries();
 	if (rows.length <= 1e3) return;
 	const sorted = rows.toSorted((a, b) => a.createdAt - b.createdAt || a.key.localeCompare(b.key));
-	for (const row of sorted.slice(0, rows.length - MAX_CALL_RECORD_EVENTS)) deleteCallRecordEventRows(stores, row.key);
+	for (const row of sorted.slice(0, rows.length - MAX_CALL_RECORD_EVENTS)) await deleteCallRecordEventRows(stores, row.key);
+}
+function isValidCallRecordChunkCount(chunkCount) {
+	return Number.isSafeInteger(chunkCount) && chunkCount >= 1 && chunkCount <= MAX_CHUNKS_PER_CALL_RECORD_EVENT;
 }
 /** Read and reassemble one chunked call record event. */
-function readCallRecordEvent(stores, eventKey, meta) {
-	if (!Number.isSafeInteger(meta.chunkCount) || meta.chunkCount < 1 || meta.chunkCount > 48) return null;
-	const records = stores.chunks.lookupMany?.(Array.from({ length: meta.chunkCount }, (_, index) => buildChunkKey(eventKey, index)));
+async function readCallRecordEvent(stores, eventKey, meta, records) {
+	if (!isValidCallRecordChunkCount(meta.chunkCount)) return null;
 	const chunks = [];
 	for (let index = 0; index < meta.chunkCount; index += 1) {
 		const result = records?.[index];
 		if (result && !result.ok) throw result.error;
-		const chunk = records ? result?.value : stores.chunks.lookup(buildChunkKey(eventKey, index));
+		const chunk = records ? result?.value : await stores.chunks.lookup(buildChunkKey(eventKey, index));
 		if (!chunk || chunk.index !== index) return null;
 		chunks.push(Buffer.from(chunk.dataBase64, "base64"));
 	}
 	return parseVoiceCallRecordLine(Buffer.concat(chunks, meta.byteLength).toString("utf8"))?.call ?? null;
 }
 /** Read all persisted call records in stable persisted order. */
-function readCallRecordEvents(stores) {
-	return stores.events.entries().toSorted((a, b) => a.createdAt - b.createdAt || a.key.localeCompare(b.key)).map((entry) => {
-		const call = readCallRecordEvent(stores, entry.key, entry.value);
-		return call ? {
+async function readCallRecordEvents(stores) {
+	const entries = (await stores.events.entries()).toSorted((a, b) => a.createdAt - b.createdAt || a.key.localeCompare(b.key));
+	const sqliteCalls = [];
+	let batchEnd = 0;
+	let chunkOffset = 0;
+	let chunkRecords;
+	for (const [entryIndex, entry] of entries.entries()) {
+		if (entryIndex >= batchEnd && stores.chunks.lookupMany) {
+			const keys = [];
+			for (let next = entryIndex;; next++) {
+				const row = entries[next];
+				if (!row) break;
+				const chunkCount = row.value?.chunkCount;
+				if (!isValidCallRecordChunkCount(chunkCount) || keys.length + chunkCount > CALL_RECORD_READ_BATCH_KEYS) break;
+				for (let index = 0; index < chunkCount; index++) keys.push(buildChunkKey(row.key, index));
+				batchEnd = next + 1;
+			}
+			chunkRecords = keys.length > 0 ? await stores.chunks.lookupMany(keys) : void 0;
+			chunkOffset = 0;
+		}
+		const records = chunkRecords?.slice(chunkOffset, chunkOffset + entry.value.chunkCount);
+		const call = await readCallRecordEvent(stores, entry.key, entry.value, records);
+		if (chunkRecords) chunkOffset += entry.value.chunkCount;
+		if (call) sqliteCalls.push({
 			call,
 			persistedAt: entry.value.persistedAt ?? entry.createdAt,
 			sequence: entry.value.sequence ?? parseEventKeySequence(entry.key),
 			orderKey: entry.key
-		} : null;
-	}).filter((entry) => entry !== null).toSorted((a, b) => a.persistedAt - b.persistedAt || a.sequence - b.sequence || a.orderKey.localeCompare(b.orderKey)).map((entry) => entry.call);
+		});
+	}
+	return sqliteCalls.toSorted((a, b) => a.persistedAt - b.persistedAt || a.sequence - b.sequence || a.orderKey.localeCompare(b.orderKey)).map((entry) => entry.call);
 }
 /** Persist one call record event to plugin state. */
-function persistCallRecord(storePath, call) {
+async function persistCallRecord(storePath, call, stateRuntime) {
 	try {
-		const stores = createCallRecordStateStores(storePath);
+		const stores = createCallRecordStateStores(storePath, stateRuntime);
 		const order = nextCallRecordOrder();
-		registerCallRecordEvent(stores, buildNewEventKey(order), call, order);
+		await registerCallRecordEvent(stores, buildNewEventKey(order), call, order);
 	} catch (err) {
 		console.error("[voice-call] Failed to persist call record:", err);
 		throw err;
 	}
 }
 /** Restore nonterminal active calls and provider/event indexes from persisted records. */
-function loadActiveCallsFromStore(storePath) {
-	const stores = tryCreateCallRecordStateStores(storePath);
+async function loadActiveCallsFromStore(storePath, stateRuntime) {
+	const stores = tryCreateCallRecordStateStores(storePath, stateRuntime);
 	let calls = [];
 	try {
-		calls = stores ? readCallRecordEvents(stores) : [];
+		calls = stores ? await readCallRecordEvents(stores) : [];
 	} catch (err) {
 		console.error("[voice-call] Failed to read SQLite call records:", err);
 	}
@@ -363,25 +399,25 @@ function loadActiveCallsFromStore(storePath) {
 		processedEventIds
 	};
 }
-function readCallHistoryFromStore(storePath) {
-	const stores = tryCreateCallRecordStateStores(storePath);
+async function readCallHistoryFromStore(storePath, stateRuntime) {
+	const stores = tryCreateCallRecordStateStores(storePath, stateRuntime);
 	if (stores) try {
-		return readCallRecordEvents(stores);
+		return await readCallRecordEvents(stores);
 	} catch (err) {
 		console.error("[voice-call] Failed to read SQLite call history:", err);
 	}
 	return [];
 }
 /** Resolve an internal ID or retained provider alias to its newest logical call snapshot. */
-function findCallInStore(storePath, callId) {
-	const calls = readCallRecordEvents(createCallRecordStateStores(storePath));
+async function findCallInStore(storePath, callId, stateRuntime) {
+	const calls = await readCallRecordEvents(createCallRecordStateStores(storePath, stateRuntime));
 	const match = calls.findLast((call) => call.callId === callId) ?? calls.findLast((call) => call.providerCallId === callId);
 	return match ? calls.findLast((call) => call.callId === match.callId) : void 0;
 }
 /** Return the newest persisted call history rows up to the requested limit. */
-async function getCallHistoryFromStore(storePath, limit = 50) {
+async function getCallHistoryFromStore(storePath, limit = 50, stateRuntime) {
 	if (limit <= 0) return [];
-	return readCallHistoryFromStore(storePath).slice(-limit);
+	return (await readCallHistoryFromStore(storePath, stateRuntime)).slice(-limit);
 }
 //#endregion
 //#region extensions/voice-call/src/store-path.ts
@@ -390,4 +426,4 @@ 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, loadActiveCallsFromStore as d, parseVoiceCallRecordLine as f, appendCallReplayKey as g, resolveVoiceCallLegacyCallLogPath as h, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as i, findCallInStore as l, prepareVoiceCallRecordForStorage as m, CALL_RECORD_CHUNK_MAX_ENTRIES as n, MAX_CALL_RECORD_EVENTS as o, persistCallRecord as p, CALL_RECORD_EVENTS_NAMESPACE as r, RAW_CALL_RECORD_CHUNK_BYTES as s, resolveDefaultVoiceCallStoreDir as t, getCallHistoryFromStore as u, rememberManagerReplayKey as v, TerminalStates as x, reserveRejectedProviderCall as y };
+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 };

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

@@ -1,4 +1,4 @@
-import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-3Jy2k-eX.js";
+import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-exU4Hutw.mjs";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/telnyx.ts
 function normalizeTelnyxDirection(direction) {

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

@@ -1,8 +1,8 @@
-import { fetchWithSsrFGuard } from "./runtime-api.js";
-import "./api.js";
-import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-4fkgz3UG.js";
-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-Ln4SWaYK.js";
-import { c as verifyTwilioWebhook, i as readVoiceCallProviderJsonResponse, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-3Jy2k-eX.js";
+import { fetchWithSsrFGuard } from "../runtime-api.js";
+import "../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 { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
@@ -99,7 +99,6 @@ function decideTwimlResponse(input) {
 			kind: "stored",
 			consumeStoredTwimlCallId: input.callIdFromQuery
 		};
-		if (input.isNotifyCall) return { kind: "empty" };
 		if (isOutboundDirection(input.direction)) return input.canStream ? { kind: "stream" } : { kind: "pause" };
 	}
 	if (input.isStatusCallback) return { kind: "empty" };
@@ -160,11 +159,10 @@ 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 (notify mode). Subsequent webhooks should not reuse it.
+	* webhook request before streaming. Subsequent webhooks should not reuse it.
 	*/
 	deleteStoredTwiml(callId) {
 		this.twimlStorage.delete(callId);
-		this.notifyCalls.delete(callId);
 	}
 	/**
 	* Release all process-local metadata owned by one Twilio call.
@@ -192,7 +190,6 @@ var TwilioProvider = class TwilioProvider {
 		this.callStreamMap = /* @__PURE__ */ new Map();
 		this.streamAuthTokens = /* @__PURE__ */ new Map();
 		this.twimlStorage = /* @__PURE__ */ new Map();
-		this.notifyCalls = /* @__PURE__ */ new Set();
 		this.activeStreamCalls = /* @__PURE__ */ new Set();
 		if (!config.accountSid) throw new Error("Twilio Account SID is required");
 		if (!config.authToken) throw new Error("Twilio Auth Token is required");
@@ -414,7 +411,6 @@ var TwilioProvider = class TwilioProvider {
 		const decision = decideTwimlResponse({
 			...view,
 			hasStoredTwiml: Boolean(storedTwiml),
-			isNotifyCall: view.callIdFromQuery ? this.notifyCalls.has(view.callIdFromQuery) : false,
 			hasActiveStreams: this.activeStreamCalls.size > 0,
 			canStream: Boolean(view.callSid && this.getStreamUrl())
 		});
@@ -435,9 +431,8 @@ var TwilioProvider = class TwilioProvider {
 		if (!view.callIdFromQuery || view.isStatusCallback) return null;
 		const storedTwiml = this.twimlStorage.get(view.callIdFromQuery);
 		if (!storedTwiml) return null;
-		const kind = this.notifyCalls.has(view.callIdFromQuery) ? "notify" : "pre-connect";
 		this.deleteStoredTwiml(view.callIdFromQuery);
-		console.log(`[voice-call] Twilio initial TwiML consumed for call ${view.callIdFromQuery} (kind=${kind}, callSid=${view.callSid ?? "unknown"})`);
+		console.log(`[voice-call] Twilio initial TwiML consumed for call ${view.callIdFromQuery} (kind=pre-connect, callSid=${view.callSid ?? "unknown"})`);
 		return storedTwiml;
 	}
 	/**
@@ -582,18 +577,9 @@ var TwilioProvider = class TwilioProvider {
 		const SILENCE_CHUNK = Buffer.alloc(CHUNK_SIZE, 255);
 		const handler = this.mediaStreamHandler;
 		const ttsProvider = this.ttsProvider;
-		const normalizeSendResult = (raw) => {
-			if (!raw || typeof raw !== "object") return { sent: true };
-			const typed = raw;
-			return { sent: typed.sent === void 0 ? true : Boolean(typed.sent) };
-		};
-		const sendAudioChunk = (audio) => {
-			const raw = handler.sendAudio(streamSid, audio);
-			return normalizeSendResult(raw);
-		};
 		await handler.queueTts(streamSid, async (signal) => {
 			const sendKeepAlive = () => {
-				sendAudioChunk(SILENCE_CHUNK);
+				handler.sendAudio(streamSid, SILENCE_CHUNK);
 			};
 			sendKeepAlive();
 			const keepAlive = setInterval(() => {
@@ -635,7 +621,7 @@ var TwilioProvider = class TwilioProvider {
 			for (const chunk of chunkAudio(muLawAudio, CHUNK_SIZE)) {
 				if (signal.aborted) break;
 				chunkAttempts += 1;
-				if (!sendAudioChunk(chunk).sent) {
+				if (!handler.sendAudio(streamSid, chunk).sent) {
 					handler.clearAudio(streamSid);
 					throw new Error(`Telephony stream playback failed: audio chunk ${chunkAttempts} not delivered`);
 				}

package/dist/doctor-contract-api.js

@@ -1,9 +1,10 @@
-import { a as CALL_RECORD_EVENT_META_MAX_ENTRIES, c as buildVoiceCallLegacyJsonlEventKey, f as parseVoiceCallRecordLine, h as resolveVoiceCallLegacyCallLogPath, i as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, m as prepareVoiceCallRecordForStorage, n as CALL_RECORD_CHUNK_MAX_ENTRIES, o as MAX_CALL_RECORD_EVENTS, r as CALL_RECORD_EVENTS_NAMESPACE, s as RAW_CALL_RECORD_CHUNK_BYTES, t as resolveDefaultVoiceCallStoreDir } from "./store-path-M0GXxUfv.js";
+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 { 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 from "node:fs/promises";
+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. */
@@ -70,6 +71,7 @@ function describeVoiceCallSchemaMigration(migration) {
 		case "conversation-binding-targets-v15": return "conversation bindings -> exact target keys without agent/session projections";
 		case "skill-workshop-directory-ownership-v16": return "Skill Workshop proposals -> per-agent Workshop directory ownership";
 		case "prepared-worker-ownership-v17": return "prepared workers -> one-use capacity and fixed workspace ownership";
+		case "github-publication-requester-authority-v18": return "GitHub publication receipts -> original requesting authority";
 		case "worker-placement-execution-mode-v8": return "cloud worker placements -> execution-mode claims";
 		case "operator-approvals-system-agent": return "operator approvals -> OpenClaw system changes";
 		case "session-watch-cursor-provenance-v4": return "session watch cursors -> provenance column";
@@ -77,37 +79,11 @@ function describeVoiceCallSchemaMigration(migration) {
 	}
 	return migration.kind;
 }
-/** Build the plugin state key for one migrated event chunk. */
-function buildChunkKey(eventKey, index) {
-	return `${eventKey}:chunk:${String(index).padStart(4, "0")}`;
-}
-/** Chunk a prepared call record into bounded plugin state rows. */
-function prepareChunks(call) {
-	const serialized = JSON.stringify(prepareVoiceCallRecordForStorage(call));
-	const buffer = Buffer.from(serialized, "utf8");
-	const chunkCount = Math.max(1, Math.ceil(buffer.byteLength / RAW_CALL_RECORD_CHUNK_BYTES));
-	if (chunkCount > 48) throw new Error(`voice-call record exceeds SQLite chunk limit (${chunkCount}/48)`);
-	const chunks = [];
-	for (let index = 0; index < chunkCount; index += 1) {
-		const chunk = buffer.subarray(index * RAW_CALL_RECORD_CHUNK_BYTES, (index + 1) * RAW_CALL_RECORD_CHUNK_BYTES);
-		chunks.push({
-			index,
-			dataBase64: chunk.toString("base64")
-		});
-	}
-	return {
-		chunks,
-		meta: {
-			chunkCount,
-			byteLength: buffer.byteLength
-		}
-	};
-}
 /** Read and prepare legacy JSONL call records, collecting line-level warnings. */
 async function readLegacyCallRecords(filePath) {
 	let content;
 	try {
-		content = await fs.readFile(filePath, "utf8");
+		content = await fs$1.readFile(filePath, "utf8");
 	} catch {
 		return {
 			entries: [],
@@ -125,11 +101,12 @@ async function readLegacyCallRecords(filePath) {
 			continue;
 		}
 		try {
-			const prepared = prepareChunks(parsed.call);
+			const prepared = encodeCallRecordEvent(parsed.call);
+			const chunks = Array.from({ length: prepared.meta.chunkCount }, (_, chunkIndex) => prepared.chunk(chunkIndex));
 			entries.push({
 				eventKey: buildVoiceCallLegacyJsonlEventKey(line, index),
 				lineNumber: index + 1,
-				chunks: prepared.chunks,
+				chunks,
 				meta: {
 					...prepared.meta,
 					persistedAt: parsed.persistedAt,
@@ -192,18 +169,23 @@ const stateMigrations = [{
 	id: "voice-call-calls-jsonl-to-plugin-state",
 	label: "Voice Call call log",
 	async detectLegacyState(params) {
-		const { detectOpenClawStateDatabaseSchemaMigrations } = await import("openclaw/plugin-sdk/doctor-repair-runtime");
 		const storePath = resolveVoiceCallStorePath(params);
+		if (!existsSync(storePath)) return null;
+		const { detectOpenClawStateDatabaseSchemaMigrations } = await import("openclaw/plugin-sdk/doctor-repair-runtime");
 		const { entries } = await readLegacyCallRecords(resolveVoiceCallLegacyCallLogPath(storePath));
 		const schemaMigrations = detectOpenClawStateDatabaseSchemaMigrations({ env: resolveVoiceCallStateDatabaseEnv(params) });
 		if (entries.length === 0 && schemaMigrations.length === 0) return null;
 		return { preview: [...schemaMigrations.map((migration) => `- Voice Call SQLite schema: ${describeVoiceCallSchemaMigration(migration)}`), ...entries.length > 0 ? [`- Voice Call call log: ${entries.length} ${entries.length === 1 ? "record" : "records"} -> plugin state (${CALL_RECORD_EVENTS_NAMESPACE})`] : []] };
 	},
 	async migrateLegacyState(params) {
-		const { detectOpenClawStateDatabaseSchemaMigrations, repairOpenClawStateDatabaseSchema } = await import("openclaw/plugin-sdk/doctor-repair-runtime");
 		const changes = [];
 		const warnings = [];
 		const storePath = resolveVoiceCallStorePath(params);
+		if (!existsSync(storePath)) return {
+			changes,
+			warnings
+		};
+		const { detectOpenClawStateDatabaseSchemaMigrations, repairOpenClawStateDatabaseSchema } = await import("openclaw/plugin-sdk/doctor-repair-runtime");
 		const filePath = resolveVoiceCallLegacyCallLogPath(storePath);
 		const { entries, warnings: readWarnings } = await readLegacyCallRecords(filePath);
 		warnings.push(...readWarnings);

package/dist/index.js

@@ -1,8 +1,8 @@
 import { definePluginEntry } from "./runtime-api.js";
 import "./api.js";
 import { VOICE_CALL_CLI_DESCRIPTOR } from "./cli-output-mode.js";
-import { i as resolveVoiceCallConfig, t as VoiceCallConfigSchema, u as validateProviderConfig } from "./config-DQwvsxeV.js";
-import { t as createVoiceCallRuntime } from "./runtime-entry-Ln4SWaYK.js";
+import { i as resolveVoiceCallConfig, t as VoiceCallConfigSchema, u as validateProviderConfig } from "./.setup/config-72FnMWHb.mjs";
+import { t as createVoiceCallRuntime } from "./.setup/runtime-entry-dDRm6RgA.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ErrorCodes, errorShape } from "openclaw/plugin-sdk/gateway-runtime";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
@@ -514,7 +514,7 @@ var voice_call_default = definePluginEntry({
 			}
 		}));
 		api.registerCli(async ({ program }) => {
-			const { registerVoiceCallCli } = await import("./cli-BGdihqyA.js");
+			const { registerVoiceCallCli } = await import("./.setup/cli-D6j7ppuN.mjs");
 			registerVoiceCallCli({
 				program,
 				config,

package/dist/runtime-entry.js

@@ -1,2 +1,2 @@
-import { t as createVoiceCallRuntime } from "./runtime-entry-Ln4SWaYK.js";
+import { t as createVoiceCallRuntime } from "./.setup/runtime-entry-dDRm6RgA.mjs";
 export { createVoiceCallRuntime };

package/node_modules/typebox/build/compile/validator.d.mts

@@ -18,7 +18,7 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Check(value: unknown): value is Encode;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Encode;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
     Clean(value: unknown): unknown;

package/node_modules/typebox/build/compile/validator.mjs

@@ -53,7 +53,7 @@ export class Validator {
             return Parser(this.Context(), this.Type(), value);
         throw new ParseError(value, this.Errors(value));
     }
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
         if (this.IsAccelerated() && this.Check(value))
             return [];

package/node_modules/typebox/build/format/idna/idn-hostname.mjs

@@ -14,14 +14,16 @@ function IsLabel(value) {
 // ------------------------------------------------------------------
 // NormalizeHostname
 //
-// Normalizes a hostname for label validation. Normalizes for NFC
-// such that equivalent codepoint sequences can be uniformly
-// compared. It also removes codepoints that IDNA mapping ignores,
-// and converts full stop variants to ASCII '.' so the hostname can
-// be split into labels.
+// Normalizes a hostname for label validation. Maps fullwidth
+// codepoints to their ASCII equivalent (e.g. 'ａ' U+FF41 maps to
+// 'a'), then normalizes for NFC such that equivalent codepoint
+// sequences can be uniformly compared. It also removes codepoints
+// that IDNA mapping ignores, and converts full stop variants to
+// ASCII '.' so the hostname can be split into labels.
 // ------------------------------------------------------------------
 function NormalizeHostname(value) {
     return value
+        .replace(/[\uff01-\uff5e]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0)) // RE_FULLWIDTH_MAPPING
         .normalize('NFC')
         .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
         .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING

package/node_modules/typebox/build/format/iri.mjs

@@ -2,6 +2,7 @@
 const IpvFutureMatchMaxLength = 2048;
 const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
 const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
 // NarrowIpvFuture
 //
@@ -26,6 +27,9 @@ export function IsIri(value) {
     // 1. Reject strings containing unencoded whitespace or illegal control characters.
     if (InvalidIriChars.test(value))
         return false;
-    // 2. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
+    // 2. Reject malformed percent-encoding triplets.
+    if (InvalidPercentEncoding.test(value))
+        return false;
+    // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
     return URL.canParse(NarrowIpvFuture(value));
 }

package/node_modules/typebox/build/guard/emit.mjs

@@ -106,15 +106,13 @@ export function IsMaxLength(value, length) {
 // Array
 // --------------------------------------------------------------------------
 export function Every(value, offset, params, expression) {
-    return G.IsEqual(offset, '0')
-        ? `${value}.every((${params[0]}, ${params[1]}) => ${expression})`
-        : `((value, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+    return G.IsEqual(offset, '0') ? `${value}.every((${params[0]}, ${params[1]}) => (${expression}))` : `${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${expression}))`;
 }
 export function Some(value, params, expression) {
     return `${value}.some((${params[0]}, ${params[1]}) => ${expression})`;
 }
 export function SomeAll(value, params, expression) {
-    return `((value, callback) => { let result = false; for(let index = 0; index < value.length; index++) if (callback(value[index], index)) result = true; return result })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+    return `((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`;
 }
 export function Counted(value, params, expression) {
     return `${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`;

package/node_modules/typebox/build/guard/guard.mjs

@@ -140,36 +140,24 @@ export function IsMinLength(value, length) {
 // --------------------------------------------------------------------------
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export function Every(value, offset, callback) {
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            return false;
-    }
-    return true;
+    return value.every((item, index) => (index < offset) || callback(item, index));
 }
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export function EveryAll(value, offset, callback) {
     let result = true;
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            result = false;
-    }
+    value.forEach((item, index) => { if ((index >= offset) && !callback(item, index))
+        result = false; });
     return result;
 }
 /** Returns true if some element satisfies the callback, short-circuiting on the first success */
 export function Some(value, callback) {
-    for (let index = 0; index < value.length; index++) {
-        if (callback(value[index], index))
-            return true;
-    }
-    return false;
+    return value.some((value, index) => callback(value, index));
 }
 /** Returns true if some element satisfies the callback, using exhaustive enumeration */
 export function SomeAll(value, callback) {
     let result = false;
-    for (let index = 0; index < value.length; index++) {
-        if (callback(value[index], index))
-            result = true;
-    }
+    value.forEach((item, index) => { if (callback(item, index))
+        result = true; });
     return result;
 }
 /** Returns the count of elements that satisfy the callback */