@openclaw/voice-call 2026.9.2 → 2026.9.4

package/dist/{cli-D3DeAqfd.js → cli-BGdihqyA.js}

@@ -1,8 +1,8 @@
 import { sleep } from "./runtime-api.js";
 import "./api.js";
 import { l as resolveVoiceCallStreamExposurePaths, u as validateProviderConfig } from "./config-DQwvsxeV.js";
-import { _ as resolveUserPath, c as resolveWebhookExposureStatus, d as setupTailscaleExposureRoutes, g as resolveVoiceCallAgentId, l as cleanupTailscaleExposureRoute, u as getTailscaleSelfInfo } from "./runtime-entry-DNmi-vZR.js";
-import { b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, l as findCallInStore, o as MAX_CALL_RECORD_EVENTS, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-C_z9zKnA.js";
+import { d as cleanupTailscaleExposureRoute, f as getTailscaleSelfInfo, p as setupTailscaleExposureRoutes, u as resolveWebhookExposureStatus, v as resolveVoiceCallAgentId, y as resolveUserPath } from "./runtime-entry-Ln4SWaYK.js";
+import { b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, l as findCallInStore, o as MAX_CALL_RECORD_EVENTS, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-M0GXxUfv.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { callGatewayFromCli, isGatewayClientRequestError, isGatewayTransportError, redactSensitiveUrlLikeString } from "openclaw/plugin-sdk/gateway-runtime";
 import { isRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";

package/dist/doctor-contract-api.js

@@ -1,4 +1,4 @@
-import { a as CALL_RECORD_EVENT_META_MAX_ENTRIES, c as buildVoiceCallLegacyJsonlEventKey, f as parseVoiceCallRecordLine, h as resolveVoiceCallLegacyCallLogPath, i as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, m as prepareVoiceCallRecordForStorage, n as CALL_RECORD_CHUNK_MAX_ENTRIES, o as MAX_CALL_RECORD_EVENTS, r as CALL_RECORD_EVENTS_NAMESPACE, s as RAW_CALL_RECORD_CHUNK_BYTES, t as resolveDefaultVoiceCallStoreDir } from "./store-path-C_z9zKnA.js";
+import { a as CALL_RECORD_EVENT_META_MAX_ENTRIES, c as buildVoiceCallLegacyJsonlEventKey, f as parseVoiceCallRecordLine, h as resolveVoiceCallLegacyCallLogPath, i as CALL_RECORD_EVENT_CHUNKS_NAMESPACE, m as prepareVoiceCallRecordForStorage, n as CALL_RECORD_CHUNK_MAX_ENTRIES, o as MAX_CALL_RECORD_EVENTS, r as CALL_RECORD_EVENTS_NAMESPACE, s as RAW_CALL_RECORD_CHUNK_BYTES, t as resolveDefaultVoiceCallStoreDir } from "./store-path-M0GXxUfv.js";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path from "node:path";
@@ -68,6 +68,8 @@ function describeVoiceCallSchemaMigration(migration) {
 		case "state-consolidation-v13": return "cron jobs and subagent runs -> canonical JSON storage";
 		case "creator-namespace-v14": return "cron creators -> explicit principal namespaces";
 		case "conversation-binding-targets-v15": return "conversation bindings -> exact target keys without agent/session projections";
+		case "skill-workshop-directory-ownership-v16": return "Skill Workshop proposals -> per-agent Workshop directory ownership";
+		case "prepared-worker-ownership-v17": return "prepared workers -> one-use capacity and fixed workspace ownership";
 		case "worker-placement-execution-mode-v8": return "cloud worker placements -> execution-mode claims";
 		case "operator-approvals-system-agent": return "operator approvals -> OpenClaw system changes";
 		case "session-watch-cursor-provenance-v4": return "session watch cursors -> provenance column";

package/dist/{guarded-json-api-BhLtja0F.js → guarded-json-api-3Jy2k-eX.js}

@@ -1,6 +1,6 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
-import { n as normalizeProxyIp, s as getHeader } from "./runtime-entry-DNmi-vZR.js";
+import { l as getHeader, n as normalizeProxyIp } from "./runtime-entry-Ln4SWaYK.js";
 import { n as reserveWebhookReplay, t as createWebhookReplayCache } from "./webhook-replay-CCQSoBNF.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";

package/dist/index.js

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

package/dist/{plivo-qIMf0pd2.js → plivo-BsdFT1gS.js}

@@ -1,5 +1,5 @@
-import { s as getHeader, v as escapeXml } from "./runtime-entry-DNmi-vZR.js";
-import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-BhLtja0F.js";
+import { b as escapeXml, l as getHeader } from "./runtime-entry-Ln4SWaYK.js";
+import { a as reconstructWebhookUrl, o as verifyPlivoWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-3Jy2k-eX.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-CHCnMJfl.js → realtime-handler-C7N4qzvf.js}

@@ -1,5 +1,5 @@
 import { d as REALTIME_VOICE_END_CALL_TOOL_NAME, s as resolveVoiceCallPublicPathPrefix } from "./config-DQwvsxeV.js";
-import { o as canonicalizeVoiceCallMediaBase64 } from "./runtime-entry-DNmi-vZR.js";
+import { c as canonicalizeVoiceCallMediaBase64, o as WebSocket, s as WebSocketServer } from "./runtime-entry-Ln4SWaYK.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { asNullableRecord, asOptionalObjectRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
@@ -9,13 +9,14 @@ import { isFutureDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openc
 import { randomUUID } from "node:crypto";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import "node:http";
-import WebSocket$1, { WebSocketServer } from "ws";
 //#region extensions/voice-call/src/webhook/realtime-audio-pacer.ts
 const TELEPHONY_SAMPLE_RATE = 8e3;
 const TELEPHONY_CHUNK_BYTES = 160;
 const LEAD_MS = 160;
 const DEFAULT_MAX_QUEUED_AUDIO_BYTES = TELEPHONY_SAMPLE_RATE * 120;
 const QUEUE_COMPACT_HEAD_THRESHOLD = 256;
+const MAX_PLAYBACK_SEGMENTS = 128;
+const MAX_PENDING_MARK_BOUNDARIES = 64;
 /** Paces outgoing mulaw audio frames at telephony cadence. */
 var RealtimeAudioPacer = class {
 	constructor(params) {
@@ -26,9 +27,18 @@ var RealtimeAudioPacer = class {
 		this.queuedAudioBytes = 0;
 		this.closed = false;
 		this.streamClockMs = null;
+		this.playbackSegments = [];
+		this.sentAudioMs = 0;
+		this.retiredAudioMs = 0;
+		this.confirmedPlayedMs = 0;
+		this.playbackMarkPrefix = `openclaw-playout-${randomUUID()}`;
+		this.playbackMarkSequence = 0;
+		this.lastPlaybackMarkMs = 0;
+		this.markBoundaries = [];
+		this.retiredItemOffsets = /* @__PURE__ */ new Map();
 	}
 	/** Queue mulaw audio and split it into 20ms-ish telephony chunks. */
-	sendAudio(muLaw) {
+	sendAudio(muLaw, metadata) {
 		if (this.closed || muLaw.length === 0) return;
 		const maxQueuedAudioBytes = this.params.maxQueuedAudioBytes ?? DEFAULT_MAX_QUEUED_AUDIO_BYTES;
 		for (let offset = 0; offset < muLaw.length; offset += TELEPHONY_CHUNK_BYTES) {
@@ -37,15 +47,42 @@ var RealtimeAudioPacer = class {
 				this.failBackpressure();
 				return;
 			}
+			const durationMs = chunk.length / 8;
+			const segment = this.extendPlaybackSegment(metadata?.itemId, durationMs);
+			if (!segment) {
+				this.failBackpressure();
+				return;
+			}
 			this.queue.push({
 				type: "audio",
 				chunk,
-				durationMs: chunk.length / 8
+				durationMs,
+				segment
 			});
 			this.queuedAudioBytes += chunk.length;
 		}
 		this.ensurePump();
 	}
+	/**
+	* Retained provider items in playback order with consumed playout duration.
+	* Queued audio has not reached the telephony line, so unplayed items report zero.
+	*/
+	getPlaybackState() {
+		let remaining = Math.max(0, this.confirmedPlayedMs - this.retiredAudioMs);
+		const playedByItem = /* @__PURE__ */ new Map();
+		for (const segment of this.playbackSegments) {
+			const consumed = Math.min(remaining, segment.sentMs);
+			remaining -= consumed;
+			if (segment.itemId !== void 0) {
+				const previousMs = playedByItem.get(segment.itemId) ?? this.retiredItemOffsets.get(segment.itemId) ?? 0;
+				playedByItem.set(segment.itemId, previousMs + consumed);
+			}
+		}
+		return Array.from(playedByItem, ([itemId, audioEndMs]) => ({
+			itemId,
+			audioEndMs: Math.floor(audioEndMs)
+		}));
+	}
 	/** Queue a provider mark frame after prior audio frames. */
 	sendMark(name) {
 		if (this.closed || !name) return;
@@ -55,14 +92,32 @@ var RealtimeAudioPacer = class {
 		});
 		this.ensurePump();
 	}
+	/** Retire the playback prefix once the carrier confirms playout reached the mark. */
+	acknowledgeMark(name) {
+		if (this.closed || !name) return;
+		const boundaryIndex = this.markBoundaries.findIndex((boundary) => boundary.name === name);
+		if (boundaryIndex < 0) return;
+		const boundary = this.markBoundaries[boundaryIndex];
+		this.markBoundaries.splice(0, boundaryIndex + 1);
+		if (!boundary) return;
+		while (this.playbackSegments.length > 0) {
+			const head = this.playbackSegments[0];
+			if (!head || head.sentMs < head.totalMs || head.lastSentEndMs === void 0 || head.lastSentEndMs > boundary.sentMs) break;
+			const retired = this.playbackSegments.shift();
+			if (retired) {
+				this.retiredAudioMs += retired.sentMs;
+				if (retired.itemId !== void 0) this.retiredItemOffsets.set(retired.itemId, (this.retiredItemOffsets.get(retired.itemId) ?? 0) + retired.sentMs);
+			}
+		}
+		this.confirmedPlayedMs = Math.max(this.confirmedPlayedMs, Math.min(boundary.sentMs, this.sentAudioMs));
+	}
 	/** Clear queued audio and notify the provider stream. */
 	clearAudio() {
 		if (this.closed) return 0;
 		const clearedAudioBytes = this.queuedAudioBytes;
 		this.clearTimer();
 		this.resetQueue();
-		this.queuedAudioBytes = 0;
-		this.streamClockMs = null;
+		this.resetPlaybackState();
 		this.params.send(this.params.serializer.clear());
 		return clearedAudioBytes;
 	}
@@ -75,8 +130,33 @@ var RealtimeAudioPacer = class {
 		this.closed = true;
 		this.clearTimer();
 		this.resetQueue();
+		this.resetPlaybackState();
+	}
+	extendPlaybackSegment(itemId, durationMs) {
+		let segment = this.playbackSegments.at(-1);
+		if (!segment || segment.itemId !== itemId) {
+			if (this.playbackSegments.length >= MAX_PLAYBACK_SEGMENTS) return null;
+			segment = {
+				itemId,
+				totalMs: 0,
+				sentMs: 0
+			};
+			this.playbackSegments.push(segment);
+		}
+		segment.totalMs += durationMs;
+		return segment;
+	}
+	resetPlaybackState() {
+		this.playbackSegments = [];
 		this.queuedAudioBytes = 0;
+		this.sentAudioMs = 0;
+		this.retiredAudioMs = 0;
+		this.confirmedPlayedMs = 0;
+		this.lastPlaybackMarkMs = 0;
+		this.markBoundaries = [];
+		this.retiredItemOffsets.clear();
 		this.streamClockMs = null;
+		this.params.onPlaybackReset?.();
 	}
 	/** Clear the scheduled pump timer. */
 	clearTimer() {
@@ -124,7 +204,7 @@ var RealtimeAudioPacer = class {
 		while (this.pendingQueueSize > 0 && this.streamClockMs < now + LEAD_MS) {
 			const item = this.takeNextItem();
 			if (!item) break;
-			if (!(item.type === "audio" ? this.sendAudioItem(item) : this.params.send(this.params.serializer.mark(item.name)))) {
+			if (!(item.type === "audio" ? this.sendAudioItem(item) : this.sendMarkItem(item))) {
 				this.resetQueue();
 				this.queuedAudioBytes = 0;
 				this.streamClockMs = null;
@@ -141,7 +221,30 @@ var RealtimeAudioPacer = class {
 	sendAudioItem(item) {
 		this.queuedAudioBytes = Math.max(0, this.queuedAudioBytes - item.chunk.length);
 		const sent = this.params.send(this.params.serializer.media(item.chunk.toString("base64")));
+		if (sent) {
+			item.segment.sentMs += item.durationMs;
+			this.sentAudioMs += item.durationMs;
+			item.segment.lastSentEndMs = this.sentAudioMs;
+		}
 		this.streamClockMs = (this.streamClockMs ?? performance.now()) + item.durationMs;
+		if (!sent || item.segment.itemId === void 0 || this.sentAudioMs - this.lastPlaybackMarkMs < LEAD_MS) return sent;
+		this.lastPlaybackMarkMs = this.sentAudioMs;
+		this.playbackMarkSequence += 1;
+		return this.sendMarkItem({
+			type: "mark",
+			name: `${this.playbackMarkPrefix}-${this.playbackMarkSequence}`
+		});
+	}
+	/** Send a queued mark frame and bind it to the playback prefix before it. */
+	sendMarkItem(item) {
+		const sent = this.params.send(this.params.serializer.mark(item.name));
+		if (sent) {
+			this.markBoundaries.push({
+				name: item.name,
+				sentMs: this.sentAudioMs
+			});
+			if (this.markBoundaries.length > MAX_PENDING_MARK_BOUNDARIES) this.markBoundaries.shift();
+		}
 		return sent;
 	}
 };
@@ -443,6 +546,15 @@ function appendRecentTalkEventMetadata(call, event) {
 	}].slice(-12);
 	call.metadata = metadata;
 }
+function rejectRealtimeUpgrade(socket, status) {
+	const reason = status === 401 ? "Unauthorized" : "Service Unavailable";
+	try {
+		socket.end(`HTTP/1.1 ${status} ${reason}\r\nConnection: close\r\n\r\n`, () => socket.destroy());
+	} catch (error) {
+		socket.destroy();
+		throw error;
+	}
+}
 var RealtimeCallHandler = class {
 	constructor(config, manager, resolveCallRegistration, servePath, streamDisconnectLifecycle, coreConfig) {
 		this.config = config;
@@ -506,16 +618,15 @@ var RealtimeCallHandler = class {
 		}
 	}
 	handleWebSocketUpgrade(request, socket, head) {
+		socket.once("error", () => socket.destroy());
 		if (this.closing) {
-			socket.write("HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n");
-			socket.destroy();
+			rejectRealtimeUpgrade(socket, 503);
 			return;
 		}
 		const token = new URL(request.url ?? "/", "wss://localhost").pathname.split("/").pop() ?? null;
 		const callerMeta = token ? this.consumeStreamToken(token) : null;
 		if (!callerMeta) {
-			socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
-			socket.destroy();
+			rejectRealtimeUpgrade(socket, 401);
 			return;
 		}
 		const adapter = (callerMeta.providerName ?? "twilio") === "telnyx" ? new TelnyxStreamFrameAdapter() : new TwilioStreamFrameAdapter();
@@ -565,7 +676,8 @@ var RealtimeCallHandler = class {
 						return;
 					}
 					if (frame.kind === "mark") {
-						telephonyBinding.bridge.acknowledgeMark();
+						telephonyBinding.acknowledgeCarrierMark(frame.name);
+						telephonyBinding.bridge.acknowledgeMark(frame.name);
 						return;
 					}
 					if (frame.kind === "error") {
@@ -598,7 +710,7 @@ var RealtimeCallHandler = class {
 		this.pendingStreamTokens.clear();
 		const sockets = [...this.activeSockets];
 		this.closePromise = Promise.all([shutdownBarrier, ...sockets.map((ws) => new Promise((resolve) => {
-			if (ws.readyState === WebSocket$1.CLOSED) {
+			if (ws.readyState === WebSocket.CLOSED) {
 				resolve();
 				return;
 			}
@@ -790,7 +902,7 @@ var RealtimeCallHandler = class {
 		});
 		console.log(`[voice-call] Realtime bridge starting for call ${callId} (providerCallId=${callSid}, initialGreeting=${initialGreetingInstructions ? "queued" : "absent"})`);
 		const sendString = (message) => {
-			if (ws.readyState !== WebSocket$1.OPEN) return false;
+			if (ws.readyState !== WebSocket.OPEN) return false;
 			if (ws.bufferedAmount > MAX_REALTIME_WS_BUFFERED_BYTES) {
 				console.warn(`[voice-call] realtime outbound websocket backpressure before send callId=${callId} providerCallId=${callSid} bufferedBytes=${ws.bufferedAmount}`);
 				ws.close(1013, "Backpressure: send buffer exceeded");
@@ -804,7 +916,9 @@ var RealtimeCallHandler = class {
 			}
 			return true;
 		};
+		const pendingMarkAcks = /* @__PURE__ */ new Map();
 		const audioPacer = new RealtimeAudioPacer({
+			onPlaybackReset: () => pendingMarkAcks.clear(),
 			send: sendString,
 			serializer: {
 				media: (payload) => adapter.serializeMedia(payload),
@@ -813,7 +927,7 @@ var RealtimeCallHandler = class {
 			},
 			onBackpressure: () => {
 				console.warn(`[voice-call] realtime paced audio backpressure callId=${callId} providerCallId=${callSid}`);
-				if (ws.readyState === WebSocket$1.OPEN) ws.close(1013, "Backpressure: paced audio queue exceeded");
+				if (ws.readyState === WebSocket.OPEN) ws.close(1013, "Backpressure: paced audio queue exceeded");
 			}
 		});
 		const speechDetector = createSpeechThresholdGate({
@@ -839,11 +953,12 @@ var RealtimeCallHandler = class {
 			initialGreetingInstructions,
 			triggerGreetingOnReady: Boolean(initialGreetingInstructions),
 			audioSink: {
-				isOpen: () => ws.readyState === WebSocket$1.OPEN,
-				sendAudio: (muLaw) => {
+				isOpen: () => ws.readyState === WebSocket.OPEN,
+				sendAudio: (muLaw, metadata) => {
 					harness.recordOutputAudio(muLaw);
-					audioPacer.sendAudio(muLaw);
+					audioPacer.sendAudio(muLaw, metadata);
 				},
+				getPlaybackState: () => audioPacer.getPlaybackState(),
 				clearAudio: (reason) => {
 					harness.flushOutput(() => {
 						const clearedBytes = audioPacer.clearAudio();
@@ -855,8 +970,9 @@ var RealtimeCallHandler = class {
 						harness.finishOutputAudio("clear");
 					});
 				},
-				sendMark: (markName) => {
+				sendMark: (markName, acknowledge) => {
 					audioPacer.sendMark(markName);
+					if (markName && acknowledge) pendingMarkAcks.set(markName, acknowledge);
 				}
 			},
 			onTranscript: (role, text, isFinal) => {
@@ -1035,7 +1151,7 @@ var RealtimeCallHandler = class {
 				if (ownsCallState) this.clearUserTranscriptState(callId, userTranscriptOwner);
 				if (reason === "completed" && (!ownsCallState || sessionClosed)) return;
 				this.streamDisconnectLifecycle.retire(callSid, streamSid);
-				if (ws.readyState === WebSocket$1.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Bridge disconnected");
+				if (ws.readyState === WebSocket.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Bridge disconnected");
 				if (ownsCallState) emitCallEnd(reason);
 			}
 		};
@@ -1056,7 +1172,7 @@ var RealtimeCallHandler = class {
 			audioPacer.close();
 			const reason = provisionalCloseReason ?? "error";
 			if (!hadPredecessorOnAdmission || !this.activeBridgesByCallId.has(callId)) emitCallEnd(reason);
-			if (ws.readyState === WebSocket$1.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Failed to create realtime bridge");
+			if (ws.readyState === WebSocket.OPEN) ws.close(reason === "error" ? 1011 : 1e3, "Failed to create realtime bridge");
 			return null;
 		}
 		const session = candidate;
@@ -1125,10 +1241,19 @@ var RealtimeCallHandler = class {
 		};
 		const telephonyBinding = {
 			bridge: session,
+			acknowledgeCarrierMark: (markName) => {
+				audioPacer.acknowledgeMark(markName);
+				if (!markName) return;
+				const acknowledge = pendingMarkAcks.get(markName);
+				if (acknowledge) {
+					pendingMarkAcks.delete(markName);
+					acknowledge();
+				}
+			},
 			close: (cause) => closeBinding(telephonyBinding, cause),
 			endCall: () => {
 				closeBinding(telephonyBinding);
-				if (ws.readyState === WebSocket$1.OPEN) ws.close(1e3, "Call ended");
+				if (ws.readyState === WebSocket.OPEN) ws.close(1e3, "Call ended");
 			},
 			noteMediaActivity: () => {
 				if (bindingClosed || this.activeTelephonyBindingsByCallId.get(callId) !== telephonyBinding) return;
@@ -1137,7 +1262,7 @@ var RealtimeCallHandler = class {
 					console.warn(`[voice-call] Realtime media inactive callId=${callId} providerCallId=${callSid} timeoutMs=${REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS} graceMs=${REALTIME_DISCONNECT_HANGUP_GRACE_MS}`);
 					livenessTimer = setTimeout(() => {
 						telephonyBinding.close("inactivity");
-						if (ws.readyState === WebSocket$1.OPEN) ws.close(1e3, "Media inactivity");
+						if (ws.readyState === WebSocket.OPEN) ws.close(1e3, "Media inactivity");
 					}, REALTIME_DISCONNECT_HANGUP_GRACE_MS);
 					livenessTimer.unref?.();
 				}, REALTIME_MEDIA_INACTIVITY_TIMEOUT_MS);

package/dist/{response-generator-BK43h7yV.js → response-generator-DsdC88Xg.js}

@@ -1,5 +1,5 @@
 import { c as resolveVoiceCallSessionKey } from "./config-DQwvsxeV.js";
-import { h as resolveCallAgentId, m as resolveVoiceResponseModel } from "./runtime-entry-DNmi-vZR.js";
+import { _ as resolveCallAgentId, g as resolveVoiceResponseModel } from "./runtime-entry-Ln4SWaYK.js";
 import { filterStringEntries, isRecord, normalizeLowercaseStringOrEmpty, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentConfig } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { isValidAgentHarnessSessionStoreEntry } from "openclaw/plugin-sdk/session-store-runtime";

package/dist/{runtime-entry-DNmi-vZR.js → runtime-entry-Ln4SWaYK.js}

@@ -1,7 +1,8 @@
 import { isBlockedHostnameOrIp, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, sendHttpRequestRejection } from "./runtime-api.js";
 import "./api.js";
 import { a as resolveVoiceCallEffectiveConfig, c as resolveVoiceCallSessionKey, f as resolveVoiceCallRealtimeTools, i as resolveVoiceCallConfig, l as resolveVoiceCallStreamExposurePaths, n as normalizeVoiceCallConfig, o as resolveVoiceCallNumberRouteKeyForCall, r as resolveTwilioAuthToken, u as validateProviderConfig } from "./config-DQwvsxeV.js";
-import { _ as releaseRejectedProviderCall, b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, g as appendCallReplayKey, l as findCallInStore, p as persistCallRecord, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore, v as rememberManagerReplayKey, x as TerminalStates, y as reserveRejectedProviderCall } from "./store-path-C_z9zKnA.js";
+import { _ as releaseRejectedProviderCall, b as setVoiceCallStateRuntime, d as loadActiveCallsFromStore, g as appendCallReplayKey, l as findCallInStore, p as persistCallRecord, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore, v as rememberManagerReplayKey, x as TerminalStates, y as reserveRejectedProviderCall } from "./store-path-M0GXxUfv.js";
+import { createRequire } from "node:module";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isLoopbackHost } from "openclaw/plugin-sdk/gateway-runtime";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
@@ -24,7 +25,7 @@ import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import http from "node:http";
 import { URL as URL$1 } from "node:url";
 import { resolveConfiguredCapabilityProvider } from "openclaw/plugin-sdk/provider-selection-runtime";
-import { WebSocket, WebSocketServer } from "ws";
+import { rejectWebSocketUpgrade } from "openclaw/plugin-sdk/websocket-runtime";
 import { canonicalizeBase64 } from "openclaw/plugin-sdk/media-runtime";
 //#region extensions/voice-call/src/allowlist.ts
 /** Normalize a phone number to digits only. */
@@ -234,14 +235,14 @@ function escapeXml(text) {
 /**
 * Map of OpenAI voice names to similar Twilio Polly voices.
 */
-const OPENAI_TO_POLLY_MAP = {
-	alloy: "Polly.Joanna",
-	echo: "Polly.Matthew",
-	fable: "Polly.Amy",
-	onyx: "Polly.Brian",
-	nova: "Polly.Salli",
-	shimmer: "Polly.Kimberly"
-};
+const OPENAI_TO_POLLY_MAP = /* @__PURE__ */ new Map([
+	["alloy", "Polly.Joanna"],
+	["echo", "Polly.Matthew"],
+	["fable", "Polly.Amy"],
+	["onyx", "Polly.Brian"],
+	["nova", "Polly.Salli"],
+	["shimmer", "Polly.Kimberly"]
+]);
 /**
 * Default Polly voice when no mapping is found.
 */
@@ -256,7 +257,7 @@ const DEFAULT_POLLY_VOICE = "Polly.Joanna";
 function mapVoiceToPolly(voice) {
 	if (!voice) return DEFAULT_POLLY_VOICE;
 	if (voice.startsWith("Polly.") || voice.startsWith("Google.")) return voice;
-	return OPENAI_TO_POLLY_MAP[normalizeLowercaseStringOrEmpty(voice)] || DEFAULT_POLLY_VOICE;
+	return OPENAI_TO_POLLY_MAP.get(normalizeLowercaseStringOrEmpty(voice)) ?? DEFAULT_POLLY_VOICE;
 }
 //#endregion
 //#region extensions/voice-call/src/manager/twiml.ts
@@ -1850,6 +1851,10 @@ function canonicalizeVoiceCallMediaBase64(payloadBase64) {
 	return canonicalizeBase64(payloadBase64.replaceAll("-", "+").replaceAll("_", "/"));
 }
 //#endregion
+//#region extensions/voice-call/src/websocket.ts
+const require = createRequire(import.meta.url);
+const { WebSocket, WebSocketServer } = require(path.join(path.dirname(require.resolve("ws/package.json")), "index.js"));
+//#endregion
 //#region extensions/voice-call/src/media-stream.ts
 const DEFAULT_PRE_START_TIMEOUT_MS = 5e3;
 const DEFAULT_MAX_PENDING_CONNECTIONS = 32;
@@ -2588,7 +2593,7 @@ function normalizeProviderStatus(status) {
 /** Map terminal provider status strings to OpenClaw end reasons. */
 function mapProviderStatusToEndReason(status) {
 	const normalized = normalizeProviderStatus(status);
-	return TERMINAL_PROVIDER_STATUS_TO_END_REASON[normalized] ?? null;
+	return Object.hasOwn(TERMINAL_PROVIDER_STATUS_TO_END_REASON, normalized) ? TERMINAL_PROVIDER_STATUS_TO_END_REASON[normalized] ?? null : null;
 }
 /** Return true when a provider status is terminal. */
 function isProviderStatusTerminal(status) {
@@ -2687,7 +2692,7 @@ const MAX_WEBHOOK_BODY_BYTES = WEBHOOK_BODY_READ_DEFAULTS.preAuth.maxBytes;
 const WEBHOOK_BODY_TIMEOUT_MS = WEBHOOK_BODY_READ_DEFAULTS.preAuth.timeoutMs;
 const MISSING_REMOTE_ADDRESS_IN_FLIGHT_KEY = "__voice_call_no_remote__";
 const loadRealtimeTranscriptionRuntime = createLazyRuntimeModule(() => import("./realtime-transcription.runtime-CbJAs5t_.js"));
-const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-BK43h7yV.js"));
+const loadResponseGeneratorModule = createLazyRuntimeModule(() => import("./response-generator-DsdC88Xg.js"));
 function appendRecentTalkEventMetadata(call, event) {
 	const metadata = call.metadata ?? {};
 	const recent = Array.isArray(metadata.recentTalkEvents) ? metadata.recentTalkEvents.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)) : [];
@@ -2997,7 +3002,10 @@ var VoiceCallWebhookServer = class {
 					return;
 				}
 				if (this.getUpgradePathname(request) === streamPath && this.mediaStreamHandler) this.mediaStreamHandler?.handleUpgrade(request, socket, head);
-				else socket.destroy();
+				else {
+					socket.once("error", () => {});
+					rejectWebSocketUpgrade(socket, { status: 404 });
+				}
 			});
 			this.server.on("error", (err) => {
 				this.server = null;
@@ -3413,12 +3421,12 @@ const REALTIME_VOICE_CONSULT_SYSTEM_PROMPT = [
 	"Do not print secret values or dump environment variables; only check whether required configuration is present.",
 	"Be accurate, brief, and speakable."
 ].join(" ");
-const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-DCbnTTjn.js"));
-const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-BwJFcA2z.js"));
-const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-qIMf0pd2.js"));
+const loadTelnyxProvider = createLazyRuntimeModule(() => import("./telnyx-eCxGOUfA.js"));
+const loadTwilioProvider = createLazyRuntimeModule(() => import("./twilio-DQKhnXXE.js"));
+const loadPlivoProvider = createLazyRuntimeModule(() => import("./plivo-BsdFT1gS.js"));
 const loadMockProvider = createLazyRuntimeModule(() => import("./mock-C57qj18W.js"));
 const loadRealtimeVoiceRuntime = createLazyRuntimeModule(() => import("./realtime-voice.runtime-vtdCOWg-.js"));
-const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-CHCnMJfl.js"));
+const loadRealtimeHandler = createLazyRuntimeModule(() => import("./realtime-handler-C7N4qzvf.js"));
 function resolveVoiceCallConsultSessionKey(call) {
 	return resolveVoiceCallSessionKey({
 		config: call.config,
@@ -3760,4 +3768,4 @@ async function createVoiceCallRuntime(params) {
 	}
 }
 //#endregion
-export { resolveUserPath as _, normalizeProviderStatus as a, resolveWebhookExposureStatus as c, setupTailscaleExposureRoutes as d, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as f, resolveVoiceCallAgentId as g, resolveCallAgentId as h, mapProviderStatusToEndReason as i, cleanupTailscaleExposureRoute as l, resolveVoiceResponseModel as m, normalizeProxyIp as n, canonicalizeVoiceCallMediaBase64 as o, chunkAudio as p, isProviderStatusTerminal as r, getHeader as s, createVoiceCallRuntime as t, getTailscaleSelfInfo as u, escapeXml as v, mapVoiceToPolly as y };
+export { resolveCallAgentId as _, normalizeProviderStatus as a, escapeXml as b, canonicalizeVoiceCallMediaBase64 as c, cleanupTailscaleExposureRoute as d, getTailscaleSelfInfo as f, resolveVoiceResponseModel as g, chunkAudio as h, mapProviderStatusToEndReason as i, getHeader as l, TELEPHONY_DEFAULT_TTS_TIMEOUT_MS as m, normalizeProxyIp as n, WebSocket as o, setupTailscaleExposureRoutes as p, isProviderStatusTerminal as r, WebSocketServer as s, createVoiceCallRuntime as t, resolveWebhookExposureStatus as u, resolveVoiceCallAgentId as v, mapVoiceToPolly as x, resolveUserPath as y };

package/dist/runtime-entry.js

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

package/dist/{store-path-C_z9zKnA.js → store-path-M0GXxUfv.js}

@@ -10,34 +10,6 @@ const ProviderNameSchema = z.enum([
 	"plivo",
 	"mock"
 ]);
-const CallStateSchema = z.enum([
-	"initiated",
-	"ringing",
-	"answered",
-	"active",
-	"speaking",
-	"listening",
-	"completed",
-	"hangup-user",
-	"hangup-bot",
-	"timeout",
-	"error",
-	"failed",
-	"no-answer",
-	"busy",
-	"voicemail"
-]);
-const TerminalStates = /* @__PURE__ */ new Set([
-	"completed",
-	"hangup-user",
-	"hangup-bot",
-	"timeout",
-	"error",
-	"failed",
-	"no-answer",
-	"busy",
-	"voicemail"
-]);
 const EndReasonSchema = z.enum([
 	"completed",
 	"hangup-user",
@@ -49,54 +21,16 @@ const EndReasonSchema = z.enum([
 	"busy",
 	"voicemail"
 ]);
-const BaseEventSchema = z.object({
-	id: z.string(),
-	dedupeKey: z.string().optional(),
-	callId: z.string(),
-	providerCallId: z.string().optional(),
-	timestamp: z.number(),
-	turnToken: z.string().optional(),
-	direction: z.enum(["inbound", "outbound"]).optional(),
-	from: z.string().optional(),
-	to: z.string().optional()
-});
-z.discriminatedUnion("type", [
-	BaseEventSchema.extend({ type: z.literal("call.initiated") }),
-	BaseEventSchema.extend({ type: z.literal("call.ringing") }),
-	BaseEventSchema.extend({ type: z.literal("call.answered") }),
-	BaseEventSchema.extend({ type: z.literal("call.active") }),
-	BaseEventSchema.extend({
-		type: z.literal("call.speaking"),
-		text: z.string()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.assistant-speech"),
-		transcript: z.string()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.speech"),
-		transcript: z.string(),
-		isFinal: z.boolean(),
-		confidence: z.number().min(0).max(1).optional()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.silence"),
-		durationMs: z.number()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.dtmf"),
-		digits: z.string()
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.ended"),
-		reason: EndReasonSchema
-	}),
-	BaseEventSchema.extend({
-		type: z.literal("call.error"),
-		error: z.string(),
-		retryable: z.boolean().optional()
-	})
+const CallStateSchema = z.enum([
+	"initiated",
+	"ringing",
+	"answered",
+	"active",
+	"speaking",
+	"listening",
+	...EndReasonSchema.options
 ]);
+const TerminalStates = new Set(EndReasonSchema.options);
 const CallDirectionSchema = z.enum(["outbound", "inbound"]);
 const TranscriptEntrySchema = z.object({
 	timestamp: z.number(),
@@ -358,12 +292,14 @@ function pruneCallRecordEvents(stores) {
 	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;
+function readCallRecordEvent(stores, eventKey, meta) {
+	if (!Number.isSafeInteger(meta.chunkCount) || meta.chunkCount < 1 || meta.chunkCount > 48) return null;
+	const records = stores.chunks.lookupMany?.(Array.from({ length: meta.chunkCount }, (_, index) => buildChunkKey(eventKey, index)));
 	const chunks = [];
 	for (let index = 0; index < meta.chunkCount; index += 1) {
-		const chunk = stores.chunks.lookup(buildChunkKey(eventKey, index));
+		const result = records?.[index];
+		if (result && !result.ok) throw result.error;
+		const chunk = records ? result?.value : stores.chunks.lookup(buildChunkKey(eventKey, index));
 		if (!chunk || chunk.index !== index) return null;
 		chunks.push(Buffer.from(chunk.dataBase64, "base64"));
 	}
@@ -372,7 +308,7 @@ function readCallRecordEvent(stores, eventKey) {
 /** 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);
+		const call = readCallRecordEvent(stores, entry.key, entry.value);
 		return call ? {
 			call,
 			persistedAt: entry.value.persistedAt ?? entry.createdAt,

package/dist/{telnyx-DCbnTTjn.js → telnyx-eCxGOUfA.js}

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

package/dist/{twilio-BwJFcA2z.js → twilio-DQKhnXXE.js}

@@ -1,8 +1,8 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
 import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-4fkgz3UG.js";
-import { a as normalizeProviderStatus, i as mapProviderStatusToEndReason, p as chunkAudio, r as isProviderStatusTerminal, s as getHeader, v as escapeXml, y as mapVoiceToPolly } from "./runtime-entry-DNmi-vZR.js";
-import { c as verifyTwilioWebhook, i as readVoiceCallProviderJsonResponse, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-BhLtja0F.js";
+import { a as normalizeProviderStatus, b as escapeXml, h as chunkAudio, i as mapProviderStatusToEndReason, l as getHeader, r as isProviderStatusTerminal, x as mapVoiceToPolly } from "./runtime-entry-Ln4SWaYK.js";
+import { c as verifyTwilioWebhook, i as readVoiceCallProviderJsonResponse, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-3Jy2k-eX.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";

package/openclaw.plugin.json

@@ -1,8 +1,9 @@
 {
   "id": "voice-call",
+  "categories": ["voice", "tools"],
   "doctorContract": {
     "resolveSessionStoreAgentIds": true,
-    "stateMigrations": true
+    "stateMigrations": [{ "id": "voice-call-calls-jsonl-to-plugin-state" }]
   },
   "name": "Voice Call",
   "description": "OpenClaw voice-call plugin for Twilio, Telnyx, and Plivo phone calls.",

package/package.json

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