@openclaw/voice-call 2026.6.1 → 2026.6.5-beta.1

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

@@ -1,13 +1,16 @@
-import { t as VoiceCallConfigSchema } from "./config-BKyRNKHF.js";
+import { t as VoiceCallConfigSchema } from "./config-jaA6vOZ2.js";
 import { asOptionalRecord, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/voice-call/src/config-compat.ts
+/** Version where legacy voice-call config shape support is removed. */
 const VOICE_CALL_LEGACY_CONFIG_REMOVAL_VERSION = "2026.6.0";
 const asObject = asOptionalRecord;
 const getString = readStringField;
+/** Read finite numeric config values. */
 function getNumber(obj, key) {
 	const value = obj?.[key];
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+/** Merge legacy provider-specific values into the canonical providers map. */
 function mergeProviderConfig(providersValue, providerId, compatValues) {
 	if (Object.keys(compatValues).length === 0) return asObject(providersValue);
 	const providers = asObject(providersValue) ?? {};
@@ -20,6 +23,7 @@ function mergeProviderConfig(providersValue, providerId, compatValues) {
 		}
 	};
 }
+/** Collect legacy voice-call config keys that should be migrated. */
 function collectVoiceCallLegacyConfigIssues(value) {
 	const raw = asObject(value) ?? {};
 	const realtimeAgentContext = asObject(asObject(raw.realtime)?.agentContext);
@@ -68,11 +72,13 @@ function collectVoiceCallLegacyConfigIssues(value) {
 	});
 	return issues;
 }
+/** Format runtime warnings for legacy voice-call config keys. */
 function formatVoiceCallLegacyConfigWarnings(params) {
 	const issues = collectVoiceCallLegacyConfigIssues(params.value);
 	if (issues.length === 0) return [];
 	return [`[voice-call] legacy config keys detected under ${params.configPathPrefix}; runtime loading will not rewrite them, and support for the legacy shape will be removed in ${VOICE_CALL_LEGACY_CONFIG_REMOVAL_VERSION}. Run "${params.doctorFixCommand}".`, ...issues.map((issue) => `[voice-call] ${params.configPathPrefix}.${issue.path}: ${issue.message}`)];
 }
+/** Migrate legacy voice-call config input to the current canonical shape. */
 function migrateVoiceCallLegacyConfigInput(params) {
 	const raw = asObject(params.value) ?? {};
 	const realtime = asObject(raw.realtime);
@@ -137,9 +143,11 @@ function migrateVoiceCallLegacyConfigInput(params) {
 		issues
 	};
 }
+/** Normalize legacy voice-call config input without returning migration metadata. */
 function normalizeVoiceCallLegacyConfigInput(value) {
 	return migrateVoiceCallLegacyConfigInput({ value }).config;
 }
+/** Parse voice-call plugin config after applying legacy normalization. */
 function parseVoiceCallPluginConfig(value) {
 	return VoiceCallConfigSchema.parse(normalizeVoiceCallLegacyConfigInput(value));
 }

package/dist/{config-BKyRNKHF.js → config-jaA6vOZ2.js}

@@ -10,6 +10,7 @@ const BLOCKED_MERGE_KEYS = new Set([
 	"prototype",
 	"constructor"
 ]);
+/** Deep-merge plain objects, keeping base values when overrides are undefined. */
 function deepMergeDefined(base, override) {
 	if (!isRecord(base) || !isRecord(override)) return override === void 0 ? base : override;
 	const result = { ...base };
@@ -22,6 +23,7 @@ function deepMergeDefined(base, override) {
 }
 //#endregion
 //#region extensions/voice-call/src/realtime-defaults.ts
+/** Baseline instructions that keep realtime calls brief and route deep work to agent consult. */
 const DEFAULT_VOICE_CALL_REALTIME_INSTRUCTIONS = `You are OpenClaw's phone-call realtime voice interface. Keep spoken replies brief and natural. When a question needs deeper reasoning, current information, or tools, call ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} before answering.`;
 //#endregion
 //#region extensions/voice-call/src/config.ts

package/dist/doctor-contract-api.js

@@ -1,17 +1,20 @@
-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 { 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-8M2m4Isq.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
+/** Resolve home from doctor env with OS fallback. */
 function resolveHome(env) {
 	return env.HOME?.trim() || os.homedir();
 }
+/** Resolve config paths, including "~", against the doctor env home. */
 function resolveUserPath(input, env) {
 	const trimmed = input.trim();
 	if (!trimmed) return trimmed;
 	if (trimmed.startsWith("~")) return path.resolve(trimmed.replace(/^~(?=$|[\\/])/, resolveHome(env)));
 	return path.resolve(trimmed);
 }
+/** Read the configured voice-call store path from either package id. */
 function getVoiceCallConfigStore(config) {
 	for (const pluginId of ["voice-call", "@openclaw/voice-call"]) {
 		const rawConfig = config.plugins?.entries?.[pluginId]?.config;
@@ -21,11 +24,13 @@ function getVoiceCallConfigStore(config) {
 	}
 	return "";
 }
+/** Resolve the voice-call store path used by legacy and plugin-state call records. */
 function resolveVoiceCallStorePath(params) {
 	const configuredStore = getVoiceCallConfigStore(params.config);
 	if (configuredStore) return resolveUserPath(configuredStore, params.env);
 	return path.join(resolveHome(params.env), ".openclaw", "voice-calls");
 }
+/** Return true when a path exists and is a file. */
 async function fileExists(filePath) {
 	try {
 		return (await fs.stat(filePath)).isFile();
@@ -33,9 +38,11 @@ async function fileExists(filePath) {
 		return false;
 	}
 }
+/** Build the plugin state key for one migrated event chunk. */
 function buildChunkKey(eventKey, index) {
 	return `${eventKey}:chunk:${String(index).padStart(4, "0")}`;
 }
+/** Chunk a prepared call record into bounded plugin state rows. */
 function prepareChunks(call) {
 	const serialized = JSON.stringify(prepareVoiceCallRecordForStorage(call));
 	const buffer = Buffer.from(serialized, "utf8");
@@ -57,6 +64,7 @@ function prepareChunks(call) {
 		}
 	};
 }
+/** Read and prepare legacy JSONL call records, collecting line-level warnings. */
 async function readLegacyCallRecords(filePath) {
 	let content;
 	try {
@@ -99,6 +107,7 @@ async function readLegacyCallRecords(filePath) {
 		warnings
 	};
 }
+/** Archive the legacy JSONL source after a complete migration. */
 async function archiveLegacySource(params) {
 	const archivedPath = `${params.filePath}.migrated`;
 	if (await fileExists(archivedPath)) {
@@ -112,6 +121,7 @@ async function archiveLegacySource(params) {
 		params.warnings.push(`Failed archiving Voice Call call-log legacy source: ${String(err)}`);
 	}
 }
+/** Select newest missing records that fit remaining plugin state capacity. */
 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));
@@ -135,6 +145,7 @@ async function selectEntriesForImport(params) {
 		entries: selected.toReversed()
 	};
 }
+/** Import prepared legacy call records into plugin state. */
 async function importLegacyCallRecords(params) {
 	const selected = await selectEntriesForImport(params);
 	let imported = 0;
@@ -151,6 +162,7 @@ async function importLegacyCallRecords(params) {
 	}
 	return imported;
 }
+/** Doctor migrations owned by the voice-call plugin. */
 const stateMigrations = [{
 	id: "voice-call-calls-jsonl-to-plugin-state",
 	label: "Voice Call call log",

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

@@ -1,6 +1,6 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
-import { a as getHeader } from "./runtime-entry-13O0Ki99.js";
+import { a as getHeader } from "./runtime-entry-GVY8iEzX.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";
@@ -561,6 +561,7 @@ function verifyPlivoWebhook(ctx, authToken, options) {
 }
 //#endregion
 //#region extensions/voice-call/src/providers/shared/guarded-json-api.ts
+/** Send a provider JSON request through the SSRF guard and parse bounded JSON responses. */
 async function guardedJsonApiRequest(params) {
 	const { response, release } = await fetchWithSsrFGuard({
 		url: params.url,

package/dist/index.js

@@ -1,9 +1,9 @@
 import { definePluginEntry, sleep } from "./runtime-api.js";
 import "./api.js";
-import { i as resolveVoiceCallConfig, s as validateProviderConfig } from "./config-BKyRNKHF.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 { i as resolveVoiceCallConfig, s as validateProviderConfig } from "./config-jaA6vOZ2.js";
+import { c as getTailscaleSelfInfo, l as setupTailscaleExposureRoute, o as resolveWebhookExposureStatus, p as resolveUserPath, s as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime } from "./runtime-entry-GVY8iEzX.js";
+import { c as getCallHistoryFromStore, m as setVoiceCallStateRuntime } from "./store-8M2m4Isq.js";
+import { i as parseVoiceCallPluginConfig, r as normalizeVoiceCallLegacyConfigInput, t as formatVoiceCallLegacyConfigWarnings } from "./config-compat-BPPFhsJ7.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";
@@ -539,6 +539,7 @@ function registerVoiceCallCli(params) {
 //#region extensions/voice-call/src/gateway-continue-operation.ts
 const VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS = 3e4;
 const VOICE_CALL_CONTINUE_OPERATION_CLEANUP_MS = 300 * 1e3;
+/** Create a process-local operation store for gateway continue-call polling. */
 function createVoiceCallContinueOperationStore(params) {
 	const operations = /* @__PURE__ */ new Map();
 	const resolvePollTimeoutMs = (rt) => {

package/dist/{plivo-DeSZeJ0S.js → plivo-29Dvun7P.js}

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

@@ -16,6 +16,7 @@ const DEFAULT_MAX_QUEUED_AUDIO_BYTES = TELEPHONY_SAMPLE_RATE * 120;
 const PCM16_MAX_AMPLITUDE = 32768;
 const MULAW_LINEAR_SAMPLES = new Int16Array(256);
 for (let i = 0; i < MULAW_LINEAR_SAMPLES.length; i += 1) MULAW_LINEAR_SAMPLES[i] = decodeMulawSample(i);
+/** Paces outgoing mulaw audio frames at telephony cadence. */
 var RealtimeAudioPacer = class {
 	constructor(params) {
 		this.params = params;
@@ -24,6 +25,7 @@ var RealtimeAudioPacer = class {
 		this.queuedAudioBytes = 0;
 		this.closed = false;
 	}
+	/** Queue mulaw audio and split it into 20ms-ish telephony chunks. */
 	sendAudio(muLaw) {
 		if (this.closed || muLaw.length === 0) return;
 		const maxQueuedAudioBytes = this.params.maxQueuedAudioBytes ?? DEFAULT_MAX_QUEUED_AUDIO_BYTES;
@@ -42,6 +44,7 @@ var RealtimeAudioPacer = class {
 		}
 		this.ensurePump();
 	}
+	/** Queue a provider mark frame after prior audio frames. */
 	sendMark(name) {
 		if (this.closed || !name) return;
 		this.queue.push({
@@ -50,6 +53,7 @@ var RealtimeAudioPacer = class {
 		});
 		this.ensurePump();
 	}
+	/** Clear queued audio and notify the provider stream. */
 	clearAudio() {
 		if (this.closed) return 0;
 		const clearedAudioBytes = this.queuedAudioBytes;
@@ -59,24 +63,29 @@ var RealtimeAudioPacer = class {
 		this.params.send(this.params.serializer.clear());
 		return clearedAudioBytes;
 	}
+	/** Stop sending and discard queued frames. */
 	close() {
 		this.closed = true;
 		this.clearTimer();
 		this.queue = [];
 		this.queuedAudioBytes = 0;
 	}
+	/** Clear the scheduled pump timer. */
 	clearTimer() {
 		if (!this.timer) return;
 		clearTimeout(this.timer);
 		this.timer = null;
 	}
+	/** Start the pump when queued work exists and no timer is active. */
 	ensurePump() {
 		if (!this.timer) this.pump();
 	}
+	/** Close the pacer and notify the caller about queued-audio backpressure. */
 	failBackpressure() {
 		this.close();
 		this.params.onBackpressure?.();
 	}
+	/** Send one queued item and schedule the next send based on audio duration. */
 	pump() {
 		this.timer = null;
 		if (this.closed) return;
@@ -97,6 +106,7 @@ var RealtimeAudioPacer = class {
 		if (this.queue.length > 0) this.timer = setTimeout(() => this.pump(), delayMs);
 	}
 };
+/** Calculate normalized RMS from mulaw bytes. */
 function calculateMulawRms(muLaw) {
 	if (muLaw.length === 0) return 0;
 	let sum = 0;
@@ -106,6 +116,7 @@ function calculateMulawRms(muLaw) {
 	}
 	return Math.sqrt(sum / muLaw.length);
 }
+/** Detect likely speech start from consecutive loud mulaw chunks. */
 var RealtimeMulawSpeechStartDetector = class {
 	constructor(params = {}) {
 		this.params = params;
@@ -113,6 +124,7 @@ var RealtimeMulawSpeechStartDetector = class {
 		this.quietChunks = DEFAULT_REQUIRED_QUIET_CHUNKS;
 		this.speaking = false;
 	}
+	/** Accept one mulaw chunk and return true only on transition into speaking. */
 	accept(muLaw) {
 		if (calculateMulawRms(muLaw) >= (this.params.rmsThreshold ?? DEFAULT_SPEECH_RMS_THRESHOLD)) {
 			this.quietChunks = 0;
@@ -131,6 +143,7 @@ var RealtimeMulawSpeechStartDetector = class {
 		return false;
 	}
 };
+/** Decode one G.711 mulaw byte to a linear PCM sample. */
 function decodeMulawSample(value) {
 	const muLaw = ~value & 255;
 	const sign = muLaw & 128;
@@ -141,6 +154,7 @@ function decodeMulawSample(value) {
 }
 //#endregion
 //#region extensions/voice-call/src/webhook/stream-frame-adapter.ts
+/** Parse numeric timestamps sent as numbers or integer strings. */
 function parseTimestampMs(value) {
 	if (typeof value === "number" && Number.isFinite(value)) return value;
 	if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {
@@ -148,6 +162,7 @@ function parseTimestampMs(value) {
 		return Number.isSafeInteger(parsed) ? parsed : void 0;
 	}
 }
+/** Parse a JSON object frame, returning null for invalid or non-object payloads. */
 function tryParseJson(rawMessage) {
 	try {
 		const parsed = JSON.parse(rawMessage);
@@ -155,16 +170,20 @@ function tryParseJson(rawMessage) {
 	} catch {}
 	return null;
 }
+/** Read an object-valued field from a parsed frame. */
 function readRecordField(record, field) {
 	const value = record[field];
 	return typeof value === "object" && value !== null ? value : void 0;
 }
+/** Normalize base64/base64url padding differences for validation. */
 function normalizeBase64ForCompare(value) {
 	return value.replace(/=+$/u, "").replace(/-/gu, "+").replace(/_/gu, "/");
 }
+/** Return true when a payload round-trips as base64. */
 function isValidBase64Payload(value) {
 	return normalizeBase64ForCompare(Buffer.from(value, "base64").toString("base64")) === normalizeBase64ForCompare(value);
 }
+/** Parse a common provider media frame. */
 function parseMediaFrame(msg) {
 	const mediaData = readRecordField(msg, "media");
 	const payload = typeof mediaData?.payload === "string" ? mediaData.payload : void 0;
@@ -176,6 +195,7 @@ function parseMediaFrame(msg) {
 		track: typeof mediaData?.track === "string" ? mediaData.track : void 0
 	};
 }
+/** Parse a common provider mark frame. */
 function parseMarkFrame(msg) {
 	const markData = readRecordField(msg, "mark");
 	return {
@@ -183,11 +203,13 @@ function parseMarkFrame(msg) {
 		name: typeof markData?.name === "string" ? markData.name : void 0
 	};
 }
+/** Parse common media, mark, and stop frames shared by supported providers. */
 function parseCommonInboundFrame(event, msg) {
 	if (event === "media") return parseMediaFrame(msg);
 	if (event === "mark") return parseMarkFrame(msg);
 	if (event === "stop") return { kind: "stop" };
 }
+/** Parse one provider frame with provider-specific start/error hooks. */
 function parseProviderInboundFrame(rawMessage, parseStartFrame, parseExtraFrame) {
 	const msg = tryParseJson(rawMessage);
 	if (!msg) return { kind: "ignored" };
@@ -195,9 +217,11 @@ function parseProviderInboundFrame(rawMessage, parseStartFrame, parseExtraFrame)
 	if (event === "start") return parseStartFrame(msg) ?? { kind: "ignored" };
 	return parseCommonInboundFrame(event, msg) ?? parseExtraFrame?.(event, msg) ?? { kind: "ignored" };
 }
+/** Include streamSid only when Twilio has already supplied one. */
 function withOptionalStreamSid(streamSid) {
 	return streamSid === void 0 ? {} : { streamSid };
 }
+/** Serialize a provider media frame. */
 function serializeMediaFrame(payloadBase64, streamSid) {
 	return JSON.stringify({
 		event: "media",
@@ -205,12 +229,14 @@ function serializeMediaFrame(payloadBase64, streamSid) {
 		media: { payload: payloadBase64 }
 	});
 }
+/** Serialize a provider clear frame. */
 function serializeClearFrame(streamSid) {
 	return JSON.stringify({
 		event: "clear",
 		...withOptionalStreamSid(streamSid)
 	});
 }
+/** Serialize a provider mark frame. */
 function serializeMarkFrame(name, streamSid) {
 	return JSON.stringify({
 		event: "mark",
@@ -218,11 +244,13 @@ function serializeMarkFrame(name, streamSid) {
 		mark: { name }
 	});
 }
+/** Twilio media stream adapter, retaining streamSid for outbound frames. */
 var TwilioStreamFrameAdapter = class {
 	constructor() {
 		this.providerName = "twilio";
 		this.streamSid = "";
 	}
+	/** Parse one Twilio websocket message into a normalized frame. */
 	parseInbound(rawMessage) {
 		return parseProviderInboundFrame(rawMessage, (msg) => {
 			const startData = readRecordField(msg, "start");
@@ -237,20 +265,25 @@ var TwilioStreamFrameAdapter = class {
 			};
 		});
 	}
+	/** Serialize Twilio media with the active streamSid. */
 	serializeMedia(payloadBase64) {
 		return serializeMediaFrame(payloadBase64, this.streamSid);
 	}
+	/** Serialize Twilio clear with the active streamSid. */
 	serializeClear() {
 		return serializeClearFrame(this.streamSid);
 	}
+	/** Serialize Twilio mark with the active streamSid. */
 	serializeMark(name) {
 		return serializeMarkFrame(name, this.streamSid);
 	}
 };
+/** Telnyx media stream adapter. */
 var TelnyxStreamFrameAdapter = class {
 	constructor() {
 		this.providerName = "telnyx";
 	}
+	/** Parse one Telnyx websocket message into a normalized frame. */
 	parseInbound(rawMessage) {
 		return parseProviderInboundFrame(rawMessage, (msg) => {
 			const topLevelStreamId = typeof msg.stream_id === "string" && msg.stream_id ? msg.stream_id : void 0;
@@ -273,12 +306,15 @@ var TelnyxStreamFrameAdapter = class {
 			};
 		});
 	}
+	/** Serialize Telnyx media. */
 	serializeMedia(payloadBase64) {
 		return serializeMediaFrame(payloadBase64);
 	}
+	/** Serialize Telnyx clear. */
 	serializeClear() {
 		return serializeClearFrame();
 	}
+	/** Serialize Telnyx mark. */
 	serializeMark(name) {
 		return serializeMarkFrame(name);
 	}

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

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

@@ -1,7 +1,7 @@
 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 { a as resolveVoiceCallEffectiveConfig, c as deepMergeDefined, i as resolveVoiceCallConfig, n as normalizeVoiceCallConfig, o as resolveVoiceCallSessionKey, r as resolveTwilioAuthToken, s as validateProviderConfig } from "./config-jaA6vOZ2.js";
+import { c as getCallHistoryFromStore, d as persistCallRecord, h as TerminalStates, l as loadActiveCallsFromStore, m as setVoiceCallStateRuntime } from "./store-8M2m4Isq.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";
@@ -20,10 +20,12 @@ import { resolveConfiguredCapabilityProvider } from "openclaw/plugin-sdk/provide
 import { WEBHOOK_BODY_READ_DEFAULTS, createWebhookInFlightLimiter } from "openclaw/plugin-sdk/webhook-ingress";
 import { WebSocket as WebSocket$1, WebSocketServer } from "ws";
 //#region extensions/voice-call/src/allowlist.ts
+/** Normalize a phone number to digits only. */
 function normalizePhoneNumber(input) {
 	if (!input) return "";
 	return input.replace(/\D/g, "");
 }
+/** Return true when the normalized caller exactly matches an allowlist entry. */
 function isAllowlistedCaller(normalizedFrom, allowFrom) {
 	if (!normalizedFrom) return false;
 	return (allowFrom ?? []).some((num) => {
@@ -66,16 +68,19 @@ function addTranscriptEntry(call, speaker, text) {
 }
 //#endregion
 //#region extensions/voice-call/src/manager/timer-delays.ts
+/** Convert seconds to a safe timeout delay in milliseconds. */
 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);
 }
+/** Normalize a millisecond timeout delay with fallback behavior. */
 function resolveVoiceCallTimerDelayMs(timeoutMs, fallbackMs = 1) {
 	return resolveTimerTimeoutMs(timeoutMs, fallbackMs);
 }
 //#endregion
 //#region extensions/voice-call/src/manager/timers.ts
+/** Clear and forget the max-duration timer for a call. */
 function clearMaxDurationTimer(ctx, callId) {
 	const timer = ctx.maxDurationTimers.get(callId);
 	if (timer) {
@@ -83,6 +88,7 @@ function clearMaxDurationTimer(ctx, callId) {
 		ctx.maxDurationTimers.delete(callId);
 	}
 }
+/** Start or replace the max-duration timer for a call. */
 function startMaxDurationTimer(params) {
 	clearMaxDurationTimer(params.ctx, params.callId);
 	const maxDurationMs = params.timeoutMs === void 0 ? resolveVoiceCallSecondsTimerDelayMs(params.ctx.config.maxDurationSeconds) : resolveVoiceCallTimerDelayMs(params.timeoutMs);
@@ -101,18 +107,21 @@ function startMaxDurationTimer(params) {
 	}, maxDurationMs);
 	params.ctx.maxDurationTimers.set(params.callId, timer);
 }
+/** Clear and forget a pending final-transcript waiter. */
 function clearTranscriptWaiter(ctx, callId) {
 	const waiter = ctx.transcriptWaiters.get(callId);
 	if (!waiter) return;
 	clearTimeout(waiter.timeout);
 	ctx.transcriptWaiters.delete(callId);
 }
+/** Reject a pending transcript waiter during call finalization or error paths. */
 function rejectTranscriptWaiter(ctx, callId, reason) {
 	const waiter = ctx.transcriptWaiters.get(callId);
 	if (!waiter) return;
 	clearTranscriptWaiter(ctx, callId);
 	waiter.reject(new Error(reason));
 }
+/** Resolve a transcript waiter when the matching turn's final transcript arrives. */
 function resolveTranscriptWaiter(ctx, callId, transcript, turnToken) {
 	const waiter = ctx.transcriptWaiters.get(callId);
 	if (!waiter) return false;
@@ -121,6 +130,7 @@ function resolveTranscriptWaiter(ctx, callId, transcript, turnToken) {
 	waiter.resolve(transcript);
 	return true;
 }
+/** Wait for the next final transcript for a call, optionally scoped to a turn token. */
 function waitForFinalTranscript(ctx, callId, turnToken) {
 	if (ctx.transcriptWaiters.has(callId)) return Promise.reject(/* @__PURE__ */ new Error("Already waiting for transcript"));
 	const timeoutMs = resolveVoiceCallTimerDelayMs(ctx.config.transcriptTimeoutMs);
@@ -139,10 +149,12 @@ function waitForFinalTranscript(ctx, callId, turnToken) {
 }
 //#endregion
 //#region extensions/voice-call/src/manager/lifecycle.ts
+/** Remove a provider-call mapping only when it still points at this call. */
 function removeProviderCallMapping(providerCallIdMap, call) {
 	if (!call.providerCallId) return;
 	if (providerCallIdMap.get(call.providerCallId) === call.callId) providerCallIdMap.delete(call.providerCallId);
 }
+/** Persist terminal state, clean timers/waiters, and remove active call indexes. */
 function finalizeCall(params) {
 	const { ctx, call, endReason } = params;
 	call.endedAt = params.endedAt ?? Date.now();
@@ -156,11 +168,13 @@ function finalizeCall(params) {
 }
 //#endregion
 //#region extensions/voice-call/src/manager/lookup.ts
+/** Resolve an active call from provider call id with map lookup plus stale-map fallback scan. */
 function getCallByProviderCallId(params) {
 	const callId = params.providerCallIdMap.get(params.providerCallId);
 	if (callId) return params.activeCalls.get(callId);
 	for (const call of params.activeCalls.values()) if (call.providerCallId === params.providerCallId) return call;
 }
+/** Resolve an active call by internal call id or provider call id. */
 function findCall(params) {
 	const directCall = params.activeCalls.get(params.callIdOrProviderCallId);
 	if (directCall) return directCall;
@@ -172,11 +186,13 @@ function findCall(params) {
 }
 //#endregion
 //#region extensions/voice-call/src/tts-provider-voice.ts
+/** Read voice setting aliases from one provider-specific config block. */
 function resolveProviderVoiceSetting(providerConfig) {
 	if (!providerConfig || typeof providerConfig !== "object") return;
 	const candidate = providerConfig;
 	return normalizeOptionalString(candidate.speakerVoice) ?? normalizeOptionalString(candidate.speakerVoiceId) ?? normalizeOptionalString(candidate.voice) ?? normalizeOptionalString(candidate.voiceId);
 }
+/** Resolve the active provider's preferred voice id/name from voice-call TTS config. */
 function resolvePreferredTtsVoice(config) {
 	const providerId = config.tts?.provider;
 	if (!providerId) return;
@@ -219,6 +235,7 @@ function mapVoiceToPolly(voice) {
 }
 //#endregion
 //#region extensions/voice-call/src/manager/twiml.ts
+/** Generate TwiML that speaks one notification and hangs up. */
 function generateNotifyTwiml(message, voice) {
 	return `<?xml version="1.0" encoding="UTF-8"?>
 <Response>
@@ -226,6 +243,7 @@ function generateNotifyTwiml(message, voice) {
   <Hangup/>
 </Response>`;
 }
+/** Generate TwiML that plays DTMF digits before redirecting to a webhook URL. */
 function generateDtmfRedirectTwiml(digits, webhookUrl) {
 	return `<?xml version="1.0" encoding="UTF-8"?>
 <Response>
@@ -818,6 +836,7 @@ function processEvent(ctx, event) {
 }
 //#endregion
 //#region extensions/voice-call/src/utils.ts
+/** Resolve user input paths, including "~" against the current OS home. */
 function resolveUserPath(input) {
 	const trimmed = input.trim();
 	if (!trimmed) return trimmed;
@@ -1089,10 +1108,12 @@ var CallManager = class {
 };
 //#endregion
 //#region extensions/voice-call/src/realtime-agent-context.ts
+/** Limit injected context while preserving an explicit truncation marker. */
 function limitText(text, maxChars) {
 	if (text.length <= maxChars) return text;
 	return `${text.slice(0, Math.max(0, maxChars - 32)).trimEnd()}\n[truncated]`;
 }
+/** Read configured workspace context files through the safe workspace root. */
 async function readWorkspaceVoiceContextFiles(params) {
 	const sections = [];
 	let remaining = params.maxChars;
@@ -1108,6 +1129,7 @@ async function readWorkspaceVoiceContextFiles(params) {
 	}
 	return sections;
 }
+/** Build final realtime instructions from base instructions, consult policy, and fast context. */
 async function buildRealtimeVoiceInstructions(params) {
 	const { config } = params;
 	const sections = [params.baseInstructions];
@@ -1146,6 +1168,7 @@ async function buildRealtimeVoiceInstructions(params) {
 }
 //#endregion
 //#region extensions/voice-call/src/realtime-fast-context.ts
+/** Resolve fast-context consult data using caller-oriented labels. */
 async function resolveRealtimeFastContextConsult(params) {
 	return await resolveRealtimeVoiceFastContextConsult({
 		...params,
@@ -1157,6 +1180,7 @@ async function resolveRealtimeFastContextConsult(params) {
 }
 //#endregion
 //#region extensions/voice-call/src/response-model.ts
+/** Resolve provider/model fields from explicit voice config or agent defaults. */
 function resolveVoiceResponseModel(params) {
 	const modelRef = params.voiceConfig.responseModel ?? `${params.agentRuntime.defaults.provider}/${params.agentRuntime.defaults.model}`;
 	const slashIndex = modelRef.indexOf("/");
@@ -1178,7 +1202,9 @@ function chunkAudio(audio, chunkSize = 160) {
 }
 //#endregion
 //#region extensions/voice-call/src/telephony-tts.ts
+/** Default timeout for one telephony synthesis request. */
 const TELEPHONY_DEFAULT_TTS_TIMEOUT_MS = 8e3;
+/** Create a TTS provider that honors voice-call overrides and converts PCM to mulaw. */
 function createTelephonyTtsProvider(params) {
 	const { coreConfig, ttsOverride, runtime, logger } = params;
 	const mergedConfig = applyTtsOverride(coreConfig, ttsOverride);
@@ -1210,6 +1236,7 @@ function createTelephonyTtsProvider(params) {
 		}
 	};
 }
+/** Apply voice-call TTS overrides to core config without mutating the original object. */
 function applyTtsOverride(coreConfig, override) {
 	if (!override) return coreConfig;
 	const base = coreConfig.messages?.tts;
@@ -1223,12 +1250,14 @@ function applyTtsOverride(coreConfig, override) {
 		}
 	};
 }
+/** Merge core and voice-call TTS config, keeping undefined override fields out. */
 function mergeTtsConfig(base, override) {
 	if (!base && !override) return;
 	if (!override) return base;
 	if (!base) return override;
 	return deepMergeDefined(base, override);
 }
+/** Resolve directive override policy for telephony synthesis. */
 function resolveTelephonyModelOverridePolicy(overrides) {
 	if (!(overrides?.enabled ?? true)) return {
 		enabled: false,
@@ -1252,16 +1281,20 @@ function resolveTelephonyModelOverridePolicy(overrides) {
 		allowSeed: allow(overrides?.allowSeed)
 	};
 }
+/** Read model override policy from TTS config when present. */
 function readTelephonyModelOverrides(ttsConfig) {
 	const value = ttsConfig?.modelOverrides;
 	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
+/** Normalize provider ids for config lookup. */
 function normalizeProviderId(value) {
 	return typeof value === "string" ? value.trim().toLowerCase() || void 0 : void 0;
 }
+/** Coerce provider config objects while rejecting arrays and primitives. */
 function asProviderConfig(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+/** Collect named provider configs from canonical and legacy TTS config shapes. */
 function collectTelephonyProviderConfigs(ttsConfig) {
 	if (!ttsConfig) return {};
 	const entries = {};
@@ -1294,12 +1327,14 @@ function collectTelephonyProviderConfigs(ttsConfig) {
 //#endregion
 //#region extensions/voice-call/src/bounded-child-output.ts
 const DEFAULT_MAX_OUTPUT_CHARS = 16384;
+/** Create an empty bounded output buffer. */
 function emptyBoundedChildOutput() {
 	return {
 		text: "",
 		truncated: false
 	};
 }
+/** Append output while retaining the newest maxChars and recording truncation. */
 function appendBoundedChildOutput(current, chunk, maxChars = DEFAULT_MAX_OUTPUT_CHARS) {
 	const appended = current.text + chunk;
 	if (appended.length <= maxChars) return {
@@ -1311,6 +1346,7 @@ function appendBoundedChildOutput(current, chunk, maxChars = DEFAULT_MAX_OUTPUT_
 		truncated: true
 	};
 }
+/** Format captured output with a truncation marker when older text was dropped. */
 function formatBoundedChildOutput(output) {
 	return output.truncated ? `[output truncated]\n${output.text}` : output.text;
 }
@@ -1680,12 +1716,15 @@ async function startTunnel(config) {
 }
 //#endregion
 //#region extensions/voice-call/src/webhook-exposure.ts
+/** Return true when a provider requires a public webhook URL or tunnel. */
 function providerRequiresPublicWebhook(providerName) {
 	return providerName === "twilio" || providerName === "telnyx" || providerName === "plivo";
 }
+/** Return true for localhost, private, or otherwise provider-unreachable hosts. */
 function isLocalOnlyWebhookHost(hostname) {
 	return isBlockedHostnameOrIp(hostname);
 }
+/** Return true when a webhook URL parses to a local/private host. */
 function isProviderUnreachableWebhookUrl(webhookUrl) {
 	try {
 		return isLocalOnlyWebhookHost(new URL(webhookUrl).hostname);
@@ -1693,6 +1732,7 @@ function isProviderUnreachableWebhookUrl(webhookUrl) {
 		return false;
 	}
 }
+/** Resolve a human-readable webhook exposure status for doctor/setup surfaces. */
 function resolveWebhookExposureStatus(config) {
 	if (config.provider === "mock") return {
 		ok: true,
@@ -1729,6 +1769,7 @@ function resolveWebhookExposureStatus(config) {
 }
 //#endregion
 //#region extensions/voice-call/src/http-headers.ts
+/** Return the first value for a header name regardless of caller casing. */
 function getHeader(headers, name) {
 	const target = normalizeLowercaseStringOrEmpty(name);
 	const value = headers[target] ?? Object.entries(headers).find(([key]) => normalizeLowercaseStringOrEmpty(key) === target)?.[1];
@@ -2380,19 +2421,23 @@ const TERMINAL_PROVIDER_STATUS_TO_END_REASON = {
 	"no-answer": "no-answer",
 	canceled: "hangup-bot"
 };
+/** Normalize provider status text, falling back to "unknown". */
 function normalizeProviderStatus(status) {
 	const normalized = normalizeOptionalLowercaseString(status);
 	return normalized && normalized.length > 0 ? normalized : "unknown";
 }
+/** Map terminal provider status strings to OpenClaw end reasons. */
 function mapProviderStatusToEndReason(status) {
 	return TERMINAL_PROVIDER_STATUS_TO_END_REASON[normalizeProviderStatus(status)] ?? null;
 }
+/** Return true when a provider status is terminal. */
 function isProviderStatusTerminal(status) {
 	return mapProviderStatusToEndReason(status) !== null;
 }
 //#endregion
 //#region extensions/voice-call/src/webhook/stale-call-reaper.ts
 const CHECK_INTERVAL_MS = 3e4;
+/** Start a stale-call reaper and return its cleanup callback. */
 function startStaleCallReaper(params) {
 	const maxAgeSeconds = params.staleCallReaperSeconds;
 	if (!maxAgeSeconds || maxAgeSeconds <= 0) return null;
@@ -2428,7 +2473,7 @@ function loadRealtimeTranscriptionRuntime() {
 	return realtimeTranscriptionRuntimePromise;
 }
 function loadResponseGeneratorModule() {
-	responseGeneratorModulePromise ??= import("./response-generator-D6UsHyfH.js");
+	responseGeneratorModulePromise ??= import("./response-generator-DjsoOMEg.js");
 	return responseGeneratorModulePromise;
 }
 function sanitizeTranscriptForLog(value) {
@@ -3112,15 +3157,15 @@ let mockProviderPromise;
 let realtimeVoiceRuntimePromise;
 let realtimeHandlerPromise;
 function loadTelnyxProvider() {
-	telnyxProviderPromise ??= import("./telnyx-68EYJwaz.js");
+	telnyxProviderPromise ??= import("./telnyx-Gm8Z1pUt.js");
 	return telnyxProviderPromise;
 }
 function loadTwilioProvider() {
-	twilioProviderPromise ??= import("./twilio-D0dUSGam.js");
+	twilioProviderPromise ??= import("./twilio-BuFmgABx.js");
 	return twilioProviderPromise;
 }
 function loadPlivoProvider() {
-	plivoProviderPromise ??= import("./plivo-DeSZeJ0S.js");
+	plivoProviderPromise ??= import("./plivo-29Dvun7P.js");
 	return plivoProviderPromise;
 }
 function loadMockProvider() {
@@ -3132,7 +3177,7 @@ function loadRealtimeVoiceRuntime() {
 	return realtimeVoiceRuntimePromise;
 }
 function loadRealtimeHandler() {
-	realtimeHandlerPromise ??= import("./realtime-handler-BP6_qBNe.js");
+	realtimeHandlerPromise ??= import("./realtime-handler-ChN5De4P.js");
 	return realtimeHandlerPromise;
 }
 function resolveVoiceCallConsultSessionKey(call) {

package/dist/runtime-entry.js

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

package/dist/setup-api.js

@@ -1,7 +1,8 @@
-import { n as migrateVoiceCallLegacyConfigInput } from "./config-compat-BLdRz9GR.js";
+import { n as migrateVoiceCallLegacyConfigInput } from "./config-compat-BPPFhsJ7.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
+/** Migrate voice-call plugin config inside the full OpenClaw config object. */
 function migrateVoiceCallPluginConfig(config) {
 	const rawVoiceCallConfig = config.plugins?.entries?.["voice-call"]?.config;
 	if (!isRecord(rawVoiceCallConfig)) return null;
@@ -25,6 +26,7 @@ function migrateVoiceCallPluginConfig(config) {
 		changes: migration.changes
 	};
 }
+/** Setup plugin entry that registers voice-call config migrations. */
 var setup_api_default = definePluginEntry({
 	id: "voice-call",
 	name: "Voice Call Setup",

package/dist/{store-XuAPgOJG.js → store-8M2m4Isq.js}

@@ -124,22 +124,30 @@ const { setRuntime: setVoiceCallStateRuntime, clearRuntime: clearVoiceCallStateR
 });
 //#endregion
 //#region extensions/voice-call/src/manager/store.ts
+/** Plugin state namespace for call record event metadata. */
 const CALL_RECORD_EVENTS_NAMESPACE = "call-record-events";
+/** Plugin state namespace for base64 call record event chunks. */
 const CALL_RECORD_EVENT_CHUNKS_NAMESPACE = "call-record-event-chunks";
+/** Maximum retained call record events. */
 const MAX_CALL_RECORD_EVENTS = 1e3;
+/** Extra metadata entries retained so pruning can safely trim oldest rows. */
 const CALL_RECORD_EVENT_META_MAX_ENTRIES = 1100;
 const CALL_RECORD_CHUNK_MAX_ENTRIES = 48048;
+/** Raw UTF-8 bytes stored per call record chunk before base64 encoding. */
 const RAW_CALL_RECORD_CHUNK_BYTES = 47 * 1024;
 let callRecordEventSequence = 0;
+/** Return the pre-SQLite JSONL call log path for migration/compat checks. */
 function resolveVoiceCallLegacyCallLogPath(storePath) {
 	return path.join(storePath, "calls.jsonl");
 }
+/** Build env for plugin state stores rooted at the voice-call store path. */
 function resolvePluginStateEnv(storePath) {
 	return {
 		...process.env,
 		OPENCLAW_STATE_DIR: storePath
 	};
 }
+/** Open the plugin state stores when the runtime is available. */
 function createCallRecordStateStores(storePath) {
 	const runtime = getOptionalVoiceCallStateRuntime();
 	if (!runtime) return null;
@@ -157,6 +165,7 @@ function createCallRecordStateStores(storePath) {
 		})
 	};
 }
+/** Open call stores and log failures instead of breaking restore paths. */
 function tryCreateCallRecordStateStores(storePath) {
 	try {
 		return createCallRecordStateStores(storePath);
@@ -165,12 +174,15 @@ function tryCreateCallRecordStateStores(storePath) {
 		return null;
 	}
 }
+/** Build the stable storage key for one chunk of an event. */
 function buildChunkKey(eventKey, index) {
 	return `${eventKey}:chunk:${String(index).padStart(4, "0")}`;
 }
+/** Build a deterministic key for one legacy JSONL line. */
 function buildVoiceCallLegacyJsonlEventKey(line, index) {
 	return `jsonl:${String(index).padStart(8, "0")}:${createHash("sha256").update(line).digest("hex")}`;
 }
+/** Allocate monotonic ordering metadata for newly persisted call records. */
 function nextCallRecordOrder() {
 	const sequence = callRecordEventSequence;
 	callRecordEventSequence = (callRecordEventSequence + 1) % 1e6;
@@ -179,13 +191,16 @@ function nextCallRecordOrder() {
 		sequence
 	};
 }
+/** Build a unique event key that preserves timestamp and sequence ordering. */
 function buildNewEventKey(order) {
 	return `event:${order.persistedAt.toString(36)}:${String(order.sequence).padStart(6, "0")}:${randomUUID()}`;
 }
+/** Recover the sequence segment from newer event keys. */
 function parseEventKeySequence(key) {
 	const match = /^event:[^:]+:(\d+):/.exec(key);
 	return match ? Number.parseInt(match[1], 10) : 0;
 }
+/** Parse a stored call record line from v2 envelope or legacy raw-call JSON. */
 function parseVoiceCallRecordLine(line, sequence = 0) {
 	if (!line.trim()) return null;
 	try {
@@ -209,9 +224,11 @@ function parseVoiceCallRecordLine(line, sequence = 0) {
 		return null;
 	}
 }
+/** Count storage chunks needed for a call record. */
 function countCallRecordChunks(call) {
 	return Math.max(1, Math.ceil(Buffer.byteLength(JSON.stringify(call), "utf8") / RAW_CALL_RECORD_CHUNK_BYTES));
 }
+/** Truncate oversized call records to fit the bounded plugin state chunk budget. */
 function prepareVoiceCallRecordForStorage(call) {
 	if (countCallRecordChunks(call) <= 48) return call;
 	const transcriptEntries = call.transcript.length;
@@ -249,6 +266,7 @@ function prepareVoiceCallRecordForStorage(call) {
 	}
 	return call;
 }
+/** Register a serialized call record event and its chunks, then prune old events. */
 function registerCallRecordEvent(stores, eventKey, call, order) {
 	const serialized = JSON.stringify(prepareVoiceCallRecordForStorage(call));
 	const buffer = Buffer.from(serialized, "utf8");
@@ -269,18 +287,21 @@ function registerCallRecordEvent(stores, eventKey, call, order) {
 	});
 	pruneCallRecordEvents(stores);
 }
+/** Delete metadata and all chunk rows for one call record event. */
 function deleteCallRecordEventRows(stores, eventKey) {
 	const meta = stores.events.lookup(eventKey);
 	stores.events.delete(eventKey);
 	if (!meta) return;
 	for (let index = 0; index < meta.chunkCount; index += 1) stores.chunks.delete(buildChunkKey(eventKey, index));
 }
+/** Keep only the newest bounded call record events. */
 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);
 }
+/** Read and reassemble one chunked call record event. */
 function readCallRecordEvent(stores, eventKey) {
 	const meta = stores.events.lookup(eventKey);
 	if (!meta) return null;
@@ -292,6 +313,7 @@ function readCallRecordEvent(stores, eventKey) {
 	}
 	return parseVoiceCallRecordLine(Buffer.concat(chunks, meta.byteLength).toString("utf8"))?.call ?? null;
 }
+/** Read all persisted call records in stable persisted order. */
 function readCallRecordEvents(stores) {
 	return stores.events.entries().toSorted((a, b) => a.createdAt - b.createdAt || a.key.localeCompare(b.key)).map((entry) => {
 		const call = readCallRecordEvent(stores, entry.key);
@@ -303,6 +325,7 @@ function readCallRecordEvents(stores) {
 		} : 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);
 }
+/** Persist one call record event to plugin state. */
 function persistCallRecord(storePath, call) {
 	try {
 		const stores = createCallRecordStateStores(storePath);
@@ -314,6 +337,7 @@ function persistCallRecord(storePath, call) {
 		throw err;
 	}
 }
+/** Restore nonterminal active calls and provider/event indexes from persisted records. */
 function loadActiveCallsFromStore(storePath) {
 	const stores = tryCreateCallRecordStateStores(storePath);
 	let calls = [];
@@ -347,6 +371,7 @@ function loadActiveCallsFromStore(storePath) {
 		rejectedProviderCallIds
 	};
 }
+/** Return the newest persisted call history rows up to the requested limit. */
 async function getCallHistoryFromStore(storePath, limit = 50) {
 	if (limit <= 0) return [];
 	const stores = tryCreateCallRecordStateStores(storePath);

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

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

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

@@ -1,13 +1,14 @@
 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-13O0Ki99.js";
-import { a as verifyTwilioWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-tyxHyrev.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-GVY8iEzX.js";
+import { a as verifyTwilioWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-C5KNhYC-.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 //#region extensions/voice-call/src/providers/twilio/api.ts
 const TWILIO_API_TIMEOUT_MS = 3e4;
+/** Parse Twilio JSON error responses without trusting response shape. */
 function parseTwilioApiError(text) {
 	try {
 		const parsed = JSON.parse(text);
@@ -21,6 +22,7 @@ function parseTwilioApiError(text) {
 		return {};
 	}
 }
+/** Error thrown for non-2xx Twilio REST API responses. */
 var TwilioApiError = class extends Error {
 	constructor(httpStatus, responseText) {
 		const parsed = parseTwilioApiError(responseText);
@@ -32,6 +34,7 @@ var TwilioApiError = class extends Error {
 		this.twilioCode = parsed.code;
 	}
 };
+/** POST a form-encoded Twilio REST API request through the SSRF guard. */
 async function twilioApiRequest(params) {
 	const bodyParams = params.body instanceof URLSearchParams ? params.body : Object.entries(params.body).reduce((acc, [key, value]) => {
 		if (Array.isArray(value)) for (const entry of value) acc.append(key, entry);
@@ -71,9 +74,11 @@ async function twilioApiRequest(params) {
 }
 //#endregion
 //#region extensions/voice-call/src/providers/twilio/twiml-policy.ts
+/** Return true for Twilio outbound call directions. */
 function isOutboundDirection(direction) {
 	return direction?.startsWith("outbound") ?? false;
 }
+/** Read the Twilio request fields needed by TwiML decision logic. */
 function readTwimlRequestView(ctx) {
 	const params = new URLSearchParams(ctx.rawBody);
 	const type = normalizeOptionalString(ctx.query?.type);
@@ -86,6 +91,7 @@ function readTwimlRequestView(ctx) {
 		callIdFromQuery
 	};
 }
+/** Decide the TwiML response kind for a Twilio webhook request. */
 function decideTwimlResponse(input) {
 	if (input.callIdFromQuery && !input.isStatusCallback) {
 		if (input.hasStoredTwiml) return {
@@ -109,6 +115,7 @@ function decideTwimlResponse(input) {
 }
 //#endregion
 //#region extensions/voice-call/src/providers/twilio/webhook.ts
+/** Verify a Twilio webhook and map SDK verification details to provider result fields. */
 function verifyTwilioProviderWebhook(params) {
 	const result = verifyTwilioWebhook(params.ctx, params.authToken, {
 		publicUrl: params.currentPublicUrl || void 0,
@@ -206,6 +213,7 @@ var TwilioProvider = class TwilioProvider {
 	}
 	registerCallStream(callSid, streamSid) {
 		this.callStreamMap.set(callSid, streamSid);
+		this.activeStreamCalls.add(callSid);
 	}
 	hasRegisteredStream(callSid) {
 		return this.callStreamMap.has(callSid);
@@ -406,7 +414,6 @@ var TwilioProvider = class TwilioProvider {
 			canStream: Boolean(view.callSid && this.getStreamUrl())
 		});
 		if (decision.consumeStoredTwimlCallId) this.deleteStoredTwiml(decision.consumeStoredTwimlCallId);
-		if (decision.activateStreamCallSid) this.activeStreamCalls.add(decision.activateStreamCallSid);
 		switch (decision.kind) {
 			case "stored": return storedTwiml ?? TwilioProvider.EMPTY_TWIML;
 			case "queue": return TwilioProvider.QUEUE_TWIML;

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.6.1",
+  "version": "2026.6.5-beta.1",
   "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.6.1"
+    "openclaw": ">=2026.6.5-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -31,10 +31,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.6.1"
+      "pluginApi": ">=2026.6.5-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.6.1"
+      "openclawVersion": "2026.6.5-beta.1"
     },
     "release": {
       "publishToClawHub": true,