@openclaw/voice-call 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/runtime-entry.js

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

package/dist/setup-api.js

@@ -1,18 +1,11 @@
-import { asOptionalRecord, isRecord, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asFiniteNumber, asOptionalRecord, isRecord, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/voice-call/src/config-migration.ts
-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) ?? {};
-	const existing = asObject(providers[providerId]) ?? {};
+	if (Object.keys(compatValues).length === 0) return asOptionalRecord(providersValue);
+	const providers = asOptionalRecord(providersValue) ?? {};
+	const existing = asOptionalRecord(providers[providerId]) ?? {};
 	return {
 		...providers,
 		[providerId]: {
@@ -23,23 +16,23 @@ function mergeProviderConfig(providersValue, providerId, compatValues) {
 }
 /** Migrate legacy voice-call config input to the current canonical shape. */
 function migrateVoiceCallLegacyConfigInput(params) {
-	const raw = asObject(params.value) ?? {};
-	const realtime = asObject(raw.realtime);
-	const realtimeAgentContext = asObject(realtime?.agentContext);
-	const twilio = asObject(raw.twilio);
-	const streaming = asObject(raw.streaming);
+	const raw = asOptionalRecord(params.value) ?? {};
+	const realtime = asOptionalRecord(raw.realtime);
+	const realtimeAgentContext = asOptionalRecord(realtime?.agentContext);
+	const twilio = asOptionalRecord(raw.twilio);
+	const streaming = asOptionalRecord(raw.streaming);
 	const configPathPrefix = params.configPathPrefix ?? "plugins.entries.voice-call.config";
 	const legacyStreamingOpenAICompat = {};
-	const streamingOpenAIApiKey = getString(streaming, "openaiApiKey");
+	const streamingOpenAIApiKey = readStringField(streaming, "openaiApiKey");
 	if (streamingOpenAIApiKey) legacyStreamingOpenAICompat.apiKey = streamingOpenAIApiKey;
-	const streamingSttModel = getString(streaming, "sttModel");
+	const streamingSttModel = readStringField(streaming, "sttModel");
 	if (streamingSttModel) legacyStreamingOpenAICompat.model = streamingSttModel;
-	const streamingSilenceDurationMs = getNumber(streaming, "silenceDurationMs");
+	const streamingSilenceDurationMs = asFiniteNumber(streaming?.silenceDurationMs);
 	if (streamingSilenceDurationMs !== void 0) legacyStreamingOpenAICompat.silenceDurationMs = streamingSilenceDurationMs;
-	const streamingVadThreshold = getNumber(streaming, "vadThreshold");
+	const streamingVadThreshold = asFiniteNumber(streaming?.vadThreshold);
 	if (streamingVadThreshold !== void 0) legacyStreamingOpenAICompat.vadThreshold = streamingVadThreshold;
-	const streamingProvider = getString(streaming, "provider");
-	const legacyStreamingProvider = getString(streaming, "sttProvider");
+	const streamingProvider = readStringField(streaming, "provider");
+	const legacyStreamingProvider = readStringField(streaming, "sttProvider");
 	const normalizedStreaming = streaming ? {
 		...streaming,
 		provider: streamingProvider ?? legacyStreamingProvider,
@@ -74,9 +67,9 @@ function migrateVoiceCallLegacyConfigInput(params) {
 	if (typeof streaming?.sttProvider === "string") changes.push(`Moved ${configPathPrefix}.streaming.sttProvider → ${configPathPrefix}.streaming.provider.`);
 	if (typeof streaming?.openaiApiKey === "string") changes.push(`Moved ${configPathPrefix}.streaming.openaiApiKey → ${configPathPrefix}.streaming.providers.openai.apiKey.`);
 	if (typeof streaming?.sttModel === "string") changes.push(`Moved ${configPathPrefix}.streaming.sttModel → ${configPathPrefix}.streaming.providers.openai.model.`);
-	if (getNumber(streaming, "silenceDurationMs") !== void 0) changes.push(`Moved ${configPathPrefix}.streaming.silenceDurationMs → ${configPathPrefix}.streaming.providers.openai.silenceDurationMs.`);
+	if (asFiniteNumber(streaming?.silenceDurationMs) !== void 0) changes.push(`Moved ${configPathPrefix}.streaming.silenceDurationMs → ${configPathPrefix}.streaming.providers.openai.silenceDurationMs.`);
 	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.`);
+	if (asFiniteNumber(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.hasOwn(realtimeAgentContext, "includeSystemPrompt")) changes.push(`Removed ${configPathPrefix}.realtime.agentContext.includeSystemPrompt.`);
 	return {

package/dist/{store-path-nYL-yM0S.js → store-path-51_oC_xn.js}

@@ -130,6 +130,54 @@ const { setRuntime: setVoiceCallStateRuntime, tryGetRuntime: getOptionalVoiceCal
 	errorMessage: "Voice Call state runtime not initialized"
 });
 //#endregion
+//#region extensions/voice-call/src/manager/replay-keys.ts
+/** Match the existing voice-call webhook replay-cache cardinality. */
+const MAX_MANAGER_REPLAY_KEYS = 1e4;
+function pruneOldestSetEntries(keys, maxEntries) {
+	while (keys.size > maxEntries) {
+		const oldest = keys.values().next().value;
+		if (oldest === void 0) break;
+		keys.delete(oldest);
+	}
+}
+function pruneOldestMapEntries(keys, maxEntries) {
+	while (keys.size > maxEntries) {
+		const oldest = keys.keys().next().value;
+		if (oldest === void 0) break;
+		keys.delete(oldest);
+	}
+}
+/** Remember one manager replay key without refreshing duplicate insertion order. */
+function rememberManagerReplayKey(keys, key, maxEntries = MAX_MANAGER_REPLAY_KEYS) {
+	keys.add(key);
+	pruneOldestSetEntries(keys, maxEntries);
+}
+/** Append one per-call replay key and retain only the newest bounded suffix. */
+function appendCallReplayKey(keys, key, maxEntries = 500) {
+	keys.push(key);
+	trimCallReplayKeys(keys, maxEntries);
+}
+/** Normalize restored or externally constructed call replay history in place. */
+function trimCallReplayKeys(keys, maxEntries = 500) {
+	const overflow = keys.length - maxEntries;
+	if (overflow > 0) keys.splice(0, overflow);
+}
+/**
+* Reserve one rejected provider call. The token prevents a stale failed
+* hangup from deleting a newer reservation after bounded eviction and reuse.
+*/
+function reserveRejectedProviderCall(calls, providerCallId, maxEntries = MAX_MANAGER_REPLAY_KEYS) {
+	if (calls.has(providerCallId)) return;
+	const reservation = Symbol(providerCallId);
+	calls.set(providerCallId, reservation);
+	pruneOldestMapEntries(calls, maxEntries);
+	return reservation;
+}
+/** Release a rejected-call reservation only when the failing attempt still owns it. */
+function releaseRejectedProviderCall(calls, providerCallId, reservation) {
+	if (calls.get(providerCallId) === reservation) calls.delete(providerCallId);
+}
+//#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";
@@ -237,10 +285,18 @@ function countCallRecordChunks(call) {
 }
 /** 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;
+	let boundedCall = call;
+	if (call.processedEventIds.length > 500) {
+		boundedCall = {
+			...call,
+			processedEventIds: [...call.processedEventIds]
+		};
+		trimCallReplayKeys(boundedCall.processedEventIds);
+	}
+	if (countCallRecordChunks(boundedCall) <= 48) return boundedCall;
+	const transcriptEntries = boundedCall.transcript.length;
 	const metadata = {
-		...call.metadata,
+		...boundedCall.metadata,
 		voiceCallPersistence: {
 			transcriptTruncated: true,
 			originalTranscriptEntries: transcriptEntries
@@ -266,12 +322,12 @@ function prepareVoiceCallRecordForStorage(call) {
 	];
 	for (const candidateInput of candidateInputs) {
 		const candidate = CallRecordSchema.parse({
-			...call,
+			...boundedCall,
 			...candidateInput
 		});
 		if (countCallRecordChunks(candidate) <= 48) return candidate;
 	}
-	return call;
+	return boundedCall;
 }
 /** Register a serialized call record event and its chunks, then prune old events. */
 function registerCallRecordEvent(stores, eventKey, call, order) {
@@ -356,17 +412,19 @@ function loadActiveCallsFromStore(storePath) {
 	if (calls.length === 0) return {
 		activeCalls: /* @__PURE__ */ new Map(),
 		providerCallIdMap: /* @__PURE__ */ new Map(),
-		processedEventIds: /* @__PURE__ */ new Set(),
-		rejectedProviderCallIds: /* @__PURE__ */ new Set()
+		processedEventIds: /* @__PURE__ */ new Set()
 	};
 	const callMap = /* @__PURE__ */ new Map();
-	for (const call of calls) callMap.set(call.callId, call);
+	for (const call of calls) {
+		callMap.delete(call.callId);
+		callMap.set(call.callId, call);
+	}
 	const activeCalls = /* @__PURE__ */ new Map();
 	const providerCallIdMap = /* @__PURE__ */ new Map();
 	const processedEventIds = /* @__PURE__ */ new Set();
-	const rejectedProviderCallIds = /* @__PURE__ */ new Set();
 	for (const [callId, call] of callMap) {
-		for (const eventId of call.processedEventIds) processedEventIds.add(eventId);
+		trimCallReplayKeys(call.processedEventIds);
+		for (const eventId of call.processedEventIds) rememberManagerReplayKey(processedEventIds, eventId);
 		if (TerminalStates.has(call.state)) continue;
 		activeCalls.set(callId, call);
 		if (call.providerCallId) providerCallIdMap.set(call.providerCallId, callId);
@@ -374,8 +432,7 @@ function loadActiveCallsFromStore(storePath) {
 	return {
 		activeCalls,
 		providerCallIdMap,
-		processedEventIds,
-		rejectedProviderCallIds
+		processedEventIds
 	};
 }
 function readCallHistoryFromStore(storePath) {
@@ -407,4 +464,4 @@ function resolveDefaultVoiceCallStoreDir(env = process.env) {
 	return path.join(resolveStateDir(env), "voice-calls");
 }
 //#endregion
-export { TerminalStates as _, CALL_RECORD_EVENT_META_MAX_ENTRIES as a, buildVoiceCallLegacyJsonlEventKey as c, loadActiveCallsFromStore as d, parseVoiceCallRecordLine as f, setVoiceCallStateRuntime as g, resolveVoiceCallLegacyCallLogPath as h, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as i, findCallMatchesInStore as l, prepareVoiceCallRecordForStorage as m, CALL_RECORD_CHUNK_MAX_ENTRIES as n, MAX_CALL_RECORD_EVENTS as o, persistCallRecord as p, CALL_RECORD_EVENTS_NAMESPACE as r, RAW_CALL_RECORD_CHUNK_BYTES as s, resolveDefaultVoiceCallStoreDir as t, getCallHistoryFromStore as u };
+export { releaseRejectedProviderCall as _, CALL_RECORD_EVENT_META_MAX_ENTRIES as a, setVoiceCallStateRuntime as b, buildVoiceCallLegacyJsonlEventKey as c, loadActiveCallsFromStore as d, parseVoiceCallRecordLine as f, appendCallReplayKey as g, resolveVoiceCallLegacyCallLogPath as h, CALL_RECORD_EVENT_CHUNKS_NAMESPACE as i, findCallMatchesInStore as l, prepareVoiceCallRecordForStorage as m, CALL_RECORD_CHUNK_MAX_ENTRIES as n, MAX_CALL_RECORD_EVENTS as o, persistCallRecord as p, CALL_RECORD_EVENTS_NAMESPACE as r, RAW_CALL_RECORD_CHUNK_BYTES as s, resolveDefaultVoiceCallStoreDir as t, getCallHistoryFromStore as u, rememberManagerReplayKey as v, TerminalStates as x, reserveRejectedProviderCall as y };

package/dist/{telnyx-Dx6cfLvV.js → telnyx-DO8dFQcb.js}

@@ -1,4 +1,4 @@
-import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-DS9sZa3C.js";
+import { s as verifyTelnyxWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-j4OEG0fR.js";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/telnyx.ts
 function normalizeTelnyxDirection(direction) {
@@ -57,7 +57,8 @@ var TelnyxProvider = class {
 			ok: result.ok,
 			reason: result.reason,
 			isReplay: result.isReplay,
-			verifiedRequestKey: result.verifiedRequestKey
+			verifiedRequestKey: result.verifiedRequestKey,
+			releaseReplay: result.releaseReplay
 		};
 	}
 	/**
@@ -121,13 +122,17 @@ var TelnyxProvider = class {
 				type: "call.speaking",
 				text: data.payload?.text || ""
 			};
-			case "call.transcription": return {
-				...baseEvent,
-				type: "call.speech",
-				transcript: data.payload?.transcription_data?.transcript ?? data.payload?.transcription ?? "",
-				isFinal: data.payload?.transcription_data?.is_final ?? data.payload?.is_final ?? true,
-				confidence: data.payload?.transcription_data?.confidence ?? data.payload?.confidence
-			};
+			case "call.transcription": {
+				const transcript = data.payload?.transcription_data?.transcript ?? data.payload?.transcription ?? "";
+				if (!transcript.trim()) return null;
+				return {
+					...baseEvent,
+					type: "call.speech",
+					transcript,
+					isFinal: data.payload?.transcription_data?.is_final ?? data.payload?.is_final ?? true,
+					confidence: data.payload?.transcription_data?.confidence ?? data.payload?.confidence
+				};
+			}
 			case "call.hangup": return {
 				...baseEvent,
 				type: "call.ended",

package/dist/{twilio-D_D8KysU.js → twilio-JDt_1nlz.js}

@@ -1,13 +1,13 @@
 import { fetchWithSsrFGuard } from "./runtime-api.js";
 import "./api.js";
 import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-4fkgz3UG.js";
-import { _ as escapeXml, a as normalizeProviderStatus, i as mapProviderStatusToEndReason, p as chunkAudio, r as isProviderStatusTerminal, s as getHeader, v as mapVoiceToPolly } from "./runtime-entry-D0UJiLfi.js";
-import { c as verifyTwilioWebhook, i as readProviderJsonResponseText, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-DS9sZa3C.js";
+import { _ as escapeXml, a as normalizeProviderStatus, i as mapProviderStatusToEndReason, p as chunkAudio, r as isProviderStatusTerminal, s as getHeader, v as mapVoiceToPolly } from "./runtime-entry-DK8kPCGC.js";
+import { c as verifyTwilioWebhook, i as readVoiceCallProviderJsonResponse, n as cancelProviderResponseBody, r as readProviderErrorResponseSnippet, t as guardedJsonApiRequest } from "./guarded-json-api-j4OEG0fR.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
 //#region extensions/voice-call/src/providers/twilio/api.ts
 const TWILIO_API_TIMEOUT_MS = 3e4;
 /** Parse Twilio JSON error responses without trusting response shape. */
@@ -68,13 +68,7 @@ async function twilioApiRequest(params) {
 			const errorText = await readProviderErrorResponseSnippet(response);
 			throw new TwilioApiError(response.status, errorText);
 		}
-		const text = await readProviderJsonResponseText(response);
-		if (!text) return;
-		try {
-			return JSON.parse(text);
-		} catch {
-			throw new Error("Twilio API returned malformed JSON.");
-		}
+		return await readVoiceCallProviderJsonResponse(response, "Twilio API returned malformed JSON.");
 	} finally {
 		await release();
 	}
@@ -138,7 +132,8 @@ function verifyTwilioProviderWebhook(params) {
 		ok: result.ok,
 		reason: result.reason,
 		isReplay: result.isReplay,
-		verifiedRequestKey: result.verifiedRequestKey
+		verifiedRequestKey: result.verifiedRequestKey,
+		releaseReplay: result.releaseReplay
 	};
 }
 //#endregion
@@ -172,17 +167,20 @@ var TwilioProvider = class TwilioProvider {
 		this.notifyCalls.delete(callId);
 	}
 	/**
-	* Delete stored TwiML for a call, addressed by Twilio's provider call SID.
-	*
-	* This is used when we only have `providerCallId` (e.g. hangup).
+	* Release all process-local metadata owned by one Twilio call.
+	* Terminal webhooks can be replayed, so this must stay idempotent.
 	*/
-	deleteStoredTwimlForProviderCall(providerCallId) {
+	releaseCallState(providerCallId, callId) {
 		const webhookUrl = this.callWebhookUrls.get(providerCallId);
-		if (!webhookUrl) return;
-		const callId = webhookUrl.match(/callId=([^&]+)/)?.[1];
-		if (!callId) return;
-		this.deleteStoredTwiml(callId);
+		let resolvedCallId = callId;
+		if (!resolvedCallId && webhookUrl) try {
+			resolvedCallId = new URL(webhookUrl).searchParams.get("callId") || void 0;
+		} catch {}
+		if (resolvedCallId) this.deleteStoredTwiml(resolvedCallId);
+		this.callWebhookUrls.delete(providerCallId);
+		this.callStreamMap.delete(providerCallId);
 		this.streamAuthTokens.delete(providerCallId);
+		this.activeStreamCalls.delete(providerCallId);
 	}
 	constructor(config, options = {}) {
 		this.name = "twilio";
@@ -190,6 +188,7 @@ var TwilioProvider = class TwilioProvider {
 		this.currentPublicUrl = null;
 		this.ttsProvider = null;
 		this.mediaStreamHandler = null;
+		this.playbackMarkSequence = 0;
 		this.callStreamMap = /* @__PURE__ */ new Map();
 		this.streamAuthTokens = /* @__PURE__ */ new Map();
 		this.twimlStorage = /* @__PURE__ */ new Map();
@@ -263,15 +262,16 @@ var TwilioProvider = class TwilioProvider {
 		});
 	}
 	async updateLiveCallTwiml(providerCallId, twiml, operation) {
-		for (const retryDelayMs of TWILIO_CALL_UPDATE_RETRY_DELAYS_MS) try {
-			await this.apiRequest(`/Calls/${providerCallId}.json`, { Twiml: twiml });
-			return;
-		} catch (err) {
-			if (!isTwilioCallNotInProgressError(err)) throw err;
-			console.warn(`[voice-call] Twilio ${operation} update hit call state race (21220); retrying in ${retryDelayMs}ms`);
-			await setTimeout$1(retryDelayMs);
-		}
-		await this.apiRequest(`/Calls/${providerCallId}.json`, { Twiml: twiml });
+		await retryAsync(() => this.apiRequest(`/Calls/${providerCallId}.json`, { Twiml: twiml }), {
+			attempts: TWILIO_CALL_UPDATE_RETRY_DELAYS_MS.length + 1,
+			minDelayMs: 0,
+			shouldRetry: isTwilioCallNotInProgressError,
+			delayMs: ({ attempt }) => TWILIO_CALL_UPDATE_RETRY_DELAYS_MS[attempt - 1] ?? 0,
+			onRetry: ({ delayMs }) => {
+				console.warn(`[voice-call] Twilio ${operation} update hit call state race (21220); retrying in ${delayMs}ms`);
+			},
+			sleep: (delayMs) => sleepWithAbort(delayMs)
+		});
 	}
 	/**
 	* Verify Twilio webhook signature using HMAC-SHA1.
@@ -303,6 +303,7 @@ var TwilioProvider = class TwilioProvider {
 				dedupeKey,
 				turnToken: turnTokenFromQuery
 			});
+			if (event?.direction === "inbound" && event.type !== "call.ended" && event.providerCallId && this.currentPublicUrl && !this.callWebhookUrls.has(event.providerCallId)) this.callWebhookUrls.set(event.providerCallId, this.currentPublicUrl);
 			const twiml = this.generateTwimlResponse(ctx);
 			return {
 				events: event ? [event] : [],
@@ -347,7 +348,7 @@ var TwilioProvider = class TwilioProvider {
 			to: params.get("To") || void 0
 		};
 		const speechResult = params.get("SpeechResult");
-		if (speechResult) return {
+		if (speechResult?.trim()) return {
 			...baseEvent,
 			type: "call.speech",
 			transcript: speechResult,
@@ -375,14 +376,13 @@ var TwilioProvider = class TwilioProvider {
 		};
 		const endReason = mapProviderStatusToEndReason(callStatus);
 		if (endReason) {
-			this.streamAuthTokens.delete(callSid);
-			this.activeStreamCalls.delete(callSid);
-			if (callIdOverride) this.deleteStoredTwiml(callIdOverride);
-			return {
+			const event = {
 				...baseEvent,
 				type: "call.ended",
 				reason: endReason
 			};
+			this.releaseCallState(callSid, callIdOverride);
+			return event;
 		}
 		return null;
 	}
@@ -524,11 +524,8 @@ var TwilioProvider = class TwilioProvider {
 	* Hang up a call via Twilio API.
 	*/
 	async hangupCall(input) {
-		this.deleteStoredTwimlForProviderCall(input.providerCallId);
-		this.callWebhookUrls.delete(input.providerCallId);
-		this.streamAuthTokens.delete(input.providerCallId);
-		this.activeStreamCalls.delete(input.providerCallId);
 		await this.apiRequest(`/Calls/${input.providerCallId}.json`, { Status: "completed" }, { allowNotFound: true });
+		this.releaseCallState(input.providerCallId, input.callId);
 	}
 	/**
 	* Play TTS audio via Twilio.
@@ -593,10 +590,6 @@ var TwilioProvider = class TwilioProvider {
 			const raw = handler.sendAudio(streamSid, audio);
 			return normalizeSendResult(raw);
 		};
-		const sendPlaybackMark = (name) => {
-			const raw = handler.sendMark(streamSid, name);
-			return normalizeSendResult(raw);
-		};
 		await handler.queueTts(streamSid, async (signal) => {
 			const sendKeepAlive = () => {
 				sendAudioChunk(SILENCE_CHUNK);
@@ -607,6 +600,7 @@ var TwilioProvider = class TwilioProvider {
 			}, CHUNK_DELAY_MS);
 			let muLawAudio;
 			let synthTimeout = null;
+			let removeAbortListener = () => {};
 			const synthTimeoutMs = ttsProvider.synthesisTimeoutMs;
 			try {
 				const synthPromise = ttsProvider.synthesizeForTelephony(text);
@@ -615,10 +609,23 @@ var TwilioProvider = class TwilioProvider {
 						reject(/* @__PURE__ */ new Error(`Telephony TTS synthesis timed out after ${synthTimeoutMs}ms`));
 					}, synthTimeoutMs);
 				});
-				muLawAudio = await Promise.race([synthPromise, timeoutPromise]);
+				const abortPromise = new Promise((_, reject) => {
+					const onAbort = () => {
+						reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Telephony TTS synthesis aborted"));
+					};
+					signal.addEventListener("abort", onAbort, { once: true });
+					removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+					if (signal.aborted) onAbort();
+				});
+				muLawAudio = await Promise.race([
+					synthPromise,
+					timeoutPromise,
+					abortPromise
+				]);
 			} finally {
 				if (synthTimeout) clearTimeout(synthTimeout);
 				clearInterval(keepAlive);
+				removeAbortListener();
 			}
 			if (muLawAudio.length === 0) throw new Error("Telephony TTS produced no audio");
 			let chunkAttempts = 0;
@@ -627,7 +634,11 @@ var TwilioProvider = class TwilioProvider {
 			for (const chunk of chunkAudio(muLawAudio, CHUNK_SIZE)) {
 				if (signal.aborted) break;
 				chunkAttempts += 1;
-				if (sendAudioChunk(chunk).sent) chunkDelivered += 1;
+				if (!sendAudioChunk(chunk).sent) {
+					handler.clearAudio(streamSid);
+					throw new Error(`Telephony stream playback failed: audio chunk ${chunkAttempts} not delivered`);
+				}
+				chunkDelivered += 1;
 				const waitMs = nextChunkDueAt - Date.now();
 				if (waitMs > 0) try {
 					await sleepWithAbort(Math.ceil(waitMs), signal);
@@ -638,14 +649,10 @@ var TwilioProvider = class TwilioProvider {
 				nextChunkDueAt += CHUNK_DELAY_MS;
 				if (signal.aborted) break;
 			}
-			let markSent = true;
-			if (!signal.aborted) markSent = sendPlaybackMark(`tts-${Date.now()}`).sent;
-			if (!signal.aborted && chunkAttempts > 0 && (chunkDelivered === 0 || !markSent)) {
-				const failures = [];
-				if (chunkDelivered === 0) failures.push("no audio chunks delivered");
-				if (!markSent) failures.push("completion mark not delivered");
-				throw new Error(`Telephony stream playback failed: ${failures.join("; ")}`);
-			}
+			if (signal.aborted) return;
+			if (chunkAttempts === 0 || chunkDelivered !== chunkAttempts) throw new Error("Telephony stream playback failed: incomplete audio delivery");
+			const markName = `tts-${Date.now()}-${++this.playbackMarkSequence}`;
+			await handler.sendMarkAndWait(streamSid, markName, muLawAudio.length / 8, signal);
 		});
 	}
 	/**

package/dist/{webhook-replay-aaP79dI8.js → webhook-replay-FQrEGVSM.js}

@@ -10,23 +10,37 @@ function createWebhookReplayCache() {
 	};
 }
 function pruneWebhookReplayCache(cache, now) {
-	for (const [key, expiresAt] of cache.seenUntil) if (!isFutureDateTimestampMs(expiresAt, { nowMs: now })) cache.seenUntil.delete(key);
+	for (const [key, reservation] of cache.seenUntil) if (!isFutureDateTimestampMs(reservation.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;
 		cache.seenUntil.delete(oldest);
 	}
 }
-function markWebhookReplay(cache, replayKey) {
+function reserveWebhookReplay(cache, replayKey) {
 	const now = Date.now();
 	cache.calls += 1;
 	if (cache.calls % REPLAY_CACHE_PRUNE_INTERVAL === 0) pruneWebhookReplayCache(cache, now);
 	const existing = cache.seenUntil.get(replayKey);
-	if (existing !== void 0 && isFutureDateTimestampMs(existing, { nowMs: now })) return true;
+	if (existing !== void 0 && isFutureDateTimestampMs(existing.expiresAt, { nowMs: now })) return {
+		isReplay: true,
+		verifiedRequestKey: replayKey
+	};
 	const expiresAt = resolveExpiresAtMsFromDurationMs(REPLAY_WINDOW_MS, { nowMs: now });
-	if (expiresAt !== void 0) cache.seenUntil.set(replayKey, expiresAt);
+	if (expiresAt === void 0) return {
+		isReplay: false,
+		verifiedRequestKey: replayKey
+	};
+	const reservation = { expiresAt };
+	cache.seenUntil.set(replayKey, reservation);
 	if (cache.seenUntil.size > REPLAY_CACHE_MAX_ENTRIES) pruneWebhookReplayCache(cache, now);
-	return false;
+	return {
+		isReplay: false,
+		verifiedRequestKey: replayKey,
+		releaseReplay: () => {
+			if (cache.seenUntil.get(replayKey) === reservation) cache.seenUntil.delete(replayKey);
+		}
+	};
 }
 //#endregion
-export { markWebhookReplay as n, createWebhookReplayCache as t };
+export { reserveWebhookReplay as n, createWebhookReplayCache as t };