@openclaw/voice-call 2026.5.31-beta.2 → 2026.5.31-beta.4

package/dist/doctor-contract-api.js

@@ -0,0 +1,211 @@
+import { a as MAX_CALL_RECORD_EVENTS, f as prepareVoiceCallRecordForStorage, i as CALL_RECORD_EVENT_META_MAX_ENTRIES, n as CALL_RECORD_EVENTS_NAMESPACE, o as RAW_CALL_RECORD_CHUNK_BYTES, p as resolveVoiceCallLegacyCallLogPath, r as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, s as buildVoiceCallLegacyJsonlEventKey, t as CALL_RECORD_CHUNK_MAX_ENTRIES, u as parseVoiceCallRecordLine } from "./store-XuAPgOJG.js";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region extensions/voice-call/doctor-contract-api.ts
+function resolveHome(env) {
+	return env.HOME?.trim() || os.homedir();
+}
+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);
+}
+function getVoiceCallConfigStore(config) {
+	for (const pluginId of ["voice-call", "@openclaw/voice-call"]) {
+		const rawConfig = config.plugins?.entries?.[pluginId]?.config;
+		if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) continue;
+		const store = rawConfig.store;
+		if (typeof store === "string" && store.trim()) return store.trim();
+	}
+	return "";
+}
+function resolveVoiceCallStorePath(params) {
+	const configuredStore = getVoiceCallConfigStore(params.config);
+	if (configuredStore) return resolveUserPath(configuredStore, params.env);
+	return path.join(resolveHome(params.env), ".openclaw", "voice-calls");
+}
+async function fileExists(filePath) {
+	try {
+		return (await fs.stat(filePath)).isFile();
+	} catch {
+		return false;
+	}
+}
+function buildChunkKey(eventKey, index) {
+	return `${eventKey}:chunk:${String(index).padStart(4, "0")}`;
+}
+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
+		}
+	};
+}
+async function readLegacyCallRecords(filePath) {
+	let content;
+	try {
+		content = await fs.readFile(filePath, "utf8");
+	} catch {
+		return {
+			entries: [],
+			warnings: []
+		};
+	}
+	const entries = [];
+	const warnings = [];
+	let index = 0;
+	for (const line of content.split("\n")) {
+		const parsed = parseVoiceCallRecordLine(line, index);
+		if (!parsed) {
+			if (line.trim()) warnings.push(`Skipped malformed Voice Call call-log line ${index + 1}`);
+			index += 1;
+			continue;
+		}
+		try {
+			const prepared = prepareChunks(parsed.call);
+			entries.push({
+				eventKey: buildVoiceCallLegacyJsonlEventKey(line, index),
+				lineNumber: index + 1,
+				chunks: prepared.chunks,
+				meta: {
+					...prepared.meta,
+					persistedAt: parsed.persistedAt,
+					sequence: parsed.sequence
+				}
+			});
+		} catch (err) {
+			warnings.push(`Skipped Voice Call call-log line ${index + 1}: ${String(err)}`);
+		}
+		index += 1;
+	}
+	return {
+		entries,
+		warnings
+	};
+}
+async function archiveLegacySource(params) {
+	const archivedPath = `${params.filePath}.migrated`;
+	if (await fileExists(archivedPath)) {
+		params.warnings.push(`Left migrated Voice Call call-log source in place because ${archivedPath} already exists`);
+		return;
+	}
+	try {
+		await fs.rename(params.filePath, archivedPath);
+		params.changes.push(`Archived Voice Call call-log legacy source -> ${archivedPath}`);
+	} catch (err) {
+		params.warnings.push(`Failed archiving Voice Call call-log legacy source: ${String(err)}`);
+	}
+}
+async function selectEntriesForImport(params) {
+	const existingEventKeys = new Set((await params.eventStore.entries()).map((entry) => entry.key));
+	const missingEntries = params.entries.filter((entry) => !existingEventKeys.has(entry.eventKey));
+	const existingChunks = await params.chunkStore.entries();
+	let eventRoom = Math.max(0, MAX_CALL_RECORD_EVENTS - existingEventKeys.size);
+	let chunkRoom = Math.max(0, CALL_RECORD_CHUNK_MAX_ENTRIES - existingChunks.length);
+	const selected = [];
+	let pruned = 0;
+	for (const entry of missingEntries.toReversed()) {
+		if (eventRoom <= 0 || entry.chunks.length > chunkRoom) {
+			pruned++;
+			continue;
+		}
+		selected.push(entry);
+		eventRoom--;
+		chunkRoom -= entry.chunks.length;
+	}
+	if (pruned > 0) params.warnings.push(`Pruned ${pruned} older Voice Call call-log ${pruned === 1 ? "record" : "records"} during migration because plugin state keeps the newest ${MAX_CALL_RECORD_EVENTS} records`);
+	return {
+		existingEventKeys,
+		entries: selected.toReversed()
+	};
+}
+async function importLegacyCallRecords(params) {
+	const selected = await selectEntriesForImport(params);
+	let imported = 0;
+	for (const entry of selected.entries) {
+		if (selected.existingEventKeys.has(entry.eventKey)) continue;
+		try {
+			for (const chunk of entry.chunks) await params.chunkStore.register(buildChunkKey(entry.eventKey, chunk.index), chunk);
+			await params.eventStore.register(entry.eventKey, entry.meta);
+			selected.existingEventKeys.add(entry.eventKey);
+			imported++;
+		} catch (err) {
+			params.warnings.push(`Failed migrating Voice Call call-log line ${entry.lineNumber}: ${String(err)}`);
+		}
+	}
+	return imported;
+}
+const stateMigrations = [{
+	id: "voice-call-calls-jsonl-to-plugin-state",
+	label: "Voice Call call log",
+	async detectLegacyState(params) {
+		const { entries } = await readLegacyCallRecords(resolveVoiceCallLegacyCallLogPath(resolveVoiceCallStorePath(params)));
+		if (entries.length === 0) return null;
+		return { preview: [`- Voice Call call log: ${entries.length} ${entries.length === 1 ? "record" : "records"} -> plugin state (${CALL_RECORD_EVENTS_NAMESPACE})`] };
+	},
+	async migrateLegacyState(params) {
+		const changes = [];
+		const warnings = [];
+		const storePath = resolveVoiceCallStorePath(params);
+		const filePath = resolveVoiceCallLegacyCallLogPath(storePath);
+		const { entries, warnings: readWarnings } = await readLegacyCallRecords(filePath);
+		warnings.push(...readWarnings);
+		if (entries.length === 0) return {
+			changes,
+			warnings
+		};
+		const env = {
+			...params.env,
+			OPENCLAW_STATE_DIR: storePath
+		};
+		const imported = await importLegacyCallRecords({
+			entries,
+			eventStore: params.context.openPluginStateKeyedStore({
+				namespace: CALL_RECORD_EVENTS_NAMESPACE,
+				maxEntries: CALL_RECORD_EVENT_META_MAX_ENTRIES,
+				env
+			}),
+			chunkStore: params.context.openPluginStateKeyedStore({
+				namespace: CALL_RECORD_EVENT_CHUNKS_NAMESPACE,
+				maxEntries: CALL_RECORD_CHUNK_MAX_ENTRIES,
+				env
+			}),
+			warnings
+		});
+		if (imported > 0) changes.push(`Migrated ${imported} Voice Call call-log ${imported === 1 ? "record" : "records"} -> plugin state`);
+		if (warnings.some((warning) => warning.startsWith("Failed migrating Voice Call") || warning.startsWith("Skipped malformed Voice Call call-log line") || warning.startsWith("Skipped Voice Call call-log line") || warning.startsWith("Skipped Voice Call call-log migration"))) {
+			warnings.push("Left Voice Call call-log source in place because migration was incomplete");
+			return {
+				changes,
+				warnings
+			};
+		}
+		await archiveLegacySource({
+			filePath,
+			changes,
+			warnings
+		});
+		return {
+			changes,
+			warnings
+		};
+	}
+}];
+//#endregion
+export { stateMigrations };

package/dist/{guarded-json-api-mCcsLRBb.js → guarded-json-api-tyxHyrev.js}

@@ -1,6 +1,6 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
-import { a as getHeader } from "./runtime-entry-DXf7kdXt.js";
+import { a as getHeader } from "./runtime-entry-13O0Ki99.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";

package/dist/index.js

@@ -1,7 +1,8 @@
 import { definePluginEntry, sleep } from "./runtime-api.js";
 import "./api.js";
 import { i as resolveVoiceCallConfig, s as validateProviderConfig } from "./config-BKyRNKHF.js";
-import { _ as setVoiceCallStateRuntime, c as getTailscaleSelfInfo, g as getCallHistoryFromStore, l as setupTailscaleExposureRoute, o as resolveWebhookExposureStatus, p as resolveUserPath, s as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime } from "./runtime-entry-DXf7kdXt.js";
+import { c as getTailscaleSelfInfo, l as setupTailscaleExposureRoute, o as resolveWebhookExposureStatus, p as resolveUserPath, s as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime } from "./runtime-entry-13O0Ki99.js";
+import { c as getCallHistoryFromStore, m as setVoiceCallStateRuntime } from "./store-XuAPgOJG.js";
 import { i as parseVoiceCallPluginConfig, r as normalizeVoiceCallLegacyConfigInput, t as formatVoiceCallLegacyConfigWarnings } from "./config-compat-BLdRz9GR.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ErrorCodes, callGatewayFromCli, errorShape } from "openclaw/plugin-sdk/gateway-runtime";

package/dist/{plivo-Dpf08ZVJ.js → plivo-DeSZeJ0S.js}

@@ -1,5 +1,5 @@
-import { a as getHeader, m as escapeXml } from "./runtime-entry-DXf7kdXt.js";
-import { n as reconstructWebhookUrl, r as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-mCcsLRBb.js";
+import { a as getHeader, m as escapeXml } from "./runtime-entry-13O0Ki99.js";
+import { n as reconstructWebhookUrl, r as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-tyxHyrev.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/plivo.ts

package/dist/{realtime-handler-Crs3kty2.js → realtime-handler-BP6_qBNe.js}

@@ -83,7 +83,7 @@ var RealtimeAudioPacer = class {
 		const item = this.queue.shift();
 		if (!item) return;
 		let delayMs = 0;
-		let sent = true;
+		let sent;
 		if (item.type === "audio") {
 			this.queuedAudioBytes = Math.max(0, this.queuedAudioBytes - item.chunk.length);
 			sent = this.params.send(this.params.serializer.media(item.chunk.toString("base64")));
@@ -787,7 +787,7 @@ var RealtimeCallHandler = class {
 					text
 				});
 			},
-			onToolCall: (toolEvent, session) => {
+			onToolCall: (toolEvent, sessionLocal) => {
 				const turnId = ensureTalkTurn();
 				emitTalkEvent({
 					type: "tool.call",
@@ -800,7 +800,7 @@ var RealtimeCallHandler = class {
 					}
 				});
 				console.log(`[voice-call] realtime tool call received callId=${callId} providerCallId=${callSid} tool=${toolEvent.name}`);
-				this.executeToolCall(session, callId, toolEvent.callId || toolEvent.itemId, toolEvent.name, toolEvent.args, turnId, emitTalkEvent);
+				this.executeToolCall(sessionLocal, callId, toolEvent.callId || toolEvent.itemId, toolEvent.name, toolEvent.args, turnId, emitTalkEvent);
 			},
 			onEvent: (event) => {
 				if (event.type === "input_audio_buffer.speech_started") {
@@ -986,7 +986,9 @@ var RealtimeCallHandler = class {
 			const now = Date.now();
 			const quietFor = now - updatedAt;
 			if (quietFor >= CONSULT_TRANSCRIPT_SETTLE_MS || now >= deadline) return;
-			await new Promise((resolve) => setTimeout(resolve, Math.min(CONSULT_TRANSCRIPT_SETTLE_MS - quietFor, deadline - now)));
+			await new Promise((resolve) => {
+				setTimeout(resolve, Math.min(CONSULT_TRANSCRIPT_SETTLE_MS - quietFor, deadline - now));
+			});
 		}
 	}
 	clearForcedConsultState(callId) {

package/dist/{response-generator-Cu4sOiUO.js → response-generator-D6UsHyfH.js}

@@ -1,5 +1,5 @@
 import { o as resolveVoiceCallSessionKey } from "./config-BKyRNKHF.js";
-import { f as resolveVoiceResponseModel } from "./runtime-entry-DXf7kdXt.js";
+import { f as resolveVoiceResponseModel } from "./runtime-entry-13O0Ki99.js";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { applyModelOverrideToSessionEntry } from "openclaw/plugin-sdk/model-session-runtime";

package/dist/{runtime-entry-DXf7kdXt.js → runtime-entry-13O0Ki99.js}

@@ -1,18 +1,17 @@
 import { isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "./runtime-api.js";
 import "./api.js";
 import { a as resolveVoiceCallEffectiveConfig, c as deepMergeDefined, i as resolveVoiceCallConfig, n as normalizeVoiceCallConfig, o as resolveVoiceCallSessionKey, r as resolveTwilioAuthToken, s as validateProviderConfig } from "./config-BKyRNKHF.js";
+import { c as getCallHistoryFromStore, d as persistCallRecord, h as TerminalStates, l as loadActiveCallsFromStore, m as setVoiceCallStateRuntime } from "./store-XuAPgOJG.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { MAX_TIMER_TIMEOUT_MS, asDateTimestampMs, resolveExpiresAtMsFromDurationMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, buildRealtimeVoiceAgentConsultPolicyInstructions, consultRealtimeVoiceAgent, convertPcmToMulaw8k, createTalkSessionController, recordTalkObservabilityEvent, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow, resolveRealtimeVoiceFastContextConsult } from "openclaw/plugin-sdk/realtime-voice";
-import { z } from "zod";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import crypto, { createHash, randomUUID } from "node:crypto";
-import { appendRegularFile, privateFileStore, privateFileStoreSync, root } from "openclaw/plugin-sdk/security-runtime";
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+import crypto from "node:crypto";
+import { root } from "openclaw/plugin-sdk/security-runtime";
 import { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
 import { spawn } from "node:child_process";
 import http from "node:http";
@@ -33,121 +32,6 @@ function isAllowlistedCaller(normalizedFrom, allowFrom) {
 	});
 }
 //#endregion
-//#region extensions/voice-call/src/types.ts
-const ProviderNameSchema = z.enum([
-	"telnyx",
-	"twilio",
-	"plivo",
-	"mock"
-]);
-const CallStateSchema = z.enum([
-	"initiated",
-	"ringing",
-	"answered",
-	"active",
-	"speaking",
-	"listening",
-	"completed",
-	"hangup-user",
-	"hangup-bot",
-	"timeout",
-	"error",
-	"failed",
-	"no-answer",
-	"busy",
-	"voicemail"
-]);
-const TerminalStates = new Set([
-	"completed",
-	"hangup-user",
-	"hangup-bot",
-	"timeout",
-	"error",
-	"failed",
-	"no-answer",
-	"busy",
-	"voicemail"
-]);
-const EndReasonSchema = z.enum([
-	"completed",
-	"hangup-user",
-	"hangup-bot",
-	"timeout",
-	"error",
-	"failed",
-	"no-answer",
-	"busy",
-	"voicemail"
-]);
-const BaseEventSchema = z.object({
-	id: z.string(),
-	dedupeKey: z.string().optional(),
-	callId: z.string(),
-	providerCallId: z.string().optional(),
-	timestamp: z.number(),
-	turnToken: z.string().optional(),
-	direction: z.enum(["inbound", "outbound"]).optional(),
-	from: z.string().optional(),
-	to: z.string().optional()
-});
-z.discriminatedUnion("type", [
-	BaseEventSchema.extend({ type: z.literal("call.initiated") }),
-	BaseEventSchema.extend({ type: z.literal("call.ringing") }),
-	BaseEventSchema.extend({ type: z.literal("call.answered") }),
-	BaseEventSchema.extend({ type: z.literal("call.active") }),
-	BaseEventSchema.extend({
-		type: z.literal("call.speaking"),
-		text: z.string()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.speech"),
-		transcript: z.string(),
-		isFinal: z.boolean(),
-		confidence: z.number().min(0).max(1).optional()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.silence"),
-		durationMs: z.number()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.dtmf"),
-		digits: z.string()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.ended"),
-		reason: EndReasonSchema
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.error"),
-		error: z.string(),
-		retryable: z.boolean().optional()
-	})
-]);
-const CallDirectionSchema = z.enum(["outbound", "inbound"]);
-const TranscriptEntrySchema = z.object({
-	timestamp: z.number(),
-	speaker: z.enum(["bot", "user"]),
-	text: z.string(),
-	isFinal: z.boolean().default(true)
-});
-const CallRecordSchema = z.object({
-	callId: z.string(),
-	providerCallId: z.string().optional(),
-	provider: ProviderNameSchema,
-	direction: CallDirectionSchema,
-	state: CallStateSchema,
-	from: z.string(),
-	to: z.string(),
-	sessionKey: z.string().optional(),
-	startedAt: z.number(),
-	answeredAt: z.number().optional(),
-	endedAt: z.number().optional(),
-	endReason: EndReasonSchema.optional(),
-	transcript: z.array(TranscriptEntrySchema).default([]),
-	processedEventIds: z.array(z.string()).default([]),
-	metadata: z.record(z.string(), z.unknown()).optional()
-});
-//#endregion
 //#region extensions/voice-call/src/manager/state.ts
 const ConversationStates = new Set(["speaking", "listening"]);
 const StateOrder = [
@@ -181,292 +65,6 @@ function addTranscriptEntry(call, speaker, text) {
 	call.transcript.push(entry);
 }
 //#endregion
-//#region extensions/voice-call/src/runtime-state.ts
-const { setRuntime: setVoiceCallStateRuntime, clearRuntime: clearVoiceCallStateRuntime, tryGetRuntime: getOptionalVoiceCallStateRuntime } = createPluginRuntimeStore({
-	pluginId: "voice-call-state",
-	errorMessage: "Voice Call state runtime not initialized"
-});
-//#endregion
-//#region extensions/voice-call/src/manager/store.ts
-const pendingPersistWrites = /* @__PURE__ */ new Set();
-const CALL_RECORD_EVENTS_NAMESPACE = "call-record-events";
-const CALL_RECORD_EVENT_CHUNKS_NAMESPACE = "call-record-event-chunks";
-const CALL_RECORD_MIGRATIONS_NAMESPACE = "call-record-migrations";
-const CALL_RECORD_JSONL_MIGRATION_KEY = "calls-jsonl-v1";
-const MAX_CALL_RECORD_EVENTS = 1e3;
-const CALL_RECORD_EVENT_META_MAX_ENTRIES = 1100;
-const MAX_CHUNKS_PER_CALL_RECORD_EVENT = 48;
-const CALL_RECORD_CHUNK_MAX_ENTRIES = 48048;
-const RAW_CHUNK_BYTES = 36 * 1024;
-let callRecordEventSequence = 0;
-function resolveCallLogPath(storePath) {
-	return path.join(storePath, "calls.jsonl");
-}
-function resolvePluginStateEnv(storePath) {
-	return {
-		...process.env,
-		OPENCLAW_STATE_DIR: storePath
-	};
-}
-function createCallRecordStateStores(storePath) {
-	const runtime = getOptionalVoiceCallStateRuntime();
-	if (!runtime) return null;
-	const env = resolvePluginStateEnv(storePath);
-	return {
-		events: runtime.state.openSyncKeyedStore({
-			namespace: CALL_RECORD_EVENTS_NAMESPACE,
-			maxEntries: CALL_RECORD_EVENT_META_MAX_ENTRIES,
-			env
-		}),
-		chunks: runtime.state.openSyncKeyedStore({
-			namespace: CALL_RECORD_EVENT_CHUNKS_NAMESPACE,
-			maxEntries: CALL_RECORD_CHUNK_MAX_ENTRIES,
-			env
-		}),
-		migrations: runtime.state.openSyncKeyedStore({
-			namespace: CALL_RECORD_MIGRATIONS_NAMESPACE,
-			maxEntries: 100,
-			env
-		})
-	};
-}
-function tryCreateCallRecordStateStores(storePath) {
-	try {
-		return createCallRecordStateStores(storePath);
-	} catch (err) {
-		console.error("[voice-call] Failed to open SQLite call record store:", err);
-		return null;
-	}
-}
-function buildChunkKey(eventKey, index) {
-	return `${eventKey}:chunk:${String(index).padStart(4, "0")}`;
-}
-function buildJsonlEventKey(line, index) {
-	return `jsonl:${String(index).padStart(8, "0")}:${createHash("sha256").update(line).digest("hex")}`;
-}
-function nextCallRecordOrder() {
-	const sequence = callRecordEventSequence;
-	callRecordEventSequence = (callRecordEventSequence + 1) % 1e6;
-	return {
-		persistedAt: Date.now(),
-		sequence
-	};
-}
-function buildNewEventKey(order) {
-	return `event:${order.persistedAt.toString(36)}:${String(order.sequence).padStart(6, "0")}:${randomUUID()}`;
-}
-function parseEventKeySequence(key) {
-	const match = /^event:[^:]+:(\d+):/.exec(key);
-	return match ? Number.parseInt(match[1], 10) : 0;
-}
-function parseCallRecordLine(line, sequence = 0) {
-	if (!line.trim()) return null;
-	try {
-		const parsed = JSON.parse(line);
-		if (parsed && typeof parsed === "object" && parsed.version === 2) {
-			const envelope = parsed;
-			return {
-				call: CallRecordSchema.parse(envelope.call),
-				persistedAt: typeof envelope.persistedAt === "number" && Number.isFinite(envelope.persistedAt) ? envelope.persistedAt : 0,
-				sequence: typeof envelope.sequence === "number" && Number.isFinite(envelope.sequence) ? envelope.sequence : sequence,
-				orderKey: ""
-			};
-		}
-		return {
-			call: CallRecordSchema.parse(parsed),
-			persistedAt: 0,
-			sequence,
-			orderKey: ""
-		};
-	} catch {
-		return null;
-	}
-}
-function registerCallRecordEvent(stores, eventKey, call, order) {
-	const serialized = JSON.stringify(call);
-	const buffer = Buffer.from(serialized, "utf8");
-	const chunkCount = Math.max(1, Math.ceil(buffer.byteLength / RAW_CHUNK_BYTES));
-	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})`);
-	for (let index = 0; index < chunkCount; index += 1) {
-		const chunk = buffer.subarray(index * RAW_CHUNK_BYTES, (index + 1) * RAW_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
-	});
-	pruneCallRecordEvents(stores);
-}
-function deleteCallRecordEventRows(stores, eventKey) {
-	const meta = stores.events.lookup(eventKey);
-	stores.events.delete(eventKey);
-	if (!meta) return;
-	for (let index = 0; index < meta.chunkCount; index += 1) stores.chunks.delete(buildChunkKey(eventKey, index));
-}
-function pruneCallRecordEvents(stores) {
-	const rows = stores.events.entries();
-	if (rows.length <= MAX_CALL_RECORD_EVENTS) 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);
-}
-function registerCallRecordEventIfAbsent(stores, eventKey, record) {
-	if (!stores.events.lookup(eventKey)) registerCallRecordEvent(stores, eventKey, record.call, {
-		persistedAt: record.persistedAt,
-		sequence: record.sequence
-	});
-}
-function readCallRecordEvent(stores, eventKey) {
-	const meta = stores.events.lookup(eventKey);
-	if (!meta) return null;
-	const chunks = [];
-	for (let index = 0; index < meta.chunkCount; index += 1) {
-		const chunk = stores.chunks.lookup(buildChunkKey(eventKey, index));
-		if (!chunk || chunk.index !== index) return null;
-		chunks.push(Buffer.from(chunk.dataBase64, "base64"));
-	}
-	return parseCallRecordLine(Buffer.concat(chunks, meta.byteLength).toString("utf8"))?.call ?? null;
-}
-function ensureLegacyCallLogImported(storePath, stores) {
-	const imported = stores.migrations.lookup(CALL_RECORD_JSONL_MIGRATION_KEY) !== void 0;
-	const logPath = resolveCallLogPath(storePath);
-	const content = privateFileStoreSync(storePath).readTextIfExists(path.basename(logPath));
-	if (content === null) {
-		if (!imported) stores.migrations.register(CALL_RECORD_JSONL_MIGRATION_KEY, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
-		return [];
-	}
-	const fallbackCalls = [];
-	{
-		let index = 0;
-		let importFailed = false;
-		for (const line of content.split("\n")) {
-			const parsed = parseCallRecordLine(line, index);
-			if (!parsed) {
-				index += 1;
-				continue;
-			}
-			try {
-				registerCallRecordEventIfAbsent(stores, buildJsonlEventKey(line, index), parsed);
-			} catch (err) {
-				importFailed = true;
-				fallbackCalls.push({
-					...parsed,
-					orderKey: `jsonl:${String(index).padStart(8, "0")}`
-				});
-				console.error("[voice-call] Failed to import persisted call record:", err);
-			}
-			index += 1;
-		}
-		if (!importFailed) try {
-			fs.rmSync(logPath, { force: true });
-		} catch {}
-	}
-	if (!imported) stores.migrations.register(CALL_RECORD_JSONL_MIGRATION_KEY, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
-	return fallbackCalls;
-}
-function readCallRecordEvents(storePath, stores) {
-	const fallbackCalls = ensureLegacyCallLogImported(storePath, 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);
-		return call ? {
-			call,
-			persistedAt: entry.value.persistedAt ?? entry.createdAt,
-			sequence: entry.value.sequence ?? parseEventKeySequence(entry.key),
-			orderKey: entry.key
-		} : null;
-	}).filter((entry) => entry !== null), ...fallbackCalls].toSorted((a, b) => a.persistedAt - b.persistedAt || a.sequence - b.sequence || a.orderKey.localeCompare(b.orderKey)).map((entry) => entry.call);
-}
-function persistCallRecord(storePath, call) {
-	const stores = tryCreateCallRecordStateStores(storePath);
-	if (stores) try {
-		ensureLegacyCallLogImported(storePath, stores);
-		const order = nextCallRecordOrder();
-		registerCallRecordEvent(stores, buildNewEventKey(order), call, order);
-		return;
-	} catch (err) {
-		console.error("[voice-call] Failed to persist call record:", err);
-	}
-	const logPath = resolveCallLogPath(storePath);
-	const order = nextCallRecordOrder();
-	const write = appendRegularFile({
-		filePath: logPath,
-		content: `${JSON.stringify({
-			version: 2,
-			...order,
-			call
-		})}\n`,
-		rejectSymlinkParents: true
-	}).catch((err) => {
-		console.error("[voice-call] Failed to persist call record:", err);
-	}).finally(() => {
-		pendingPersistWrites.delete(write);
-	});
-	pendingPersistWrites.add(write);
-}
-function loadActiveCallsFromStore(storePath) {
-	const stores = tryCreateCallRecordStateStores(storePath);
-	let calls;
-	try {
-		calls = stores ? readCallRecordEvents(storePath, stores) : readCallRecordsFromLegacyLog(storePath);
-	} catch (err) {
-		console.error("[voice-call] Failed to read SQLite call records:", err);
-		calls = readCallRecordsFromLegacyLog(storePath);
-	}
-	if (calls.length === 0) return {
-		activeCalls: /* @__PURE__ */ new Map(),
-		providerCallIdMap: /* @__PURE__ */ new Map(),
-		processedEventIds: /* @__PURE__ */ new Set(),
-		rejectedProviderCallIds: /* @__PURE__ */ new Set()
-	};
-	const callMap = /* @__PURE__ */ new Map();
-	for (const call of calls) callMap.set(call.callId, call);
-	const activeCalls = /* @__PURE__ */ new Map();
-	const providerCallIdMap = /* @__PURE__ */ new Map();
-	const processedEventIds = /* @__PURE__ */ new Set();
-	const rejectedProviderCallIds = /* @__PURE__ */ new Set();
-	for (const [callId, call] of callMap) {
-		for (const eventId of call.processedEventIds) processedEventIds.add(eventId);
-		if (TerminalStates.has(call.state)) continue;
-		activeCalls.set(callId, call);
-		if (call.providerCallId) providerCallIdMap.set(call.providerCallId, callId);
-	}
-	return {
-		activeCalls,
-		providerCallIdMap,
-		processedEventIds,
-		rejectedProviderCallIds
-	};
-}
-async function getCallHistoryFromStore(storePath, limit = 50) {
-	if (limit <= 0) return [];
-	const stores = tryCreateCallRecordStateStores(storePath);
-	if (stores) try {
-		return readCallRecordEvents(storePath, stores).slice(-limit);
-	} catch (err) {
-		console.error("[voice-call] Failed to read SQLite call history:", err);
-	}
-	const logPath = resolveCallLogPath(storePath);
-	const content = await privateFileStore(storePath).readTextIfExists(path.basename(logPath));
-	if (content === null) return [];
-	const lines = content.trim().split("\n").filter(Boolean);
-	const calls = [];
-	for (const [index, line] of lines.slice(-limit).entries()) {
-		const parsed = parseCallRecordLine(line, index);
-		if (parsed) calls.push(parsed.call);
-	}
-	return calls;
-}
-function readCallRecordsFromLegacyLog(storePath) {
-	const logPath = resolveCallLogPath(storePath);
-	const content = privateFileStoreSync(storePath).readTextIfExists(path.basename(logPath));
-	if (content === null) return [];
-	return content.split("\n").map((line, index) => parseCallRecordLine(line, index)?.call ?? null).filter((call) => call !== null);
-}
-//#endregion
 //#region extensions/voice-call/src/manager/timer-delays.ts
 function resolveVoiceCallSecondsTimerDelayMs(seconds, minMs = 1) {
 	if (!Number.isFinite(seconds)) return resolveTimerTimeoutMs(MAX_TIMER_TIMEOUT_MS, MAX_TIMER_TIMEOUT_MS, minMs);
@@ -489,15 +87,17 @@ function startMaxDurationTimer(params) {
 	clearMaxDurationTimer(params.ctx, params.callId);
 	const maxDurationMs = params.timeoutMs === void 0 ? resolveVoiceCallSecondsTimerDelayMs(params.ctx.config.maxDurationSeconds) : resolveVoiceCallTimerDelayMs(params.timeoutMs);
 	console.log(`[voice-call] Starting max duration timer (${Math.ceil(maxDurationMs / 1e3)}s) for call ${params.callId}`);
-	const timer = setTimeout(async () => {
-		params.ctx.maxDurationTimers.delete(params.callId);
-		const call = params.ctx.activeCalls.get(params.callId);
-		if (call && !TerminalStates.has(call.state)) {
-			console.log(`[voice-call] Max duration reached (${Math.ceil(maxDurationMs / 1e3)}s), ending call ${params.callId}`);
-			call.endReason = "timeout";
-			persistCallRecord(params.ctx.storePath, call);
-			await params.onTimeout(params.callId);
-		}
+	const timer = setTimeout(() => {
+		(async () => {
+			params.ctx.maxDurationTimers.delete(params.callId);
+			const call = params.ctx.activeCalls.get(params.callId);
+			if (call && !TerminalStates.has(call.state)) {
+				console.log(`[voice-call] Max duration reached (${Math.ceil(maxDurationMs / 1e3)}s), ending call ${params.callId}`);
+				call.endReason = "timeout";
+				persistCallRecord(params.ctx.storePath, call);
+				await params.onTimeout(params.callId);
+			}
+		})();
 	}, maxDurationMs);
 	params.ctx.maxDurationTimers.set(params.callId, timer);
 }
@@ -892,12 +492,14 @@ async function speakInitialMessage(ctx, providerCallId) {
 			const delaySec = ctx.config.outbound.notifyHangupDelaySec;
 			const delayMs = resolveVoiceCallSecondsTimerDelayMs(delaySec, 0);
 			console.log(`[voice-call] Notify mode: auto-hangup in ${delaySec}s for call ${call.callId}`);
-			setTimeout(async () => {
-				const currentCall = ctx.activeCalls.get(call.callId);
-				if (currentCall && !TerminalStates.has(currentCall.state)) {
-					console.log(`[voice-call] Notify mode: hanging up call ${call.callId}`);
-					await endCall(ctx, call.callId);
-				}
+			setTimeout(() => {
+				(async () => {
+					const currentCall = ctx.activeCalls.get(call.callId);
+					if (currentCall && !TerminalStates.has(currentCall.state)) {
+						console.log(`[voice-call] Notify mode: hanging up call ${call.callId}`);
+						await endCall(ctx, call.callId);
+					}
+				})();
 			}, delayMs);
 		} else if (mode === "conversation" && ctx.provider && shouldStartListeningAfterInitialMessage(ctx)) {
 			transitionState(call, "listening");
@@ -2188,7 +1790,9 @@ var MediaStreamHandler = class {
 				noServer: true,
 				maxPayload: MAX_INBOUND_MESSAGE_BYTES
 			});
-			this.wss.on("connection", (ws, req) => this.handleConnection(ws, req));
+			this.wss.on("connection", (ws, req) => {
+				this.handleConnection(ws, req);
+			});
 		}
 		if (this.getCurrentConnectionCount() >= this.maxConnections) {
 			this.rejectUpgrade(socket, 503, "Too many media stream connections");
@@ -2233,7 +1837,7 @@ var MediaStreamHandler = class {
 			ws.close(1013, "Too many pending media stream connections");
 			return;
 		}
-		ws.on("message", async (data) => {
+		ws.on("message", (data) => {
 			try {
 				const message = parseTwilioMediaMessage(data);
 				switch (message.event) {
@@ -2824,7 +2428,7 @@ function loadRealtimeTranscriptionRuntime() {
 	return realtimeTranscriptionRuntimePromise;
 }
 function loadResponseGeneratorModule() {
-	responseGeneratorModulePromise ??= import("./response-generator-Cu4sOiUO.js");
+	responseGeneratorModulePromise ??= import("./response-generator-D6UsHyfH.js");
 	return responseGeneratorModulePromise;
 }
 function sanitizeTranscriptForLog(value) {
@@ -3508,15 +3112,15 @@ let mockProviderPromise;
 let realtimeVoiceRuntimePromise;
 let realtimeHandlerPromise;
 function loadTelnyxProvider() {
-	telnyxProviderPromise ??= import("./telnyx-CxEuPBOJ.js");
+	telnyxProviderPromise ??= import("./telnyx-68EYJwaz.js");
 	return telnyxProviderPromise;
 }
 function loadTwilioProvider() {
-	twilioProviderPromise ??= import("./twilio-DzQmSUQP.js");
+	twilioProviderPromise ??= import("./twilio-D0dUSGam.js");
 	return twilioProviderPromise;
 }
 function loadPlivoProvider() {
-	plivoProviderPromise ??= import("./plivo-Dpf08ZVJ.js");
+	plivoProviderPromise ??= import("./plivo-DeSZeJ0S.js");
 	return plivoProviderPromise;
 }
 function loadMockProvider() {
@@ -3528,7 +3132,7 @@ function loadRealtimeVoiceRuntime() {
 	return realtimeVoiceRuntimePromise;
 }
 function loadRealtimeHandler() {
-	realtimeHandlerPromise ??= import("./realtime-handler-Crs3kty2.js");
+	realtimeHandlerPromise ??= import("./realtime-handler-BP6_qBNe.js");
 	return realtimeHandlerPromise;
 }
 function resolveVoiceCallConsultSessionKey(call) {
@@ -3793,4 +3397,4 @@ async function createVoiceCallRuntime(params) {
 	}
 }
 //#endregion
-export { setVoiceCallStateRuntime as _, getHeader as a, getTailscaleSelfInfo as c, chunkAudio as d, resolveVoiceResponseModel as f, getCallHistoryFromStore as g, mapVoiceToPolly as h, normalizeProviderStatus as i, setupTailscaleExposureRoute as l, escapeXml as m, isProviderStatusTerminal as n, resolveWebhookExposureStatus as o, resolveUserPath as p, mapProviderStatusToEndReason as r, cleanupTailscaleExposureRoute as s, createVoiceCallRuntime as t, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as u };
+export { getHeader as a, getTailscaleSelfInfo as c, chunkAudio as d, resolveVoiceResponseModel as f, mapVoiceToPolly as h, normalizeProviderStatus as i, setupTailscaleExposureRoute as l, escapeXml as m, isProviderStatusTerminal as n, resolveWebhookExposureStatus as o, resolveUserPath as p, mapProviderStatusToEndReason as r, cleanupTailscaleExposureRoute as s, createVoiceCallRuntime as t, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as u };

package/dist/runtime-entry.js

@@ -1,2 +1,2 @@
-import { t as createVoiceCallRuntime } from "./runtime-entry-DXf7kdXt.js";
+import { t as createVoiceCallRuntime } from "./runtime-entry-13O0Ki99.js";
 export { createVoiceCallRuntime };

package/dist/store-XuAPgOJG.js

@@ -0,0 +1,361 @@
+import { z } from "zod";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+//#region extensions/voice-call/src/types.ts
+const ProviderNameSchema = z.enum([
+	"telnyx",
+	"twilio",
+	"plivo",
+	"mock"
+]);
+const CallStateSchema = z.enum([
+	"initiated",
+	"ringing",
+	"answered",
+	"active",
+	"speaking",
+	"listening",
+	"completed",
+	"hangup-user",
+	"hangup-bot",
+	"timeout",
+	"error",
+	"failed",
+	"no-answer",
+	"busy",
+	"voicemail"
+]);
+const TerminalStates = new Set([
+	"completed",
+	"hangup-user",
+	"hangup-bot",
+	"timeout",
+	"error",
+	"failed",
+	"no-answer",
+	"busy",
+	"voicemail"
+]);
+const EndReasonSchema = z.enum([
+	"completed",
+	"hangup-user",
+	"hangup-bot",
+	"timeout",
+	"error",
+	"failed",
+	"no-answer",
+	"busy",
+	"voicemail"
+]);
+const BaseEventSchema = z.object({
+	id: z.string(),
+	dedupeKey: z.string().optional(),
+	callId: z.string(),
+	providerCallId: z.string().optional(),
+	timestamp: z.number(),
+	turnToken: z.string().optional(),
+	direction: z.enum(["inbound", "outbound"]).optional(),
+	from: z.string().optional(),
+	to: z.string().optional()
+});
+z.discriminatedUnion("type", [
+	BaseEventSchema.extend({ type: z.literal("call.initiated") }),
+	BaseEventSchema.extend({ type: z.literal("call.ringing") }),
+	BaseEventSchema.extend({ type: z.literal("call.answered") }),
+	BaseEventSchema.extend({ type: z.literal("call.active") }),
+	BaseEventSchema.extend({
+		type: z.literal("call.speaking"),
+		text: z.string()
+	}),
+	BaseEventSchema.extend({
+		type: z.literal("call.speech"),
+		transcript: z.string(),
+		isFinal: z.boolean(),
+		confidence: z.number().min(0).max(1).optional()
+	}),
+	BaseEventSchema.extend({
+		type: z.literal("call.silence"),
+		durationMs: z.number()
+	}),
+	BaseEventSchema.extend({
+		type: z.literal("call.dtmf"),
+		digits: z.string()
+	}),
+	BaseEventSchema.extend({
+		type: z.literal("call.ended"),
+		reason: EndReasonSchema
+	}),
+	BaseEventSchema.extend({
+		type: z.literal("call.error"),
+		error: z.string(),
+		retryable: z.boolean().optional()
+	})
+]);
+const CallDirectionSchema = z.enum(["outbound", "inbound"]);
+const TranscriptEntrySchema = z.object({
+	timestamp: z.number(),
+	speaker: z.enum(["bot", "user"]),
+	text: z.string(),
+	isFinal: z.boolean().default(true)
+});
+const CallRecordSchema = z.object({
+	callId: z.string(),
+	providerCallId: z.string().optional(),
+	provider: ProviderNameSchema,
+	direction: CallDirectionSchema,
+	state: CallStateSchema,
+	from: z.string(),
+	to: z.string(),
+	sessionKey: z.string().optional(),
+	startedAt: z.number(),
+	answeredAt: z.number().optional(),
+	endedAt: z.number().optional(),
+	endReason: EndReasonSchema.optional(),
+	transcript: z.array(TranscriptEntrySchema).default([]),
+	processedEventIds: z.array(z.string()).default([]),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+//#endregion
+//#region extensions/voice-call/src/runtime-state.ts
+const { setRuntime: setVoiceCallStateRuntime, clearRuntime: clearVoiceCallStateRuntime, tryGetRuntime: getOptionalVoiceCallStateRuntime } = createPluginRuntimeStore({
+	pluginId: "voice-call-state",
+	errorMessage: "Voice Call state runtime not initialized"
+});
+//#endregion
+//#region extensions/voice-call/src/manager/store.ts
+const CALL_RECORD_EVENTS_NAMESPACE = "call-record-events";
+const CALL_RECORD_EVENT_CHUNKS_NAMESPACE = "call-record-event-chunks";
+const MAX_CALL_RECORD_EVENTS = 1e3;
+const CALL_RECORD_EVENT_META_MAX_ENTRIES = 1100;
+const CALL_RECORD_CHUNK_MAX_ENTRIES = 48048;
+const RAW_CALL_RECORD_CHUNK_BYTES = 47 * 1024;
+let callRecordEventSequence = 0;
+function resolveVoiceCallLegacyCallLogPath(storePath) {
+	return path.join(storePath, "calls.jsonl");
+}
+function resolvePluginStateEnv(storePath) {
+	return {
+		...process.env,
+		OPENCLAW_STATE_DIR: storePath
+	};
+}
+function createCallRecordStateStores(storePath) {
+	const runtime = getOptionalVoiceCallStateRuntime();
+	if (!runtime) return null;
+	const env = resolvePluginStateEnv(storePath);
+	return {
+		events: runtime.state.openSyncKeyedStore({
+			namespace: CALL_RECORD_EVENTS_NAMESPACE,
+			maxEntries: CALL_RECORD_EVENT_META_MAX_ENTRIES,
+			env
+		}),
+		chunks: runtime.state.openSyncKeyedStore({
+			namespace: CALL_RECORD_EVENT_CHUNKS_NAMESPACE,
+			maxEntries: CALL_RECORD_CHUNK_MAX_ENTRIES,
+			env
+		})
+	};
+}
+function tryCreateCallRecordStateStores(storePath) {
+	try {
+		return createCallRecordStateStores(storePath);
+	} catch (err) {
+		console.error("[voice-call] Failed to open SQLite call record store:", err);
+		return null;
+	}
+}
+function buildChunkKey(eventKey, index) {
+	return `${eventKey}:chunk:${String(index).padStart(4, "0")}`;
+}
+function buildVoiceCallLegacyJsonlEventKey(line, index) {
+	return `jsonl:${String(index).padStart(8, "0")}:${createHash("sha256").update(line).digest("hex")}`;
+}
+function nextCallRecordOrder() {
+	const sequence = callRecordEventSequence;
+	callRecordEventSequence = (callRecordEventSequence + 1) % 1e6;
+	return {
+		persistedAt: Date.now(),
+		sequence
+	};
+}
+function buildNewEventKey(order) {
+	return `event:${order.persistedAt.toString(36)}:${String(order.sequence).padStart(6, "0")}:${randomUUID()}`;
+}
+function parseEventKeySequence(key) {
+	const match = /^event:[^:]+:(\d+):/.exec(key);
+	return match ? Number.parseInt(match[1], 10) : 0;
+}
+function parseVoiceCallRecordLine(line, sequence = 0) {
+	if (!line.trim()) return null;
+	try {
+		const parsed = JSON.parse(line);
+		if (parsed && typeof parsed === "object" && parsed.version === 2) {
+			const envelope = parsed;
+			return {
+				call: CallRecordSchema.parse(envelope.call),
+				persistedAt: typeof envelope.persistedAt === "number" && Number.isFinite(envelope.persistedAt) ? envelope.persistedAt : 0,
+				sequence: typeof envelope.sequence === "number" && Number.isFinite(envelope.sequence) ? envelope.sequence : sequence,
+				orderKey: ""
+			};
+		}
+		return {
+			call: CallRecordSchema.parse(parsed),
+			persistedAt: 0,
+			sequence,
+			orderKey: ""
+		};
+	} catch {
+		return null;
+	}
+}
+function countCallRecordChunks(call) {
+	return Math.max(1, Math.ceil(Buffer.byteLength(JSON.stringify(call), "utf8") / RAW_CALL_RECORD_CHUNK_BYTES));
+}
+function prepareVoiceCallRecordForStorage(call) {
+	if (countCallRecordChunks(call) <= 48) return call;
+	const transcriptEntries = call.transcript.length;
+	const metadata = {
+		...call.metadata,
+		voiceCallPersistence: {
+			transcriptTruncated: true,
+			originalTranscriptEntries: transcriptEntries
+		}
+	};
+	const candidateInputs = [
+		{
+			transcript: call.transcript.slice(-20),
+			metadata
+		},
+		{
+			transcript: [],
+			metadata
+		},
+		{
+			transcript: [],
+			metadata: { voiceCallPersistence: {
+				transcriptTruncated: true,
+				originalTranscriptEntries: transcriptEntries,
+				metadataTruncated: true
+			} }
+		}
+	];
+	for (const candidateInput of candidateInputs) {
+		const candidate = CallRecordSchema.parse({
+			...call,
+			...candidateInput
+		});
+		if (countCallRecordChunks(candidate) <= 48) return candidate;
+	}
+	return call;
+}
+function registerCallRecordEvent(stores, eventKey, call, order) {
+	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
+	});
+	pruneCallRecordEvents(stores);
+}
+function deleteCallRecordEventRows(stores, eventKey) {
+	const meta = stores.events.lookup(eventKey);
+	stores.events.delete(eventKey);
+	if (!meta) return;
+	for (let index = 0; index < meta.chunkCount; index += 1) stores.chunks.delete(buildChunkKey(eventKey, index));
+}
+function pruneCallRecordEvents(stores) {
+	const rows = 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);
+}
+function readCallRecordEvent(stores, eventKey) {
+	const meta = stores.events.lookup(eventKey);
+	if (!meta) return null;
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = 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;
+}
+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);
+		return call ? {
+			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);
+}
+function persistCallRecord(storePath, call) {
+	try {
+		const stores = createCallRecordStateStores(storePath);
+		if (!stores) throw new Error("Voice Call state runtime not initialized");
+		const order = nextCallRecordOrder();
+		registerCallRecordEvent(stores, buildNewEventKey(order), call, order);
+	} catch (err) {
+		console.error("[voice-call] Failed to persist call record:", err);
+		throw err;
+	}
+}
+function loadActiveCallsFromStore(storePath) {
+	const stores = tryCreateCallRecordStateStores(storePath);
+	let calls = [];
+	try {
+		calls = stores ? readCallRecordEvents(stores) : [];
+	} 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(),
+		rejectedProviderCallIds: /* @__PURE__ */ new Set()
+	};
+	const callMap = /* @__PURE__ */ new Map();
+	for (const call of calls) callMap.set(call.callId, call);
+	const activeCalls = /* @__PURE__ */ new Map();
+	const providerCallIdMap = /* @__PURE__ */ new Map();
+	const processedEventIds = /* @__PURE__ */ new Set();
+	const rejectedProviderCallIds = /* @__PURE__ */ new Set();
+	for (const [callId, call] of callMap) {
+		for (const eventId of call.processedEventIds) processedEventIds.add(eventId);
+		if (TerminalStates.has(call.state)) continue;
+		activeCalls.set(callId, call);
+		if (call.providerCallId) providerCallIdMap.set(call.providerCallId, callId);
+	}
+	return {
+		activeCalls,
+		providerCallIdMap,
+		processedEventIds,
+		rejectedProviderCallIds
+	};
+}
+async function getCallHistoryFromStore(storePath, limit = 50) {
+	if (limit <= 0) return [];
+	const stores = tryCreateCallRecordStateStores(storePath);
+	if (stores) try {
+		return readCallRecordEvents(stores).slice(-limit);
+	} catch (err) {
+		console.error("[voice-call] Failed to read SQLite call history:", err);
+	}
+	return [];
+}
+//#endregion
+export { MAX_CALL_RECORD_EVENTS as a, getCallHistoryFromStore as c, persistCallRecord as d, prepareVoiceCallRecordForStorage as f, TerminalStates as h, CALL_RECORD_EVENT_META_MAX_ENTRIES as i, loadActiveCallsFromStore as l, setVoiceCallStateRuntime as m, CALL_RECORD_EVENTS_NAMESPACE as n, RAW_CALL_RECORD_CHUNK_BYTES as o, resolveVoiceCallLegacyCallLogPath as p, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as r, buildVoiceCallLegacyJsonlEventKey as s, CALL_RECORD_CHUNK_MAX_ENTRIES as t, parseVoiceCallRecordLine as u };

package/dist/{telnyx-CxEuPBOJ.js → telnyx-68EYJwaz.js}

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

package/dist/{twilio-DzQmSUQP.js → twilio-D0dUSGam.js}

@@ -1,7 +1,7 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
-import { a as getHeader, d as chunkAudio, h as mapVoiceToPolly, i as normalizeProviderStatus, m as escapeXml, n as isProviderStatusTerminal, r as mapProviderStatusToEndReason } from "./runtime-entry-DXf7kdXt.js";
-import { a as verifyTwilioWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-mCcsLRBb.js";
+import { a as getHeader, d as chunkAudio, h as mapVoiceToPolly, i as normalizeProviderStatus, m as escapeXml, n as isProviderStatusTerminal, r as mapProviderStatusToEndReason } from "./runtime-entry-13O0Ki99.js";
+import { a as verifyTwilioWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-tyxHyrev.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
@@ -251,17 +251,15 @@ var TwilioProvider = class TwilioProvider {
 		});
 	}
 	async updateLiveCallTwiml(providerCallId, twiml, operation) {
-		let retryIndex = 0;
-		while (true) try {
+		for (const retryDelayMs of TWILIO_CALL_UPDATE_RETRY_DELAYS_MS) try {
 			await this.apiRequest(`/Calls/${providerCallId}.json`, { Twiml: twiml });
 			return;
 		} catch (err) {
-			const retryDelayMs = TWILIO_CALL_UPDATE_RETRY_DELAYS_MS[retryIndex];
-			if (retryDelayMs === void 0 || !isTwilioCallNotInProgressError(err)) throw err;
-			retryIndex += 1;
+			if (!isTwilioCallNotInProgressError(err)) throw err;
 			console.warn(`[voice-call] Twilio ${operation} update hit call state race (21220); retrying in ${retryDelayMs}ms`);
 			await setTimeout$1(retryDelayMs);
 		}
+		await this.apiRequest(`/Calls/${providerCallId}.json`, { Twiml: twiml });
 	}
 	/**
 	* Verify Twilio webhook signature using HMAC-SHA1.
@@ -618,7 +616,9 @@ var TwilioProvider = class TwilioProvider {
 				chunkAttempts += 1;
 				if (sendAudioChunk(chunk).sent) chunkDelivered += 1;
 				const waitMs = nextChunkDueAt - Date.now();
-				if (waitMs > 0) await new Promise((resolve) => setTimeout(resolve, Math.ceil(waitMs)));
+				if (waitMs > 0) await new Promise((resolve) => {
+					setTimeout(resolve, Math.ceil(waitMs));
+				});
 				nextChunkDueAt += CHUNK_DELAY_MS;
 				if (signal.aborted) break;
 			}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.5.31-beta.2",
+  "version": "2026.5.31-beta.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/voice-call",
-      "version": "2026.5.31-beta.2",
+      "version": "2026.5.31-beta.4",
       "dependencies": {
         "commander": "14.0.3",
         "typebox": "1.1.39",
@@ -14,7 +14,7 @@
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.5.31-beta.2"
+        "openclaw": ">=2026.5.31-beta.4"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.5.31-beta.2",
+  "version": "2026.5.31-beta.4",
   "description": "OpenClaw voice-call plugin for Twilio, Telnyx, and Plivo phone calls.",
   "repository": {
     "type": "git",
@@ -14,7 +14,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.31-beta.2"
+    "openclaw": ">=2026.5.31-beta.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -31,10 +31,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.5.31-beta.2"
+      "pluginApi": ">=2026.5.31-beta.4"
     },
     "build": {
-      "openclawVersion": "2026.5.31-beta.2"
+      "openclawVersion": "2026.5.31-beta.4"
     },
     "release": {
       "publishToClawHub": true,