@openclaw/voice-call 2026.5.28 → 2026.5.31-beta.1

package/dist/{config-U-rgixyY.js → config-BKyRNKHF.js}

@@ -433,7 +433,7 @@ function normalizePhoneRouteKey(phone) {
 function resolveVoiceCallNumberRouteKey(config, phone) {
 	const routes = config.numbers;
 	if (!routes) return;
-	if (phone && Object.prototype.hasOwnProperty.call(routes, phone)) return phone;
+	if (phone && Object.hasOwn(routes, phone)) return phone;
 	const normalizedPhone = normalizePhoneRouteKey(phone);
 	if (!normalizedPhone) return;
 	return Object.keys(routes).find((routeKey) => normalizePhoneRouteKey(routeKey) === normalizedPhone);

package/dist/{config-compat-CokN3Zzr.js → config-compat-BLdRz9GR.js}

@@ -1,4 +1,4 @@
-import { t as VoiceCallConfigSchema } from "./config-U-rgixyY.js";
+import { t as VoiceCallConfigSchema } from "./config-BKyRNKHF.js";
 import { asOptionalRecord, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/voice-call/src/config-compat.ts
 const VOICE_CALL_LEGACY_CONFIG_REMOVAL_VERSION = "2026.6.0";
@@ -61,7 +61,7 @@ function collectVoiceCallLegacyConfigIssues(value) {
 		replacement: "streaming.providers.openai.vadThreshold",
 		message: "Move streaming.vadThreshold to streaming.providers.openai.vadThreshold."
 	});
-	if (realtimeAgentContext && Object.prototype.hasOwnProperty.call(realtimeAgentContext, "includeSystemPrompt")) issues.push({
+	if (realtimeAgentContext && Object.hasOwn(realtimeAgentContext, "includeSystemPrompt")) issues.push({
 		path: "realtime.agentContext.includeSystemPrompt",
 		replacement: "realtime.agentContext",
 		message: "Remove realtime.agentContext.includeSystemPrompt; realtime context now uses the generated agent prompt."
@@ -130,7 +130,7 @@ function migrateVoiceCallLegacyConfigInput(params) {
 	else if (typeof streaming?.silenceDurationMs === "number") changes.push(`Removed invalid ${configPathPrefix}.streaming.silenceDurationMs.`);
 	if (getNumber(streaming, "vadThreshold") !== void 0) changes.push(`Moved ${configPathPrefix}.streaming.vadThreshold → ${configPathPrefix}.streaming.providers.openai.vadThreshold.`);
 	else if (typeof streaming?.vadThreshold === "number") changes.push(`Removed invalid ${configPathPrefix}.streaming.vadThreshold.`);
-	if (realtimeAgentContext && Object.prototype.hasOwnProperty.call(realtimeAgentContext, "includeSystemPrompt")) changes.push(`Removed ${configPathPrefix}.realtime.agentContext.includeSystemPrompt.`);
+	if (realtimeAgentContext && Object.hasOwn(realtimeAgentContext, "includeSystemPrompt")) changes.push(`Removed ${configPathPrefix}.realtime.agentContext.includeSystemPrompt.`);
 	return {
 		config,
 		changes,

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

@@ -1,8 +1,9 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
-import { a as getHeader } from "./runtime-entry-DwBgs2Sq.js";
+import { a as getHeader } from "./runtime-entry-DXf7kdXt.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";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
@@ -29,7 +30,7 @@ function createSkippedVerificationReplayKey(provider, ctx) {
 	return `${provider}:skip:${sha256Hex(`${ctx.method}\n${ctx.url}\n${ctx.rawBody}`)}`;
 }
 function pruneReplayCache(cache, now) {
-	for (const [key, expiresAt] of cache.seenUntil) if (expiresAt <= now) cache.seenUntil.delete(key);
+	for (const [key, expiresAt] of cache.seenUntil) if (!isFutureDateTimestampMs(expiresAt, { nowMs: now })) cache.seenUntil.delete(key);
 	while (cache.seenUntil.size > REPLAY_CACHE_MAX_ENTRIES) {
 		const oldest = cache.seenUntil.keys().next().value;
 		if (!oldest) break;
@@ -41,8 +42,9 @@ function markReplay(cache, replayKey) {
 	cache.calls += 1;
 	if (cache.calls % REPLAY_CACHE_PRUNE_INTERVAL === 0) pruneReplayCache(cache, now);
 	const existing = cache.seenUntil.get(replayKey);
-	if (existing && existing > now) return true;
-	cache.seenUntil.set(replayKey, now + REPLAY_WINDOW_MS);
+	if (existing !== void 0 && isFutureDateTimestampMs(existing, { nowMs: now })) return true;
+	const expiresAt = resolveExpiresAtMsFromDurationMs(REPLAY_WINDOW_MS, { nowMs: now });
+	if (expiresAt !== void 0) cache.seenUntil.set(replayKey, expiresAt);
 	if (cache.seenUntil.size > REPLAY_CACHE_MAX_ENTRIES) pruneReplayCache(cache, now);
 	return false;
 }

package/dist/index.js

@@ -1,10 +1,11 @@
 import { definePluginEntry, sleep } from "./runtime-api.js";
 import "./api.js";
-import { i as resolveVoiceCallConfig, s as validateProviderConfig } from "./config-U-rgixyY.js";
-import { c as getTailscaleSelfInfo, l as setupTailscaleExposureRoute, o as resolveWebhookExposureStatus, p as resolveUserPath, s as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime } from "./runtime-entry-DwBgs2Sq.js";
-import { i as parseVoiceCallPluginConfig, r as normalizeVoiceCallLegacyConfigInput, t as formatVoiceCallLegacyConfigWarnings } from "./config-compat-CokN3Zzr.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 { 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";
+import { MAX_TCP_PORT, MAX_TIMER_TIMEOUT_MS, addTimerTimeoutGraceMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { Type } from "typebox";
 import fs from "node:fs";
@@ -12,7 +13,6 @@ import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { format } from "node:util";
-import { MAX_TCP_PORT, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 //#region extensions/voice-call/src/cli.ts
 const VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS = 5e3;
 const VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS = 3e4;
@@ -54,10 +54,13 @@ async function callVoiceCallGateway(method, params, opts) {
 	}
 }
 function resolveGatewayOperationTimeoutMs(config) {
-	return Math.max(VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS, config.ringTimeoutMs + 5e3);
+	return Math.max(VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS, addTimerTimeoutGraceMs(config.ringTimeoutMs) ?? 1);
 }
 function resolveGatewayContinueTimeoutMs(config) {
-	return config.transcriptTimeoutMs + VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS + VOICE_CALL_GATEWAY_TRANSCRIPT_BUFFER_MS;
+	return clampTimerTimeoutMs(config.transcriptTimeoutMs + VOICE_CALL_GATEWAY_OPERATION_TIMEOUT_MS + VOICE_CALL_GATEWAY_TRANSCRIPT_BUFFER_MS) ?? 1;
+}
+function resolveVoiceCallDeadlineMs(timeoutMs, nowMs = Date.now()) {
+	return nowMs + (clampTimerTimeoutMs(timeoutMs) ?? MAX_TIMER_TIMEOUT_MS);
 }
 function isUnknownGatewayMethod(err, method) {
 	return formatErrorMessage(err).includes(`unknown method: ${method}`);
@@ -67,7 +70,7 @@ function readGatewayOperationId(payload) {
 	throw new Error("voicecall gateway response missing operationId");
 }
 function readGatewayPollTimeoutMs(payload, fallbackTimeoutMs) {
-	if (isRecord(payload) && typeof payload.pollTimeoutMs === "number") return Math.max(1, Math.ceil(payload.pollTimeoutMs));
+	if (isRecord(payload) && typeof payload.pollTimeoutMs === "number") return clampTimerTimeoutMs(payload.pollTimeoutMs) ?? fallbackTimeoutMs;
 	return fallbackTimeoutMs;
 }
 function readCompletedContinueResult(payload) {
@@ -84,7 +87,7 @@ function readCompletedContinueResult(payload) {
 	throw new Error("voicecall gateway response has unknown operation status");
 }
 async function pollVoiceCallContinueGateway(params) {
-	const deadlineMs = Date.now() + params.timeoutMs;
+	const deadlineMs = resolveVoiceCallDeadlineMs(params.timeoutMs);
 	while (Date.now() <= deadlineMs) {
 		const gateway = await callVoiceCallGateway("voicecall.continue.result", { operationId: params.operationId }, { timeoutMs: VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS });
 		if (!gateway.ok) throw new Error(`gateway unavailable while waiting for voicecall continue result: ${formatErrorMessage(gateway.error)}`);
@@ -218,7 +221,10 @@ async function initiateCallViaGatewayOrRuntime(params) {
 	});
 }
 function registerVoiceCallCli(params) {
-	const { program, config, ensureRuntime, logger } = params;
+	const { program, config, ensureRuntime, stateRuntime } = params;
+	const ensureHistoryStateRuntime = () => {
+		if (stateRuntime) setVoiceCallStateRuntime({ state: stateRuntime });
+	};
 	const root = program.command("voicecall").description("Voice call utilities").addHelpText("after", () => `\nDocs: https://docs.openclaw.ai/cli/voicecall\n`);
 	root.command("setup").description("Show Voice Call provider and webhook setup status").option("--json", "Print machine-readable JSON").action((options) => {
 		const status = buildSetupStatus(config);
@@ -408,54 +414,81 @@ function registerVoiceCallCli(params) {
 		const file = options.file;
 		const since = parseVoiceCallIntOption(options.since, "--since", { min: 0 });
 		const pollMs = parseVoiceCallIntOption(options.poll, "--poll", { min: 50 });
-		if (!fs.existsSync(file)) {
-			logger.error(`No log file at ${file}`);
-			process.exit(1);
-		}
-		const initial = fs.readFileSync(file, "utf8");
-		const lines = initial.split("\n").filter(Boolean);
-		for (const line of lines.slice(Math.max(0, lines.length - since))) writeStdoutLine(line);
-		let offset = Buffer.byteLength(initial, "utf8");
-		for (;;) {
-			try {
-				const stat = fs.statSync(file);
-				if (stat.size < offset) offset = 0;
-				if (stat.size > offset) {
-					const fd = fs.openSync(file, "r");
-					try {
-						const buf = Buffer.alloc(stat.size - offset);
-						fs.readSync(fd, buf, 0, buf.length, offset);
-						offset = stat.size;
-						const text = buf.toString("utf8");
-						for (const line of text.split("\n").filter(Boolean)) writeStdoutLine(line);
-					} finally {
-						fs.closeSync(fd);
-					}
+		const tailSqliteHistory = async (initialLimit) => {
+			ensureHistoryStateRuntime();
+			const seen = /* @__PURE__ */ new Set();
+			const printCall = (call) => {
+				const line = JSON.stringify(call);
+				if (!seen.has(line)) {
+					seen.add(line);
+					writeStdoutLine(line);
 				}
-			} catch {}
-			await sleep(pollMs);
-		}
+			};
+			if (initialLimit > 0) for (const call of await getCallHistoryFromStore(path.dirname(file), initialLimit)) printCall(call);
+			for (;;) {
+				try {
+					for (const call of await getCallHistoryFromStore(path.dirname(file), 1e3)) printCall(call);
+				} catch {}
+				await sleep(pollMs);
+			}
+		};
+		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") {
+			const initial = fs.readFileSync(file, "utf8");
+			const lines = initial.split("\n").filter(Boolean);
+			for (const line of lines.slice(Math.max(0, lines.length - since))) writeStdoutLine(line);
+			let offset = Buffer.byteLength(initial, "utf8");
+			for (;;) {
+				try {
+					const stat = fs.statSync(file);
+					if (stat.size < offset) offset = 0;
+					if (stat.size > offset) {
+						const fd = fs.openSync(file, "r");
+						try {
+							const buf = Buffer.alloc(stat.size - offset);
+							fs.readSync(fd, buf, 0, buf.length, offset);
+							offset = stat.size;
+							const text = buf.toString("utf8");
+							for (const line of text.split("\n").filter(Boolean)) writeStdoutLine(line);
+						} finally {
+							fs.closeSync(fd);
+						}
+					}
+				} catch {}
+				await sleep(pollMs);
+			}
+		} else await tailSqliteHistory(since);
 	});
 	root.command("latency").description("Summarize turn latency metrics from voice-call JSONL logs").option("--file <path>", "Path to calls.jsonl", resolveDefaultStorePath(config)).option("--last <n>", "Analyze last N records", "200").action(async (options) => {
 		const file = options.file;
 		const last = parseVoiceCallIntOption(options.last, "--last", { min: 1 });
-		if (!fs.existsSync(file)) throw new Error("No log file at " + file);
-		const lines = fs.readFileSync(file, "utf8").split("\n").filter(Boolean).slice(-last);
+		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") writeVoiceCallLatencySummary(fs.readFileSync(file, "utf8").split("\n").filter(Boolean).slice(-last).map((line) => {
+			try {
+				const parsed = JSON.parse(line);
+				return parsed.call ?? parsed;
+			} catch {
+				return null;
+			}
+		}).filter((call) => call !== null));
+		else {
+			ensureHistoryStateRuntime();
+			writeVoiceCallLatencySummary(await getCallHistoryFromStore(path.dirname(file), last));
+		}
+	});
+	function writeVoiceCallLatencySummary(calls) {
 		const turnLatencyMs = [];
 		const listenWaitMs = [];
-		for (const line of lines) try {
-			const parsed = JSON.parse(line);
-			const latency = parsed.metadata?.lastTurnLatencyMs;
-			const listenWait = parsed.metadata?.lastTurnListenWaitMs;
+		for (const call of calls) {
+			const latency = call.metadata?.lastTurnLatencyMs;
+			const listenWait = call.metadata?.lastTurnListenWaitMs;
 			if (typeof latency === "number" && Number.isFinite(latency)) turnLatencyMs.push(latency);
 			if (typeof listenWait === "number" && Number.isFinite(listenWait)) listenWaitMs.push(listenWait);
-		} catch {}
+		}
 		writeStdoutJson({
-			recordsScanned: lines.length,
+			recordsScanned: calls.length,
 			turnLatency: summarizeSeries(turnLatencyMs),
 			listenWait: summarizeSeries(listenWaitMs)
 		});
-	});
+	}
 	root.command("expose").description("Enable/disable Tailscale serve/funnel for the webhook").option("--mode <mode>", "off | serve (tailnet) | funnel (public)", "funnel").option("--path <path>", "Tailscale path to expose (recommend matching serve.path)").option("--port <port>", "Local webhook port").option("--serve-path <path>", "Local webhook path").action(async (options) => {
 		const mode = resolveMode(options.mode ?? "funnel");
 		const servePort = parseVoiceCallIntOption(options.port ?? String(config.serve.port ?? 3334), "--port", {
@@ -509,7 +542,7 @@ function createVoiceCallContinueOperationStore(params) {
 	const operations = /* @__PURE__ */ new Map();
 	const resolvePollTimeoutMs = (rt) => {
 		const ttsTimeoutMs = rt.config.tts?.timeoutMs ?? params.config.tts?.timeoutMs ?? params.coreConfig.messages?.tts?.timeoutMs ?? 8e3;
-		return (rt.config.transcriptTimeoutMs ?? params.config.transcriptTimeoutMs) + ttsTimeoutMs + VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS;
+		return resolveTimerTimeoutMs((rt.config.transcriptTimeoutMs ?? params.config.transcriptTimeoutMs) + ttsTimeoutMs + VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS, VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS);
 	};
 	const scheduleCleanup = (operationId) => {
 		setTimeout(() => {
@@ -925,6 +958,7 @@ var voice_call_default = definePluginEntry({
 						coreConfig: api.config,
 						fullConfig: api.config,
 						agentRuntime: api.runtime.agent,
+						stateRuntime: api.runtime.state,
 						ttsRuntime: api.runtime.tts,
 						logger: api.logger
 					});
@@ -954,10 +988,11 @@ var voice_call_default = definePluginEntry({
 		const describeHistoricalCall = async (rt, callId) => {
 			const call = (await rt.manager.getCallHistory(100)).toReversed().find((candidate) => candidate.callId === callId || candidate.providerCallId === callId);
 			if (!call) return;
+			const endedAt = timestampMsToIsoString(call.endedAt);
 			return `call is not active (${[
 				`last state=${call.state}`,
 				call.endReason ? `endReason=${call.endReason}` : void 0,
-				call.endedAt ? `endedAt=${new Date(call.endedAt).toISOString()}` : void 0
+				endedAt ? `endedAt=${endedAt}` : void 0
 			].filter(Boolean).join(", ")})`;
 		};
 		const resolveCallMessageRequest = async (params) => {
@@ -1296,6 +1331,7 @@ var voice_call_default = definePluginEntry({
 			program,
 			config,
 			ensureRuntime,
+			stateRuntime: api.runtime.state,
 			logger: api.logger
 		}), { commands: ["voicecall"] });
 		api.registerService({

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

@@ -1,5 +1,5 @@
-import { a as getHeader, m as escapeXml } from "./runtime-entry-DwBgs2Sq.js";
-import { n as reconstructWebhookUrl, r as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-hXuXY1dk.js";
+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 { 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-DQDCDHv2.js → realtime-handler-Crs3kty2.js}

@@ -1,4 +1,5 @@
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, buildRealtimeVoiceAgentConsultWorkingResponse, createRealtimeVoiceBridgeSession, createRealtimeVoiceForcedConsultCoordinator, createTalkSessionController, readRealtimeVoiceConsultQuestion, readSpeakableRealtimeVoiceToolResult, recordTalkObservabilityEvent } from "openclaw/plugin-sdk/realtime-voice";
 import { randomUUID } from "node:crypto";
@@ -99,8 +100,8 @@ var RealtimeAudioPacer = class {
 function calculateMulawRms(muLaw) {
 	if (muLaw.length === 0) return 0;
 	let sum = 0;
-	for (let i = 0; i < muLaw.length; i += 1) {
-		const normalized = (MULAW_LINEAR_SAMPLES[muLaw[i] ?? 0] ?? 0) / PCM16_MAX_AMPLITUDE;
+	for (const sample of muLaw) {
+		const normalized = (MULAW_LINEAR_SAMPLES[sample] ?? 0) / PCM16_MAX_AMPLITUDE;
 		sum += normalized * normalized;
 	}
 	return Math.sqrt(sum / muLaw.length);
@@ -578,18 +579,20 @@ var RealtimeCallHandler = class {
 	}
 	issueStreamToken(meta = {}) {
 		const token = randomUUID();
-		this.pendingStreamTokens.set(token, {
-			expiry: Date.now() + STREAM_TOKEN_TTL_MS,
+		const now = Date.now();
+		const expiry = resolveExpiresAtMsFromDurationMs(STREAM_TOKEN_TTL_MS, { nowMs: now });
+		if (expiry !== void 0) this.pendingStreamTokens.set(token, {
+			expiry,
 			...meta
 		});
-		for (const [candidate, entry] of this.pendingStreamTokens) if (Date.now() > entry.expiry) this.pendingStreamTokens.delete(candidate);
+		for (const [candidate, entry] of this.pendingStreamTokens) if (!isFutureDateTimestampMs(entry.expiry, { nowMs: now })) this.pendingStreamTokens.delete(candidate);
 		return token;
 	}
 	consumeStreamToken(token) {
 		const entry = this.pendingStreamTokens.get(token);
 		if (!entry) return null;
 		this.pendingStreamTokens.delete(token);
-		if (Date.now() > entry.expiry) return null;
+		if (!isFutureDateTimestampMs(entry.expiry)) return null;
 		return {
 			from: entry.from,
 			to: entry.to,

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

@@ -1,5 +1,5 @@
-import { o as resolveVoiceCallSessionKey } from "./config-U-rgixyY.js";
-import { f as resolveVoiceResponseModel } from "./runtime-entry-DwBgs2Sq.js";
+import { o as resolveVoiceCallSessionKey } from "./config-BKyRNKHF.js";
+import { f as resolveVoiceResponseModel } from "./runtime-entry-DXf7kdXt.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-DwBgs2Sq.js → runtime-entry-DXf7kdXt.js}

@@ -1,16 +1,18 @@
 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-U-rgixyY.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 { 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 from "node:crypto";
+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 { parseTtsDirectives } from "openclaw/plugin-sdk/speech";
 import { spawn } from "node:child_process";
 import http from "node:http";
@@ -179,12 +181,224 @@ 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: path.join(storePath, "calls.jsonl"),
-		content: `${JSON.stringify(call)}\n`,
+		filePath: logPath,
+		content: `${JSON.stringify({
+			version: 2,
+			...order,
+			call
+		})}\n`,
 		rejectSymlinkParents: true
 	}).catch((err) => {
 		console.error("[voice-call] Failed to persist call record:", err);
@@ -194,23 +408,22 @@ function persistCallRecord(storePath, call) {
 	pendingPersistWrites.add(write);
 }
 function loadActiveCallsFromStore(storePath) {
-	const logPath = path.join(storePath, "calls.jsonl");
-	const content = privateFileStoreSync(storePath).readTextIfExists(path.basename(logPath));
-	if (content === null) return {
+	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 lines = content.split("\n");
 	const callMap = /* @__PURE__ */ new Map();
-	for (const line of lines) {
-		if (!line.trim()) continue;
-		try {
-			const call = CallRecordSchema.parse(JSON.parse(line));
-			callMap.set(call.callId, call);
-		} catch {}
-	}
+	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();
@@ -229,17 +442,40 @@ function loadActiveCallsFromStore(storePath) {
 	};
 }
 async function getCallHistoryFromStore(storePath, limit = 50) {
-	const logPath = path.join(storePath, "calls.jsonl");
+	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 line of lines.slice(-limit)) try {
-		const parsed = CallRecordSchema.parse(JSON.parse(line));
-		calls.push(parsed);
-	} catch {}
+	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);
+	const timeoutMs = Math.floor(seconds * 1e3);
+	return resolveTimerTimeoutMs(Number.isFinite(timeoutMs) ? timeoutMs : MAX_TIMER_TIMEOUT_MS, minMs, minMs);
+}
+function resolveVoiceCallTimerDelayMs(timeoutMs, fallbackMs = 1) {
+	return resolveTimerTimeoutMs(timeoutMs, fallbackMs);
+}
 //#endregion
 //#region extensions/voice-call/src/manager/timers.ts
 function clearMaxDurationTimer(ctx, callId) {
@@ -251,7 +487,7 @@ function clearMaxDurationTimer(ctx, callId) {
 }
 function startMaxDurationTimer(params) {
 	clearMaxDurationTimer(params.ctx, params.callId);
-	const maxDurationMs = params.timeoutMs ?? params.ctx.config.maxDurationSeconds * 1e3;
+	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);
@@ -287,7 +523,7 @@ function resolveTranscriptWaiter(ctx, callId, transcript, turnToken) {
 }
 function waitForFinalTranscript(ctx, callId, turnToken) {
 	if (ctx.transcriptWaiters.has(callId)) return Promise.reject(/* @__PURE__ */ new Error("Already waiting for transcript"));
-	const timeoutMs = ctx.config.transcriptTimeoutMs;
+	const timeoutMs = resolveVoiceCallTimerDelayMs(ctx.config.transcriptTimeoutMs);
 	return new Promise((resolve, reject) => {
 		const timeout = setTimeout(() => {
 			ctx.transcriptWaiters.delete(callId);
@@ -654,6 +890,7 @@ async function speakInitialMessage(ctx, providerCallId) {
 		}
 		if (mode === "notify") {
 			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);
@@ -661,7 +898,7 @@ async function speakInitialMessage(ctx, providerCallId) {
 					console.log(`[voice-call] Notify mode: hanging up call ${call.callId}`);
 					await endCall(ctx, call.callId);
 				}
-			}, delaySec * 1e3);
+			}, delayMs);
 		} else if (mode === "conversation" && ctx.provider && shouldStartListeningAfterInitialMessage(ctx)) {
 			transitionState(call, "listening");
 			persistCallRecord(ctx.storePath, call);
@@ -1047,7 +1284,7 @@ var CallManager = class {
 		let skippedAlreadyElapsedTimers = 0;
 		for (const [callId, call] of verified) if (call.answeredAt && !TerminalStates.has(call.state)) {
 			const elapsed = Date.now() - call.answeredAt;
-			const maxDurationMs = this.config.maxDurationSeconds * 1e3;
+			const maxDurationMs = resolveVoiceCallSecondsTimerDelayMs(this.config.maxDurationSeconds);
 			if (elapsed >= maxDurationMs) {
 				verified.delete(callId);
 				if (call.providerCallId) this.providerCallIdMap.delete(call.providerCallId);
@@ -1074,7 +1311,7 @@ var CallManager = class {
 	*/
 	async verifyRestoredCalls(provider, candidates) {
 		if (candidates.size === 0) return /* @__PURE__ */ new Map();
-		const maxAgeMs = this.config.maxDurationSeconds * 1e3;
+		const maxAgeMs = resolveVoiceCallSecondsTimerDelayMs(this.config.maxDurationSeconds);
 		const now = Date.now();
 		const verified = /* @__PURE__ */ new Map();
 		const verifyTasks = [];
@@ -1348,7 +1585,7 @@ function createTelephonyTtsProvider(params) {
 	const providerConfigs = collectTelephonyProviderConfigs(ttsConfig);
 	const activeProvider = normalizeProviderId(ttsConfig?.provider);
 	return {
-		synthesisTimeoutMs: mergedConfig.messages?.tts?.timeoutMs ?? 8e3,
+		synthesisTimeoutMs: resolveTimerTimeoutMs(mergedConfig.messages?.tts?.timeoutMs, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS),
 		synthesizeForTelephony: async (text) => {
 			const directives = parseTtsDirectives(text, modelOverrides, {
 				cfg: mergedConfig,
@@ -1506,7 +1743,6 @@ function runTailscaleCommand(args, timeoutMs = 2500) {
 			text: ""
 		};
 		let settled = false;
-		let timer;
 		const finish = (result) => {
 			if (settled) return;
 			settled = true;
@@ -1523,7 +1759,7 @@ function runTailscaleCommand(args, timeoutMs = 2500) {
 				});
 			}
 		});
-		timer = setTimeout(() => {
+		const timer = setTimeout(() => {
 			proc.kill("SIGKILL");
 			finish({
 				code: -1,
@@ -1938,7 +2174,7 @@ var MediaStreamHandler = class {
 		this.ttsPlaying = /* @__PURE__ */ new Map();
 		this.ttsActiveControllers = /* @__PURE__ */ new Map();
 		this.config = config;
-		this.preStartTimeoutMs = config.preStartTimeoutMs ?? DEFAULT_PRE_START_TIMEOUT_MS;
+		this.preStartTimeoutMs = resolveTimerTimeoutMs(config.preStartTimeoutMs, DEFAULT_PRE_START_TIMEOUT_MS);
 		this.maxPendingConnections = config.maxPendingConnections ?? DEFAULT_MAX_PENDING_CONNECTIONS;
 		this.maxPendingConnectionsPerIp = config.maxPendingConnectionsPerIp ?? DEFAULT_MAX_PENDING_CONNECTIONS_PER_IP;
 		this.maxConnections = config.maxConnections ?? DEFAULT_MAX_CONNECTIONS;
@@ -2588,7 +2824,7 @@ function loadRealtimeTranscriptionRuntime() {
 	return realtimeTranscriptionRuntimePromise;
 }
 function loadResponseGeneratorModule() {
-	responseGeneratorModulePromise ??= import("./response-generator-C8EHsqMw.js");
+	responseGeneratorModulePromise ??= import("./response-generator-Cu4sOiUO.js");
 	return responseGeneratorModulePromise;
 }
 function sanitizeTranscriptForLog(value) {
@@ -2598,7 +2834,7 @@ function sanitizeTranscriptForLog(value) {
 }
 function appendRecentTalkEventMetadata(call, event) {
 	const metadata = call.metadata ?? {};
-	const recent = Array.isArray(metadata.recentTalkEvents) ? metadata.recentTalkEvents.filter((entry) => !!entry && typeof entry === "object" && !Array.isArray(entry)) : [];
+	const recent = Array.isArray(metadata.recentTalkEvents) ? metadata.recentTalkEvents.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)) : [];
 	recent.push({
 		at: event.timestamp,
 		type: event.type,
@@ -3094,8 +3330,11 @@ var VoiceCallWebhookServer = class {
 			this.webhookInFlightLimiter.release(inFlightKey);
 		}
 	}
-	pruneReplayResponses(now) {
-		for (const [key, entry] of this.replayResponses) if (entry.expiresAt <= now) this.replayResponses.delete(key);
+	pruneReplayResponses(rawNow) {
+		const now = asDateTimestampMs(rawNow);
+		if (now !== void 0) {
+			for (const [key, entry] of this.replayResponses) if (entry.expiresAt <= now) this.replayResponses.delete(key);
+		}
 		while (this.replayResponses.size > WEBHOOK_REPLAY_RESPONSE_MAX_ENTRIES) {
 			const oldest = this.replayResponses.keys().next().value;
 			if (!oldest) break;
@@ -3103,9 +3342,9 @@ var VoiceCallWebhookServer = class {
 		}
 	}
 	async getCachedReplayResponse(key) {
-		const now = Date.now();
+		const now = asDateTimestampMs(Date.now());
 		const entry = this.replayResponses.get(key);
-		if (!entry) return null;
+		if (!entry || now === void 0) return null;
 		if (entry.expiresAt <= now) {
 			this.replayResponses.delete(key);
 			return null;
@@ -3114,14 +3353,15 @@ var VoiceCallWebhookServer = class {
 	}
 	async cacheReplayResponse(key, buildResponse) {
 		const now = Date.now();
+		const expiresAt = resolveExpiresAtMsFromDurationMs(WEBHOOK_REPLAY_RESPONSE_TTL_MS, { nowMs: now });
 		this.replayResponseCacheCalls += 1;
 		if (this.replayResponseCacheCalls % WEBHOOK_REPLAY_RESPONSE_PRUNE_INTERVAL === 0) this.pruneReplayResponses(now);
 		const response = buildResponse().then(cloneWebhookResponsePayload).catch((err) => {
 			this.replayResponses.delete(key);
 			throw err;
 		});
-		this.replayResponses.set(key, {
-			expiresAt: now + WEBHOOK_REPLAY_RESPONSE_TTL_MS,
+		if (expiresAt !== void 0) this.replayResponses.set(key, {
+			expiresAt,
 			response
 		});
 		if (this.replayResponses.size > WEBHOOK_REPLAY_RESPONSE_MAX_ENTRIES) this.pruneReplayResponses(now);
@@ -3268,15 +3508,15 @@ let mockProviderPromise;
 let realtimeVoiceRuntimePromise;
 let realtimeHandlerPromise;
 function loadTelnyxProvider() {
-	telnyxProviderPromise ??= import("./telnyx-C8sgJugJ.js");
+	telnyxProviderPromise ??= import("./telnyx-CxEuPBOJ.js");
 	return telnyxProviderPromise;
 }
 function loadTwilioProvider() {
-	twilioProviderPromise ??= import("./twilio-CpBg6Ir5.js");
+	twilioProviderPromise ??= import("./twilio-DzQmSUQP.js");
 	return twilioProviderPromise;
 }
 function loadPlivoProvider() {
-	plivoProviderPromise ??= import("./plivo-CVgE_V_c.js");
+	plivoProviderPromise ??= import("./plivo-Dpf08ZVJ.js");
 	return plivoProviderPromise;
 }
 function loadMockProvider() {
@@ -3288,7 +3528,7 @@ function loadRealtimeVoiceRuntime() {
 	return realtimeVoiceRuntimePromise;
 }
 function loadRealtimeHandler() {
-	realtimeHandlerPromise ??= import("./realtime-handler-DQDCDHv2.js");
+	realtimeHandlerPromise ??= import("./realtime-handler-Crs3kty2.js");
 	return realtimeHandlerPromise;
 }
 function resolveVoiceCallConsultSessionKey(call) {
@@ -3394,7 +3634,7 @@ async function resolveRealtimeProvider(params) {
 	});
 }
 async function createVoiceCallRuntime(params) {
-	const { config: rawConfig, coreConfig, fullConfig, agentRuntime, ttsRuntime, logger } = params;
+	const { config: rawConfig, coreConfig, fullConfig, agentRuntime, stateRuntime, ttsRuntime, logger } = params;
 	const log = logger ?? {
 		info: console.log,
 		warn: console.warn,
@@ -3408,6 +3648,7 @@ async function createVoiceCallRuntime(params) {
 	const validation = validateProviderConfig(config);
 	if (!validation.valid) throw new Error(`Invalid voice-call config: ${validation.errors.join("; ")}`);
 	const provider = await resolveProvider(config);
+	if (stateRuntime) setVoiceCallStateRuntime({ state: stateRuntime });
 	const manager = new CallManager(config);
 	const realtimeProvider = config.realtime.enabled ? await resolveRealtimeProvider({
 		config,
@@ -3552,4 +3793,4 @@ async function createVoiceCallRuntime(params) {
 	}
 }
 //#endregion
-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 };
+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 };

package/dist/runtime-entry.js

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

package/dist/setup-api.js

@@ -1,4 +1,4 @@
-import { n as migrateVoiceCallLegacyConfigInput } from "./config-compat-CokN3Zzr.js";
+import { n as migrateVoiceCallLegacyConfigInput } from "./config-compat-BLdRz9GR.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/voice-call/setup-api.ts

package/dist/{telnyx-C8sgJugJ.js → telnyx-CxEuPBOJ.js}

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

package/dist/{twilio-CpBg6Ir5.js → twilio-DzQmSUQP.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-DwBgs2Sq.js";
-import { a as verifyTwilioWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-hXuXY1dk.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 { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";

package/node_modules/typebox/build/type/script/mapping.d.mts

@@ -164,10 +164,13 @@ export type TExtendsMapping<Input extends [unknown, unknown, unknown, unknown, u
 export declare function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown] | []): unknown;
 export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown> = (Input extends ['(', infer Type extends T.TSchema, ')'] ? Type : Input extends infer Type extends T.TSchema ? Type : never);
 export declare function BaseMapping(input: [unknown, unknown, unknown] | unknown): unknown;
+export type TWithMapping<Input extends [unknown, unknown] | []> = (Input extends ['with', infer Options extends Record<PropertyKey, unknown>] ? Options : []);
+export declare function WithMapping(input: [unknown, unknown] | []): unknown;
 type TFactorIndexArray<Type extends T.TSchema, IndexArray extends unknown[]> = (IndexArray extends [infer Left extends T.TSchema[], ...infer Right extends unknown[]] ? (Left extends [infer Indexer extends T.TSchema] ? TFactorIndexArray<C.TIndexDeferred<Type, Indexer>, Right> : Left extends [] ? TFactorIndexArray<T.TArray<Type>, Right> : T.TNever) : Type);
 type TFactorExtends<Type extends T.TSchema, Extends extends unknown[]> = (Extends extends [infer Right extends T.TSchema, infer True extends T.TSchema, infer False extends T.TSchema] ? C.TConditionalDeferred<Type, Right, True, False> : Type);
-export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[]] ? KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend> : never);
-export declare function FactorMapping(input: [unknown, unknown, unknown, unknown]): unknown;
+type TFactorWith<Type extends T.TSchema, With extends unknown> = (With extends Record<PropertyKey, unknown> ? C.TOptionsDeferred<Type, With> : Type);
+export type TFactorMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer KeyOf extends boolean, infer Type extends T.TSchema, infer IndexArray extends unknown[], infer Extend extends unknown[], infer WithClause extends unknown] ? TFactorWith<KeyOf extends true ? TFactorExtends<C.TKeyOfDeferred<TFactorIndexArray<Type, IndexArray>>, Extend> : TFactorExtends<TFactorIndexArray<Type, IndexArray>, Extend>, WithClause> : never);
+export declare function FactorMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 type TExprBinaryMapping<Left extends T.TSchema, Rest extends unknown[]> = (Rest extends [infer Operator extends unknown, infer Right extends T.TSchema, infer Next extends unknown[]] ? (TExprBinaryMapping<Right, Next> extends infer Schema extends T.TSchema ? (Operator extends '&' ? (Schema extends T.TIntersect<infer Types extends T.TSchema[]> ? T.TIntersect<[Left, ...Types]> : T.TIntersect<[Left, Schema]>) : Operator extends '|' ? (Schema extends T.TUnion<infer Types extends T.TSchema[]> ? T.TUnion<[Left, ...Types]> : T.TUnion<[Left, Schema]>) : never) : never) : Left);
 export type TExprTermTailMapping<Input extends [unknown, unknown, unknown] | []> = (Input);
 export declare function ExprTermTailMapping(input: [unknown, unknown, unknown] | []): unknown;

package/node_modules/typebox/build/type/script/mapping.mjs

@@ -185,27 +185,34 @@ export function BaseMapping(input) {
         ? input[1]
         : input;
 }
+export function WithMapping(input) {
+    return Guard.IsEqual(input.length, 2) ? input[1] : [];
+}
 // deno-coverage-ignore-start
-// ...
-const FactorIndexArray = (Type, indexArray) => {
+function FactorIndexArray(Type, indexArray) {
     return indexArray.reduce((result, left) => {
         const _left = left;
         return (Guard.IsEqual(_left.length, 1) ? C.IndexDeferred(result, _left[0]) :
             Guard.IsEqual(_left.length, 0) ? T.Array(result) :
                 Unreachable());
     }, Type);
-};
+}
 // deno-coverage-ignore-stop
-const FactorExtends = (type, extend) => {
+function FactorExtends(type, extend) {
     return Guard.IsEqual(extend.length, 3)
         ? C.ConditionalDeferred(type, extend[0], extend[1], extend[2])
         : type;
-};
+}
+function FactorWith(type, withClause) {
+    return Guard.IsArray(withClause) && Guard.IsEqual(withClause.length, 0)
+        ? type
+        : C.OptionsDeferred(type, withClause);
+}
 export function FactorMapping(input) {
-    const [keyOf, type, indexArray, extend] = input;
-    return keyOf
+    const [keyOf, type, indexArray, extend, withClause] = input;
+    return FactorWith(keyOf
         ? FactorExtends(C.KeyOfDeferred(FactorIndexArray(type, indexArray)), extend)
-        : FactorExtends(FactorIndexArray(type, indexArray), extend);
+        : FactorExtends(FactorIndexArray(type, indexArray), extend), withClause);
 }
 // deno-coverage-ignore-start
 function ExprBinaryMapping(left, rest) {

package/node_modules/typebox/build/type/script/parser.d.mts

@@ -43,7 +43,8 @@ export type TIndexArray_0<Input extends string, Result extends unknown[] = []> =
 export type TIndexArray<Input extends string> = TIndexArray_0<Input> extends [infer _0 extends ([unknown, unknown, unknown] | [unknown, unknown])[], infer Input extends string] ? [S.TIndexArrayMapping<_0>, Input] : [];
 export type TExtends<Input extends string> = ((Token.TConst<'extends', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<'?', Input> extends [infer _2, infer Input extends string] ? (TType<Input> extends [infer _3, infer Input extends string] ? (Token.TConst<':', Input> extends [infer _4, infer Input extends string] ? (TType<Input> extends [infer _5, infer Input extends string] ? [[_0, _1, _2, _3, _4, _5], Input] : []) : []) : []) : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExtendsMapping<_0>, Input] : [];
 export type TBase<Input extends string> = ((Token.TConst<'(', Input> extends [infer _0, infer Input extends string] ? (TType<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<')', Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : TKeyword<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Object_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTuple<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TTemplateLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TLiteral<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TConstructor<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : T_Function_<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TMapped<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TOptions<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TGenericCall<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TReference<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | unknown, infer Input extends string] ? [S.TBaseMapping<_0>, Input] : [];
-export type TFactor<Input extends string> = (TKeyOf<Input> extends [infer _0, infer Input extends string] ? (TBase<Input> extends [infer _1, infer Input extends string] ? (TIndexArray<Input> extends [infer _2, infer Input extends string] ? (TExtends<Input> extends [infer _3, infer Input extends string] ? [[_0, _1, _2, _3], Input] : []) : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TFactorMapping<_0>, Input] : [];
+export type TWith<Input extends string> = ((Token.TConst<'with', Input> extends [infer _0, infer Input extends string] ? (TJsonObject<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown] | [], infer Input extends string] ? [S.TWithMapping<_0>, Input] : [];
+export type TFactor<Input extends string> = (TKeyOf<Input> extends [infer _0, infer Input extends string] ? (TBase<Input> extends [infer _1, infer Input extends string] ? (TIndexArray<Input> extends [infer _2, infer Input extends string] ? (TExtends<Input> extends [infer _3, infer Input extends string] ? (TWith<Input> extends [infer _4, infer Input extends string] ? [[_0, _1, _2, _3, _4], Input] : []) : []) : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown, unknown, unknown], infer Input extends string] ? [S.TFactorMapping<_0>, Input] : [];
 export type TExprTermTail<Input extends string> = ((Token.TConst<'&', Input> extends [infer _0, infer Input extends string] ? (TFactor<Input> extends [infer _1, infer Input extends string] ? (TExprTermTail<Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExprTermTailMapping<_0>, Input] : [];
 export type TExprTerm<Input extends string> = (TFactor<Input> extends [infer _0, infer Input extends string] ? (TExprTermTail<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0 extends [unknown, unknown], infer Input extends string] ? [S.TExprTermMapping<_0>, Input] : [];
 export type TExprTail<Input extends string> = ((Token.TConst<'|', Input> extends [infer _0, infer Input extends string] ? (TExprTerm<Input> extends [infer _1, infer Input extends string] ? (TExprTail<Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExprTailMapping<_0>, Input] : [];
@@ -172,6 +173,7 @@ export declare const IndexArray_0: (input: string, result?: unknown[]) => [unkno
 export declare const IndexArray: (input: string) => [unknown, string] | [];
 export declare const Extends: (input: string) => [unknown, string] | [];
 export declare const Base: (input: string) => [unknown, string] | [];
+export declare const With: (input: string) => [unknown, string] | [];
 export declare const Factor: (input: string) => [unknown, string] | [];
 export declare const ExprTermTail: (input: string) => [unknown, string] | [];
 export declare const ExprTerm: (input: string) => [unknown, string] | [];

package/node_modules/typebox/build/type/script/parser.mjs

@@ -47,7 +47,8 @@ export const IndexArray_0 = (input, result = []) => If(If(If(Token.Const('[', in
 export const IndexArray = (input) => If(IndexArray_0(input), ([_0, input]) => [S.IndexArrayMapping(_0), input]);
 export const Extends = (input) => If(If(If(Token.Const('extends', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('?', input), ([_2, input]) => If(Type(input), ([_3, input]) => If(Token.Const(':', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExtendsMapping(_0), input]);
 export const Base = (input) => If(If(If(Token.Const('(', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(Keyword(input), ([_0, input]) => [_0, input], () => If(_Object_(input), ([_0, input]) => [_0, input], () => If(Tuple(input), ([_0, input]) => [_0, input], () => If(TemplateLiteral(input), ([_0, input]) => [_0, input], () => If(Literal(input), ([_0, input]) => [_0, input], () => If(Constructor(input), ([_0, input]) => [_0, input], () => If(_Function_(input), ([_0, input]) => [_0, input], () => If(Mapped(input), ([_0, input]) => [_0, input], () => If(Options(input), ([_0, input]) => [_0, input], () => If(GenericCall(input), ([_0, input]) => [_0, input], () => If(Reference(input), ([_0, input]) => [_0, input], () => [])))))))))))), ([_0, input]) => [S.BaseMapping(_0), input]);
-export const Factor = (input) => If(If(KeyOf(input), ([_0, input]) => If(Base(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends(input), ([_3, input]) => [[_0, _1, _2, _3], input])))), ([_0, input]) => [S.FactorMapping(_0), input]);
+export const With = (input) => If(If(If(Token.Const('with', input), ([_0, input]) => If(JsonObject(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.WithMapping(_0), input]);
+export const Factor = (input) => If(If(KeyOf(input), ([_0, input]) => If(Base(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends(input), ([_3, input]) => If(With(input), ([_4, input]) => [[_0, _1, _2, _3, _4], input]))))), ([_0, input]) => [S.FactorMapping(_0), input]);
 export const ExprTermTail = (input) => If(If(If(Token.Const('&', input), ([_0, input]) => If(Factor(input), ([_1, input]) => If(ExprTermTail(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExprTermTailMapping(_0), input]);
 export const ExprTerm = (input) => If(If(Factor(input), ([_0, input]) => If(ExprTermTail(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ExprTermMapping(_0), input]);
 export const ExprTail = (input) => If(If(If(Token.Const('|', input), ([_0, input]) => If(ExprTerm(input), ([_1, input]) => If(ExprTail(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExprTailMapping(_0), input]);

package/node_modules/typebox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.38",
+  "version": "1.1.39",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -16,22 +16,6 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
-    },
-    "./error": {
-      "import": "./build/error/index.mjs",
-      "default": "./build/error/index.mjs"
-    },
-    "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
-    },
-    "./system": {
-      "import": "./build/system/index.mjs",
-      "default": "./build/system/index.mjs"
-    },
     "./format": {
       "import": "./build/format/index.mjs",
       "default": "./build/format/index.mjs"
@@ -44,10 +28,26 @@
       "import": "./build/schema/index.mjs",
       "default": "./build/schema/index.mjs"
     },
+    "./compile": {
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
+    },
     "./value": {
       "import": "./build/value/index.mjs",
       "default": "./build/value/index.mjs"
     },
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
+    },
+    "./system": {
+      "import": "./build/system/index.mjs",
+      "default": "./build/system/index.mjs"
+    },
+    "./error": {
+      "import": "./build/error/index.mjs",
+      "default": "./build/error/index.mjs"
+    },
     ".": {
       "import": "./build/index.mjs",
       "default": "./build/index.mjs"
@@ -55,18 +55,6 @@
   },
   "typesVersions": {
     "*": {
-      "guard": [
-        "./build/guard/index.d.mts"
-      ],
-      "error": [
-        "./build/error/index.d.mts"
-      ],
-      "compile": [
-        "./build/compile/index.d.mts"
-      ],
-      "system": [
-        "./build/system/index.d.mts"
-      ],
       "format": [
         "./build/format/index.d.mts"
       ],
@@ -76,9 +64,21 @@
       "schema": [
         "./build/schema/index.d.mts"
       ],
+      "compile": [
+        "./build/compile/index.d.mts"
+      ],
       "value": [
         "./build/value/index.d.mts"
       ],
+      "guard": [
+        "./build/guard/index.d.mts"
+      ],
+      "system": [
+        "./build/system/index.d.mts"
+      ],
+      "error": [
+        "./build/error/index.d.mts"
+      ],
       ".": [
         "./build/index.d.mts"
       ]

package/npm-shrinkwrap.json

@@ -1,20 +1,20 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.5.28",
+  "version": "2026.5.31-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/voice-call",
-      "version": "2026.5.28",
+      "version": "2026.5.31-beta.1",
       "dependencies": {
         "commander": "14.0.3",
-        "typebox": "1.1.38",
+        "typebox": "1.1.39",
         "ws": "8.21.0",
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.5.28"
+        "openclaw": ">=2026.5.31-beta.1"
       },
       "peerDependenciesMeta": {
         "openclaw": {
@@ -32,9 +32,9 @@
       }
     },
     "node_modules/typebox": {
-      "version": "1.1.38",
-      "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.1.38.tgz",
-      "integrity": "sha512-pZ0aQPmMmXoUvSbeuWf/Hzsc+avNw/Zd6VeE8CFgkVGWyuHPJvqeJJDeJqLve+K70LvjYIoleGcoJHPT17cWoA==",
+      "version": "1.1.39",
+      "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.1.39.tgz",
+      "integrity": "sha512-vj0afVtOfLQvv0GR0VxVagYxsXN64btL7Z9XoaG0ZggH3mruMMkOO6hXdgMsjCY3shZgEvooAWVeznQVs5c43w==",
       "license": "MIT"
     },
     "node_modules/ws": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.5.28",
+  "version": "2026.5.31-beta.1",
   "description": "OpenClaw voice-call plugin for Twilio, Telnyx, and Plivo phone calls.",
   "repository": {
     "type": "git",
@@ -9,12 +9,12 @@
   "type": "module",
   "dependencies": {
     "commander": "14.0.3",
-    "typebox": "1.1.38",
+    "typebox": "1.1.39",
     "ws": "8.21.0",
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.28"
+    "openclaw": ">=2026.5.31-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -31,10 +31,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.5.28"
+      "pluginApi": ">=2026.5.31-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.28"
+      "openclawVersion": "2026.5.31-beta.1"
     },
     "release": {
       "publishToClawHub": true,