@absolutejs/voice 0.0.22-beta.270 → 0.0.22-beta.272

package/dist/index.d.ts

@@ -160,13 +160,13 @@ export type { VoiceSQLiteRuntimeStorage, VoiceSQLiteStoreOptions } from './sqlit
 export type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceOpsTaskAgeBucket, VoiceOpsTaskAnalyticsOptions, VoiceOpsTaskAnalyticsSummary, VoiceOpsTaskAssignmentRule, VoiceOpsTaskAssignmentRuleCondition, VoiceOpsTaskAssignmentRules, VoiceOpsTaskAssigneeAnalytics, VoiceOpsDispositionTaskPolicies, VoiceOpsSLABreachPolicy, VoiceIntegrationDeliveryStatus, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceIntegrationSinkDelivery, VoiceIntegrationEventType, VoiceIntegrationWebhookConfig, VoiceOpsTask, VoiceOpsTaskHistoryEntry, VoiceOpsTaskKind, VoiceOpsTaskPolicy, VoiceOpsTaskPriority, VoiceOpsTaskStatus, VoiceOpsTaskStore, VoiceOpsTaskSummary, VoiceOpsTaskWorkerAnalytics } from './ops';
 export { createTwilioMediaStreamBridge, createTwilioVoiceRoutes, createTwilioVoiceResponse, decodeTwilioMulawBase64, encodeTwilioMulawBase64, transcodePCMToTwilioOutboundPayload, transcodeTwilioInboundPayloadToPCM16 } from './telephony/twilio';
 export { evaluateVoiceTelephonyContract } from './telephony/contract';
-export { createTelnyxMediaStreamBridge, createTelnyxVoiceResponse, createTelnyxVoiceRoutes, verifyVoiceTelnyxWebhookSignature } from './telephony/telnyx';
-export { createMemoryVoicePlivoWebhookNonceStore, createPlivoMediaStreamBridge, createPlivoVoiceResponse, createPlivoVoiceRoutes, createVoicePlivoWebhookVerifier, signVoicePlivoWebhook, verifyVoicePlivoWebhookSignature } from './telephony/plivo';
+export { createMemoryVoiceTelnyxWebhookEventStore, createTelnyxMediaStreamBridge, createTelnyxVoiceResponse, createTelnyxVoiceRoutes, createVoicePostgresTelnyxWebhookEventStore, createVoiceRedisTelnyxWebhookEventStore, createVoiceSQLiteTelnyxWebhookEventStore, createVoiceTelnyxWebhookVerifier, verifyVoiceTelnyxWebhookSignature } from './telephony/telnyx';
+export { createMemoryVoicePlivoWebhookNonceStore, createPlivoMediaStreamBridge, createPlivoVoiceResponse, createPlivoVoiceRoutes, createVoicePostgresPlivoWebhookNonceStore, createVoicePlivoWebhookVerifier, createVoiceRedisPlivoWebhookNonceStore, createVoiceSQLitePlivoWebhookNonceStore, signVoicePlivoWebhook, verifyVoicePlivoWebhookSignature } from './telephony/plivo';
 export { createVoiceTelephonyCarrierMatrix, createVoiceTelephonyCarrierMatrixRoutes, renderVoiceTelephonyCarrierMatrixHTML } from './telephony/matrix';
 export type { TwilioInboundMessage, TwilioMediaStreamBridge, TwilioMediaStreamBridgeOptions, TwilioMediaStreamSocket, TwilioOutboundClearMessage, TwilioOutboundMarkMessage, TwilioOutboundMediaMessage, TwilioOutboundMessage, TwilioVoiceRouteParameters, TwilioVoiceResponseOptions, TwilioVoiceSmokeCheck, TwilioVoiceSmokeOptions, TwilioVoiceSmokeReport, TwilioVoiceSetupOptions, TwilioVoiceSetupStatus, TwilioVoiceRoutesOptions } from './telephony/twilio';
 export type { VoiceTelephonyContractIssue, VoiceTelephonyContractOptions, VoiceTelephonyContractReport, VoiceTelephonyContractRequirement, VoiceTelephonyProvider, VoiceTelephonySetupStatus, VoiceTelephonySmokeCheck, VoiceTelephonySmokeReport } from './telephony/contract';
-export type { TelnyxInboundMessage, TelnyxMediaPayload, TelnyxMediaStreamBridge, TelnyxMediaStreamBridgeOptions, TelnyxMediaStreamSocket, TelnyxOutboundClearMessage, TelnyxOutboundMarkMessage, TelnyxOutboundMediaMessage, TelnyxOutboundMessage, TelnyxVoiceResponseOptions, TelnyxVoiceRoutesOptions, TelnyxVoiceSetupOptions, TelnyxVoiceSetupStatus, TelnyxVoiceSmokeCheck, TelnyxVoiceSmokeOptions, TelnyxVoiceSmokeReport } from './telephony/telnyx';
-export type { PlivoInboundMessage, PlivoMediaStreamBridge, PlivoMediaStreamBridgeOptions, PlivoMediaStreamSocket, PlivoOutboundCheckpointMessage, PlivoOutboundClearAudioMessage, PlivoOutboundMessage, PlivoOutboundPlayAudioMessage, PlivoVoiceResponseOptions, PlivoVoiceRoutesOptions, PlivoVoiceSetupOptions, PlivoVoiceSetupStatus, PlivoVoiceSmokeCheck, PlivoVoiceSmokeOptions, PlivoVoiceSmokeReport, VoicePlivoWebhookNonceStore, VoicePlivoWebhookVerifierOptions } from './telephony/plivo';
+export type { TelnyxInboundMessage, TelnyxMediaPayload, TelnyxMediaStreamBridge, TelnyxMediaStreamBridgeOptions, TelnyxMediaStreamSocket, TelnyxOutboundClearMessage, TelnyxOutboundMarkMessage, TelnyxOutboundMediaMessage, TelnyxOutboundMessage, TelnyxVoiceResponseOptions, TelnyxVoiceRoutesOptions, TelnyxVoiceSetupOptions, TelnyxVoiceSetupStatus, TelnyxVoiceSmokeCheck, TelnyxVoiceSmokeOptions, TelnyxVoiceSmokeReport, VoicePostgresTelnyxWebhookEventStoreOptions, VoiceRedisTelnyxWebhookEventClient, VoiceRedisTelnyxWebhookEventStoreOptions, VoiceSQLiteTelnyxWebhookEventStoreOptions, VoiceTelnyxWebhookEventStore, VoiceTelnyxWebhookEventStoreOptions, VoiceTelnyxWebhookVerifierOptions } from './telephony/telnyx';
+export type { PlivoInboundMessage, PlivoMediaStreamBridge, PlivoMediaStreamBridgeOptions, PlivoMediaStreamSocket, PlivoOutboundCheckpointMessage, PlivoOutboundClearAudioMessage, PlivoOutboundMessage, PlivoOutboundPlayAudioMessage, PlivoVoiceResponseOptions, PlivoVoiceRoutesOptions, PlivoVoiceSetupOptions, PlivoVoiceSetupStatus, PlivoVoiceSmokeCheck, PlivoVoiceSmokeOptions, PlivoVoiceSmokeReport, VoicePostgresPlivoWebhookNonceStoreOptions, VoicePlivoWebhookNonceStore, VoicePlivoWebhookNonceStoreOptions, VoicePlivoWebhookVerifierOptions, VoiceRedisPlivoWebhookNonceClient, VoiceRedisPlivoWebhookNonceStoreOptions, VoiceSQLitePlivoWebhookNonceStoreOptions } from './telephony/plivo';
 export type { VoiceTelephonyCarrierMatrix, VoiceTelephonyCarrierMatrixEntry, VoiceTelephonyCarrierMatrixInput, VoiceTelephonyCarrierMatrixOptions, VoiceTelephonyCarrierMatrixRoutesOptions, VoiceTelephonyCarrierMatrixStatus } from './telephony/matrix';
 export { shapeTelephonyAssistantText } from './telephony/response';
 export type { TelephonyResponseShapeMode, TelephonyResponseShapeOptions } from './telephony/response';

package/dist/index.js

@@ -18109,6 +18109,7 @@ import { Elysia as Elysia34 } from "elysia";
 
 // src/telephony/plivo.ts
 import { Buffer as Buffer5 } from "buffer";
+import { Database } from "bun:sqlite";
 import { Elysia as Elysia30 } from "elysia";
 
 // src/telephony/contract.ts
@@ -19125,12 +19126,148 @@ var verifyVoicePlivoWebhookSignature = async (input) => {
 var createMemoryVoicePlivoWebhookNonceStore = () => {
   const nonces = new Set;
   return {
+    claim: (nonce) => {
+      if (nonces.has(nonce)) {
+        return false;
+      }
+      nonces.add(nonce);
+      return true;
+    },
     has: (nonce) => nonces.has(nonce),
     set: (nonce) => {
       nonces.add(nonce);
     }
   };
 };
+var normalizePlivoStoreIdentifierSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
+var quotePlivoStoreIdentifier = (value) => `"${value.replace(/"/g, '""')}"`;
+var resolvePlivoNonceTableName = (input) => {
+  if (input.tableName) {
+    return normalizePlivoStoreIdentifierSegment(input.tableName);
+  }
+  return `${normalizePlivoStoreIdentifierSegment(input.tablePrefix ?? "voice")}_${normalizePlivoStoreIdentifierSegment(input.fallback)}`;
+};
+var getPlivoNonceExpiresAt = (ttlSeconds) => typeof ttlSeconds === "number" && ttlSeconds > 0 ? Date.now() + Math.ceil(ttlSeconds * 1000) : null;
+var createVoiceSQLitePlivoWebhookNonceStore = (options) => {
+  const database = options.database ?? new Database(options.path ?? ":memory:", {
+    create: true
+  });
+  const tableName = resolvePlivoNonceTableName({
+    fallback: "plivo_webhook_nonces",
+    tableName: options.tableName,
+    tablePrefix: options.tablePrefix
+  });
+  database.exec(`CREATE TABLE IF NOT EXISTS "${tableName}" (
+			nonce TEXT PRIMARY KEY,
+			created_at INTEGER NOT NULL,
+			expires_at INTEGER
+		)`);
+  const pruneExpired = database.query(`DELETE FROM "${tableName}" WHERE expires_at IS NOT NULL AND expires_at <= ?1`);
+  const select = database.query(`SELECT nonce FROM "${tableName}" WHERE nonce = ?1 AND (expires_at IS NULL OR expires_at > ?2) LIMIT 1`);
+  const insert = database.query(`INSERT OR IGNORE INTO "${tableName}" (nonce, created_at, expires_at) VALUES (?1, ?2, ?3)`);
+  const upsert = database.query(`INSERT INTO "${tableName}" (nonce, created_at, expires_at) VALUES (?1, ?2, ?3)
+		 ON CONFLICT(nonce) DO UPDATE SET expires_at = excluded.expires_at`);
+  return {
+    claim: (nonce) => {
+      const now = Date.now();
+      pruneExpired.run(now);
+      const result = insert.run(nonce, now, getPlivoNonceExpiresAt(options.ttlSeconds));
+      return result.changes > 0;
+    },
+    has: (nonce) => Boolean(select.get(nonce, Date.now())),
+    set: (nonce) => {
+      upsert.run(nonce, Date.now(), getPlivoNonceExpiresAt(options.ttlSeconds));
+    }
+  };
+};
+var createVoicePlivoPostgresClient = async (options) => {
+  if (options.sql) {
+    return options.sql;
+  }
+  if (!options.connectionString) {
+    throw new Error("createVoicePostgresPlivoWebhookNonceStore requires either options.sql or options.connectionString.");
+  }
+  const sql = new Bun.SQL(options.connectionString);
+  return {
+    unsafe: sql.unsafe.bind(sql)
+  };
+};
+var resolvePlivoNonceQualifiedTableName = (options) => {
+  const schema = normalizePlivoStoreIdentifierSegment(options.schemaName ?? "public");
+  const table = resolvePlivoNonceTableName({
+    fallback: "plivo_webhook_nonces",
+    tableName: options.tableName,
+    tablePrefix: options.tablePrefix
+  });
+  return `${quotePlivoStoreIdentifier(schema)}.${quotePlivoStoreIdentifier(table)}`;
+};
+var createVoicePostgresPlivoWebhookNonceStore = (options = {}) => {
+  const qualifiedTableName = resolvePlivoNonceQualifiedTableName(options);
+  const schemaMatch = qualifiedTableName.match(/^"([^"]+)"\./);
+  const client = createVoicePlivoPostgresClient(options);
+  const initialized = (async () => {
+    const sql = await client;
+    if (schemaMatch?.[1]) {
+      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS ${quotePlivoStoreIdentifier(schemaMatch[1])}`);
+    }
+    await sql.unsafe(`CREATE TABLE IF NOT EXISTS ${qualifiedTableName} (
+				nonce TEXT PRIMARY KEY,
+				created_at BIGINT NOT NULL,
+				expires_at BIGINT
+			)`);
+  })();
+  const pruneExpired = async () => {
+    await initialized;
+    const sql = await client;
+    await sql.unsafe(`DELETE FROM ${qualifiedTableName} WHERE expires_at IS NOT NULL AND expires_at <= $1`, [Date.now()]);
+  };
+  return {
+    claim: async (nonce) => {
+      await pruneExpired();
+      const sql = await client;
+      const rows = await sql.unsafe(`INSERT INTO ${qualifiedTableName} (nonce, created_at, expires_at)
+				 VALUES ($1, $2, $3)
+				 ON CONFLICT (nonce) DO NOTHING
+				 RETURNING nonce`, [nonce, Date.now(), getPlivoNonceExpiresAt(options.ttlSeconds)]);
+      return rows.length > 0;
+    },
+    has: async (nonce) => {
+      await initialized;
+      const sql = await client;
+      const rows = await sql.unsafe(`SELECT nonce FROM ${qualifiedTableName}
+				 WHERE nonce = $1 AND (expires_at IS NULL OR expires_at > $2)
+				 LIMIT 1`, [nonce, Date.now()]);
+      return rows.length > 0;
+    },
+    set: async (nonce) => {
+      await initialized;
+      const sql = await client;
+      await sql.unsafe(`INSERT INTO ${qualifiedTableName} (nonce, created_at, expires_at)
+				 VALUES ($1, $2, $3)
+				 ON CONFLICT (nonce) DO UPDATE SET expires_at = EXCLUDED.expires_at`, [nonce, Date.now(), getPlivoNonceExpiresAt(options.ttlSeconds)]);
+    }
+  };
+};
+var getPlivoRedisNonceKey = (keyPrefix, nonce) => `${keyPrefix}:${nonce}`;
+var createVoiceRedisPlivoWebhookNonceStore = (options = {}) => {
+  const client = options.client ?? new Bun.RedisClient(options.url);
+  const keyPrefix = options.keyPrefix?.trim() || "voice:plivo-webhook-nonce";
+  const ttlSeconds = options.ttlSeconds;
+  const setNonce = async (nonce, nx) => {
+    const key = getPlivoRedisNonceKey(keyPrefix, nonce);
+    if (typeof ttlSeconds === "number" && ttlSeconds > 0) {
+      return client.set(key, "1", "EX", String(Math.ceil(ttlSeconds)), ...nx ? ["NX"] : []);
+    }
+    return client.set(key, "1", ...nx ? ["NX"] : []);
+  };
+  return {
+    claim: async (nonce) => await setNonce(nonce, true) === "OK",
+    has: async (nonce) => Boolean(await client.exists(getPlivoRedisNonceKey(keyPrefix, nonce))),
+    set: async (nonce) => {
+      await setNonce(nonce, false);
+    }
+  };
+};
 var createVoicePlivoWebhookVerifier = (options) => async (input) => {
   const verificationUrl = options.verificationUrl;
   const verification = await verifyVoicePlivoWebhookSignature({
@@ -19150,7 +19287,16 @@ var createVoicePlivoWebhookVerifier = (options) => async (input) => {
     return verification;
   }
   const nonce = input.headers.get("x-plivo-signature-v3-nonce");
-  if (!nonce || await nonceStore.has(nonce)) {
+  if (!nonce) {
+    return { ok: false, reason: "invalid-signature" };
+  }
+  if (nonceStore.claim) {
+    if (!await nonceStore.claim(nonce)) {
+      return { ok: false, reason: "invalid-signature" };
+    }
+    return verification;
+  }
+  if (await nonceStore.has(nonce)) {
     return { ok: false, reason: "invalid-signature" };
   }
   await nonceStore.set(nonce);
@@ -19403,6 +19549,7 @@ var createPlivoVoiceRoutes = (options = {}) => {
 
 // src/telephony/telnyx.ts
 import { Buffer as Buffer6 } from "buffer";
+import { Database as Database2 } from "bun:sqlite";
 import { Elysia as Elysia31 } from "elysia";
 var escapeXml4 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var escapeHtml30 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
@@ -19575,6 +19722,198 @@ var verifyVoiceTelnyxWebhookSignature = async (input) => {
     return { ok: false, reason: "invalid-signature" };
   }
 };
+var createMemoryVoiceTelnyxWebhookEventStore = () => {
+  const eventIds = new Set;
+  return {
+    claim: (eventId) => {
+      if (eventIds.has(eventId)) {
+        return false;
+      }
+      eventIds.add(eventId);
+      return true;
+    },
+    has: (eventId) => eventIds.has(eventId),
+    set: (eventId) => {
+      eventIds.add(eventId);
+    }
+  };
+};
+var normalizeTelnyxStoreIdentifierSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
+var quoteTelnyxStoreIdentifier = (value) => `"${value.replace(/"/g, '""')}"`;
+var resolveTelnyxEventTableName = (input) => {
+  if (input.tableName) {
+    return normalizeTelnyxStoreIdentifierSegment(input.tableName);
+  }
+  return `${normalizeTelnyxStoreIdentifierSegment(input.tablePrefix ?? "voice")}_${normalizeTelnyxStoreIdentifierSegment(input.fallback)}`;
+};
+var getTelnyxEventExpiresAt = (ttlSeconds) => typeof ttlSeconds === "number" && ttlSeconds > 0 ? Date.now() + Math.ceil(ttlSeconds * 1000) : null;
+var createVoiceSQLiteTelnyxWebhookEventStore = (options) => {
+  const database = options.database ?? new Database2(options.path ?? ":memory:", {
+    create: true
+  });
+  const tableName = resolveTelnyxEventTableName({
+    fallback: "telnyx_webhook_events",
+    tableName: options.tableName,
+    tablePrefix: options.tablePrefix
+  });
+  database.exec(`CREATE TABLE IF NOT EXISTS "${tableName}" (
+			event_id TEXT PRIMARY KEY,
+			created_at INTEGER NOT NULL,
+			expires_at INTEGER
+		)`);
+  const pruneExpired = database.query(`DELETE FROM "${tableName}" WHERE expires_at IS NOT NULL AND expires_at <= ?1`);
+  const select = database.query(`SELECT event_id FROM "${tableName}" WHERE event_id = ?1 AND (expires_at IS NULL OR expires_at > ?2) LIMIT 1`);
+  const insert = database.query(`INSERT OR IGNORE INTO "${tableName}" (event_id, created_at, expires_at) VALUES (?1, ?2, ?3)`);
+  const upsert = database.query(`INSERT INTO "${tableName}" (event_id, created_at, expires_at) VALUES (?1, ?2, ?3)
+		 ON CONFLICT(event_id) DO UPDATE SET expires_at = excluded.expires_at`);
+  return {
+    claim: (eventId) => {
+      const now = Date.now();
+      pruneExpired.run(now);
+      const result = insert.run(eventId, now, getTelnyxEventExpiresAt(options.ttlSeconds));
+      return result.changes > 0;
+    },
+    has: (eventId) => Boolean(select.get(eventId, Date.now())),
+    set: (eventId) => {
+      upsert.run(eventId, Date.now(), getTelnyxEventExpiresAt(options.ttlSeconds));
+    }
+  };
+};
+var createVoiceTelnyxPostgresClient = async (options) => {
+  if (options.sql) {
+    return options.sql;
+  }
+  if (!options.connectionString) {
+    throw new Error("createVoicePostgresTelnyxWebhookEventStore requires either options.sql or options.connectionString.");
+  }
+  const sql = new Bun.SQL(options.connectionString);
+  return {
+    unsafe: sql.unsafe.bind(sql)
+  };
+};
+var resolveTelnyxEventQualifiedTableName = (options) => {
+  const schema = normalizeTelnyxStoreIdentifierSegment(options.schemaName ?? "public");
+  const table = resolveTelnyxEventTableName({
+    fallback: "telnyx_webhook_events",
+    tableName: options.tableName,
+    tablePrefix: options.tablePrefix
+  });
+  return `${quoteTelnyxStoreIdentifier(schema)}.${quoteTelnyxStoreIdentifier(table)}`;
+};
+var createVoicePostgresTelnyxWebhookEventStore = (options = {}) => {
+  const qualifiedTableName = resolveTelnyxEventQualifiedTableName(options);
+  const schemaMatch = qualifiedTableName.match(/^"([^"]+)"\./);
+  const client = createVoiceTelnyxPostgresClient(options);
+  const initialized = (async () => {
+    const sql = await client;
+    if (schemaMatch?.[1]) {
+      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS ${quoteTelnyxStoreIdentifier(schemaMatch[1])}`);
+    }
+    await sql.unsafe(`CREATE TABLE IF NOT EXISTS ${qualifiedTableName} (
+				event_id TEXT PRIMARY KEY,
+				created_at BIGINT NOT NULL,
+				expires_at BIGINT
+			)`);
+  })();
+  const pruneExpired = async () => {
+    await initialized;
+    const sql = await client;
+    await sql.unsafe(`DELETE FROM ${qualifiedTableName} WHERE expires_at IS NOT NULL AND expires_at <= $1`, [Date.now()]);
+  };
+  return {
+    claim: async (eventId) => {
+      await pruneExpired();
+      const sql = await client;
+      const rows = await sql.unsafe(`INSERT INTO ${qualifiedTableName} (event_id, created_at, expires_at)
+				 VALUES ($1, $2, $3)
+				 ON CONFLICT (event_id) DO NOTHING
+				 RETURNING event_id`, [eventId, Date.now(), getTelnyxEventExpiresAt(options.ttlSeconds)]);
+      return rows.length > 0;
+    },
+    has: async (eventId) => {
+      await initialized;
+      const sql = await client;
+      const rows = await sql.unsafe(`SELECT event_id FROM ${qualifiedTableName}
+				 WHERE event_id = $1 AND (expires_at IS NULL OR expires_at > $2)
+				 LIMIT 1`, [eventId, Date.now()]);
+      return rows.length > 0;
+    },
+    set: async (eventId) => {
+      await initialized;
+      const sql = await client;
+      await sql.unsafe(`INSERT INTO ${qualifiedTableName} (event_id, created_at, expires_at)
+				 VALUES ($1, $2, $3)
+				 ON CONFLICT (event_id) DO UPDATE SET expires_at = EXCLUDED.expires_at`, [eventId, Date.now(), getTelnyxEventExpiresAt(options.ttlSeconds)]);
+    }
+  };
+};
+var getTelnyxRedisEventKey = (keyPrefix, eventId) => `${keyPrefix}:${eventId}`;
+var createVoiceRedisTelnyxWebhookEventStore = (options = {}) => {
+  const client = options.client ?? new Bun.RedisClient(options.url);
+  const keyPrefix = options.keyPrefix?.trim() || "voice:telnyx-webhook-event";
+  const ttlSeconds = options.ttlSeconds;
+  const setEvent = async (eventId, nx) => {
+    const key = getTelnyxRedisEventKey(keyPrefix, eventId);
+    if (typeof ttlSeconds === "number" && ttlSeconds > 0) {
+      return client.set(key, "1", "EX", String(Math.ceil(ttlSeconds)), ...nx ? ["NX"] : []);
+    }
+    return client.set(key, "1", ...nx ? ["NX"] : []);
+  };
+  return {
+    claim: async (eventId) => await setEvent(eventId, true) === "OK",
+    has: async (eventId) => Boolean(await client.exists(getTelnyxRedisEventKey(keyPrefix, eventId))),
+    set: async (eventId) => {
+      await setEvent(eventId, false);
+    }
+  };
+};
+var readTelnyxWebhookEventId = (rawBody) => {
+  try {
+    const body = JSON.parse(rawBody);
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+      return;
+    }
+    const record = body;
+    const data = record.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const eventId2 = data.id;
+      if (typeof eventId2 === "string" && eventId2.trim()) {
+        return eventId2;
+      }
+    }
+    const eventId = record.id ?? record.event_id;
+    return typeof eventId === "string" && eventId.trim() ? eventId : undefined;
+  } catch {
+    return;
+  }
+};
+var createVoiceTelnyxWebhookVerifier = (options) => async (input) => {
+  const verification = await verifyVoiceTelnyxWebhookSignature({
+    body: input.rawBody,
+    headers: input.headers,
+    publicKey: options.publicKey,
+    toleranceSeconds: options.toleranceSeconds
+  });
+  if (!verification.ok) {
+    return verification;
+  }
+  const eventStore = options.eventStore;
+  if (!eventStore) {
+    return verification;
+  }
+  const eventId = readTelnyxWebhookEventId(input.rawBody);
+  if (!eventId) {
+    return { ok: false, reason: "invalid-signature" };
+  }
+  if (eventStore.claim) {
+    return await eventStore.claim(eventId) ? verification : { ok: false, reason: "invalid-signature" };
+  }
+  if (await eventStore.has(eventId)) {
+    return { ok: false, reason: "invalid-signature" };
+  }
+  await eventStore.set(eventId);
+  return verification;
+};
 var buildTelnyxVoiceSetupStatus = async (options, input) => {
   const origin = resolveRequestOrigin3(input.request);
   const stream = await resolveTelnyxStreamUrl(options, input);
@@ -19708,11 +20047,10 @@ var createTelnyxVoiceRoutes = (options = {}) => {
   const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/telnyx/smoke";
   const bridges = new WeakMap;
   const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
-  const verify = options.webhook?.verify ?? (options.webhook?.publicKey ? (input) => verifyVoiceTelnyxWebhookSignature({
-    body: input.rawBody,
-    headers: input.headers,
-    publicKey: options.webhook?.publicKey,
-    toleranceSeconds: options.webhook?.toleranceSeconds
+  const verify = options.webhook?.verify ?? (options.webhook?.publicKey ? createVoiceTelnyxWebhookVerifier({
+    eventStore: options.webhook.eventStore,
+    publicKey: options.webhook.publicKey,
+    toleranceSeconds: options.webhook.toleranceSeconds
   }) : undefined);
   const app = new Elysia31({
     name: options.name ?? "absolutejs-voice-telnyx"
@@ -23844,7 +24182,7 @@ var createVoiceOpsRecoveryRoutes = (options = {}) => {
 
 // src/observabilityExport.ts
 import { Elysia as Elysia41 } from "elysia";
-import { Database } from "bun:sqlite";
+import { Database as Database3 } from "bun:sqlite";
 import { createHash } from "crypto";
 import { mkdir as mkdir4, readFile as readFile2, stat, unlink } from "fs/promises";
 import { join as join3 } from "path";
@@ -25074,7 +25412,7 @@ var loadVoiceObservabilityExportReplaySource = async (source) => {
     if (!source.database && !source.path) {
       throw new Error("SQLite observability export replay requires source.database or source.path.");
     }
-    const database = source.database ?? new Database(source.path, { create: false });
+    const database = source.database ?? new Database3(source.path, { create: false });
     const table2 = quoteObservabilityIdentifier(normalizeObservabilityIdentifier(source.tableName));
     const row2 = database.query(`SELECT manifest_json, artifact_index_json, payload_json FROM ${table2} WHERE run_id = $runId`).get({ $runId: source.runId });
     if (!row2) {
@@ -25151,7 +25489,7 @@ var deliverObservabilityExportToSQLite = async (input) => {
   if (!input.destination.database && !input.destination.path) {
     throw new Error("SQLite observability export delivery requires destination.database or destination.path.");
   }
-  const database = input.destination.database ?? new Database(input.destination.path, { create: true });
+  const database = input.destination.database ?? new Database3(input.destination.path, { create: true });
   const table = quoteObservabilityIdentifier(normalizeObservabilityIdentifier(input.destination.tableName));
   const record = buildObservabilityExportDatabaseRecord(input);
   database.exec(`CREATE TABLE IF NOT EXISTS ${table} (
@@ -29261,7 +29599,7 @@ var createVoiceTraceDeliveryRoutes = (options) => {
   return routes;
 };
 // src/sqliteStore.ts
-import { Database as Database2 } from "bun:sqlite";
+import { Database as Database4 } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
 var resolveTableName = (input) => {
   if (input.options.tableName) {
@@ -29272,7 +29610,7 @@ var resolveTableName = (input) => {
   return `${prefix}_${fallback}`;
 };
 var openVoiceSQLiteDatabase = (path) => {
-  const database = new Database2(path, {
+  const database = new Database4(path, {
     create: true
   });
   database.exec("PRAGMA journal_mode = WAL;");
@@ -31634,6 +31972,7 @@ export {
   createVoiceToolContractJSONHandler,
   createVoiceToolContractHTMLHandler,
   createVoiceToolContract,
+  createVoiceTelnyxWebhookVerifier,
   createVoiceTelnyxCampaignDialer,
   createVoiceTelephonyWebhookRoutes,
   createVoiceTelephonyWebhookHandler,
@@ -31657,11 +31996,13 @@ export {
   createVoiceSTTProviderRouter,
   createVoiceSQLiteTraceSinkDeliveryStore,
   createVoiceSQLiteTraceEventStore,
+  createVoiceSQLiteTelnyxWebhookEventStore,
   createVoiceSQLiteTelephonyWebhookIdempotencyStore,
   createVoiceSQLiteTaskStore,
   createVoiceSQLiteSessionStore,
   createVoiceSQLiteRuntimeStorage,
   createVoiceSQLiteReviewStore,
+  createVoiceSQLitePlivoWebhookNonceStore,
   createVoiceSQLiteIntegrationEventStore,
   createVoiceSQLiteExternalObjectMapStore,
   createVoiceSQLiteDeliverySink,
@@ -31673,8 +32014,10 @@ export {
   createVoiceRoutingDecisionSummary,
   createVoiceReviewSavedEvent,
   createVoiceResilienceRoutes,
+  createVoiceRedisTelnyxWebhookEventStore,
   createVoiceRedisTelephonyWebhookIdempotencyStore,
   createVoiceRedisTaskLeaseCoordinator,
+  createVoiceRedisPlivoWebhookNonceStore,
   createVoiceRedisIdempotencyStore,
   createVoiceReconnectContractRoutes,
   createVoiceReadinessProfile,
@@ -31695,11 +32038,13 @@ export {
   createVoiceProductionReadinessRoutes,
   createVoicePostgresTraceSinkDeliveryStore,
   createVoicePostgresTraceEventStore,
+  createVoicePostgresTelnyxWebhookEventStore,
   createVoicePostgresTelephonyWebhookIdempotencyStore,
   createVoicePostgresTaskStore,
   createVoicePostgresSessionStore,
   createVoicePostgresRuntimeStorage,
   createVoicePostgresReviewStore,
+  createVoicePostgresPlivoWebhookNonceStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
   createVoicePostgresDeliverySink,
@@ -31849,6 +32194,7 @@ export {
   createOpenAIVoiceTTS,
   createOpenAIVoiceAssistantModel,
   createOpenAIRealtimeAdapter,
+  createMemoryVoiceTelnyxWebhookEventStore,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,
   createMemoryVoicePlivoWebhookNonceStore,
   createJSONVoiceAssistantModel,

package/dist/telephony/plivo.d.ts

@@ -1,7 +1,10 @@
+import { Database } from 'bun:sqlite';
+import type { RedisClient } from 'bun';
 import { Elysia } from 'elysia';
 import { type VoiceTelephonyContractReport, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeCheck, type VoiceTelephonySmokeReport } from './contract';
 import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions, type VoiceTelephonyWebhookVerificationResult } from '../telephonyOutcome';
 import type { VoiceServerMessage, VoiceSessionRecord } from '../types';
+import type { VoicePostgresClient } from '../postgresStore';
 import { type TwilioMediaStreamBridgeOptions } from './twilio';
 export type PlivoInboundMessage = {
     event: 'start';
@@ -132,9 +135,32 @@ export type PlivoVoiceSmokeOptions = {
     title?: string;
 };
 export type VoicePlivoWebhookNonceStore = {
+    claim?: (nonce: string) => Promise<boolean> | boolean;
     has: (nonce: string) => Promise<boolean> | boolean;
     set: (nonce: string) => Promise<void> | void;
 };
+export type VoicePlivoWebhookNonceStoreOptions = {
+    ttlSeconds?: number;
+};
+export type VoiceSQLitePlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    database?: Database;
+    path?: string;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoicePostgresPlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    connectionString?: string;
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoiceRedisPlivoWebhookNonceClient = Pick<RedisClient, 'exists' | 'set'>;
+export type VoiceRedisPlivoWebhookNonceStoreOptions = VoicePlivoWebhookNonceStoreOptions & {
+    client?: VoiceRedisPlivoWebhookNonceClient;
+    keyPrefix?: string;
+    url?: string;
+};
 export type VoicePlivoWebhookVerifierOptions = {
     authToken?: string;
     nonceStore?: VoicePlivoWebhookNonceStore;
@@ -186,6 +212,9 @@ export declare const verifyVoicePlivoWebhookSignature: (input: {
     url: string;
 }) => Promise<VoiceTelephonyWebhookVerificationResult>;
 export declare const createMemoryVoicePlivoWebhookNonceStore: () => VoicePlivoWebhookNonceStore;
+export declare const createVoiceSQLitePlivoWebhookNonceStore: (options: VoiceSQLitePlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
+export declare const createVoicePostgresPlivoWebhookNonceStore: (options?: VoicePostgresPlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
+export declare const createVoiceRedisPlivoWebhookNonceStore: (options?: VoiceRedisPlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
 export declare const createVoicePlivoWebhookVerifier: (options: VoicePlivoWebhookVerifierOptions) => (input: {
     body: unknown;
     headers: Headers;

package/dist/telephony/telnyx.d.ts

@@ -1,8 +1,11 @@
+import { Database } from 'bun:sqlite';
+import type { RedisClient } from 'bun';
 import { Elysia } from 'elysia';
 import { type VoiceTelephonyContractReport, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeCheck, type VoiceTelephonySmokeReport } from './contract';
 import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions, type VoiceTelephonyWebhookVerificationResult } from '../telephonyOutcome';
 import type { VoiceServerMessage, VoiceSessionRecord } from '../types';
 import { type TwilioMediaStreamBridgeOptions } from './twilio';
+import type { VoicePostgresClient } from '../postgresStore';
 export type TelnyxMediaPayload = {
     chunk?: string;
     payload: string;
@@ -151,12 +154,45 @@ export type TelnyxVoiceRoutesOptions<TContext = unknown, TSession extends VoiceS
         }) => Promise<string> | string);
     };
     webhook?: Omit<VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>, 'context' | 'path' | 'policy' | 'provider'> & {
+        eventStore?: VoiceTelnyxWebhookEventStore;
         path?: string;
         policy?: VoiceTelephonyOutcomePolicy;
         publicKey?: string;
         toleranceSeconds?: number;
     };
 };
+export type VoiceTelnyxWebhookEventStore = {
+    claim?: (eventId: string) => Promise<boolean> | boolean;
+    has: (eventId: string) => Promise<boolean> | boolean;
+    set: (eventId: string) => Promise<void> | void;
+};
+export type VoiceTelnyxWebhookEventStoreOptions = {
+    ttlSeconds?: number;
+};
+export type VoiceSQLiteTelnyxWebhookEventStoreOptions = VoiceTelnyxWebhookEventStoreOptions & {
+    database?: Database;
+    path?: string;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoicePostgresTelnyxWebhookEventStoreOptions = VoiceTelnyxWebhookEventStoreOptions & {
+    connectionString?: string;
+    schemaName?: string;
+    sql?: VoicePostgresClient;
+    tableName?: string;
+    tablePrefix?: string;
+};
+export type VoiceRedisTelnyxWebhookEventClient = Pick<RedisClient, 'exists' | 'set'>;
+export type VoiceRedisTelnyxWebhookEventStoreOptions = VoiceTelnyxWebhookEventStoreOptions & {
+    client?: VoiceRedisTelnyxWebhookEventClient;
+    keyPrefix?: string;
+    url?: string;
+};
+export type VoiceTelnyxWebhookVerifierOptions = {
+    eventStore?: VoiceTelnyxWebhookEventStore;
+    publicKey?: string;
+    toleranceSeconds?: number;
+};
 export declare const createTelnyxVoiceResponse: (options: TelnyxVoiceResponseOptions) => string;
 export declare const createTelnyxMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: TelnyxMediaStreamSocket, options: TelnyxMediaStreamBridgeOptions<TContext, TSession, TResult>) => TelnyxMediaStreamBridge;
 export declare const verifyVoiceTelnyxWebhookSignature: (input: {
@@ -165,6 +201,14 @@ export declare const verifyVoiceTelnyxWebhookSignature: (input: {
     publicKey?: string;
     toleranceSeconds?: number;
 }) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const createMemoryVoiceTelnyxWebhookEventStore: () => VoiceTelnyxWebhookEventStore;
+export declare const createVoiceSQLiteTelnyxWebhookEventStore: (options: VoiceSQLiteTelnyxWebhookEventStoreOptions) => VoiceTelnyxWebhookEventStore;
+export declare const createVoicePostgresTelnyxWebhookEventStore: (options?: VoicePostgresTelnyxWebhookEventStoreOptions) => VoiceTelnyxWebhookEventStore;
+export declare const createVoiceRedisTelnyxWebhookEventStore: (options?: VoiceRedisTelnyxWebhookEventStoreOptions) => VoiceTelnyxWebhookEventStore;
+export declare const createVoiceTelnyxWebhookVerifier: (options: VoiceTelnyxWebhookVerifierOptions) => (input: {
+    rawBody: string;
+    headers: Headers;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
 export declare const createTelnyxVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: TelnyxVoiceRoutesOptions<TContext, TSession, TResult>) => Elysia<"", {
     decorator: {};
     store: {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.270",
+	"version": "0.0.22-beta.272",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",