@absolutejs/voice 0.0.22-beta.81 → 0.0.22-beta.83

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export { applyVoiceTelephonyOutcome, createMemoryVoiceTelephonyWebhookIdempotenc
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, resolveVoiceProviderRoutingPolicyPreset, createVoiceProviderRouter } from './modelAdapters';
+export { createOpenAIVoiceTTS } from './openaiTTS';
 export { createVoiceProviderHealthHTMLHandler, createVoiceProviderHealthJSONHandler, createVoiceProviderHealthRoutes, renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth } from './providerHealth';
 export { createVoiceProviderCapabilityHTMLHandler, createVoiceProviderCapabilityJSONHandler, createVoiceProviderCapabilityRoutes, renderVoiceProviderCapabilityHTML, summarizeVoiceProviderCapabilities } from './providerCapabilities';
 export { buildVoiceOpsConsoleReport, createVoiceOpsConsoleRoutes, renderVoiceOpsConsoleHTML } from './opsConsoleRoutes';
@@ -53,6 +54,7 @@ export type { VoiceEvalBaselineComparison, VoiceEvalBaselineComparisonOptions, V
 export type { VoiceWorkflowContract, VoiceWorkflowContractDefinition, VoiceWorkflowContractField, VoiceWorkflowContractFieldMatch, VoiceWorkflowContractPresetName, VoiceWorkflowContractPresetOptions, VoiceWorkflowContractTracePayload, VoiceWorkflowContractValidation, VoiceWorkflowContractValidationIssue, VoiceWorkflowOutcome } from './workflowContract';
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn } from './sessionReplay';
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterPolicyPreset, VoiceProviderRouterPolicyWeights, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceProviderRouterStrategy, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
+export type { OpenAIVoiceTTSOptions, OpenAIVoiceTTSVoice } from './openaiTTS';
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
 export type { VoiceProviderCapabilityDefinition, VoiceProviderCapabilityHandlerOptions, VoiceProviderCapabilityHTMLHandlerOptions, VoiceProviderCapabilityKind, VoiceProviderCapabilityOptions, VoiceProviderCapabilityReport, VoiceProviderCapabilityRoutesOptions, VoiceProviderCapabilitySummary } from './providerCapabilities';
 export type { VoiceTurnQualityHTMLHandlerOptions, VoiceTurnQualityItem, VoiceTurnQualityOptions, VoiceTurnQualityReport, VoiceTurnQualityRoutesOptions, VoiceTurnQualityStatus } from './turnQuality';
@@ -82,13 +84,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 { createTelnyxVoiceResponse, createTelnyxVoiceRoutes, verifyVoiceTelnyxWebhookSignature } from './telephony/telnyx';
-export { createPlivoVoiceResponse, createPlivoVoiceRoutes, signVoicePlivoWebhook, verifyVoicePlivoWebhookSignature } from './telephony/plivo';
+export { createTelnyxMediaStreamBridge, createTelnyxVoiceResponse, createTelnyxVoiceRoutes, verifyVoiceTelnyxWebhookSignature } from './telephony/telnyx';
+export { createPlivoMediaStreamBridge, createPlivoVoiceResponse, createPlivoVoiceRoutes, 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 { TelnyxVoiceResponseOptions, TelnyxVoiceRoutesOptions, TelnyxVoiceSetupOptions, TelnyxVoiceSetupStatus, TelnyxVoiceSmokeCheck, TelnyxVoiceSmokeOptions, TelnyxVoiceSmokeReport } from './telephony/telnyx';
-export type { PlivoVoiceResponseOptions, PlivoVoiceRoutesOptions, PlivoVoiceSetupOptions, PlivoVoiceSetupStatus, PlivoVoiceSmokeCheck, PlivoVoiceSmokeOptions, PlivoVoiceSmokeReport } from './telephony/plivo';
+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 } 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

@@ -12424,6 +12424,136 @@ var createGeminiVoiceAssistantModel = (options) => {
     }
   };
 };
+// src/openaiTTS.ts
+var OPENAI_PCM24_FORMAT = {
+  channels: 1,
+  container: "raw",
+  encoding: "pcm_s16le",
+  sampleRateHz: 24000
+};
+var resolveInstructions = async (instructions, input) => {
+  if (typeof instructions === "function") {
+    return instructions(input);
+  }
+  return instructions;
+};
+var createTTSHTTPError = (response) => new Error(`OpenAI voice TTS failed: HTTP ${response.status}`);
+var emit = async (listeners, event, payload) => {
+  for (const handler of listeners[event]) {
+    await Promise.resolve(handler(payload));
+  }
+};
+var createOpenAIVoiceTTS = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+  const model = options.model ?? "gpt-4o-mini-tts";
+  const voice2 = options.voice ?? "coral";
+  return {
+    kind: "tts",
+    open: (openOptions) => {
+      const listeners = {
+        audio: new Set,
+        close: new Set,
+        error: new Set
+      };
+      const abortController = new AbortController;
+      const signalAbort = () => abortController.abort();
+      openOptions.signal?.addEventListener("abort", signalAbort, { once: true });
+      let closed = false;
+      return {
+        close: async (reason) => {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          abortController.abort();
+          openOptions.signal?.removeEventListener("abort", signalAbort);
+          await emit(listeners, "close", {
+            reason,
+            type: "close"
+          });
+        },
+        on: (event, handler) => {
+          listeners[event].add(handler);
+          return () => {
+            listeners[event].delete(handler);
+          };
+        },
+        send: async (text) => {
+          if (closed || !text.trim()) {
+            return;
+          }
+          try {
+            const instructions = await resolveInstructions(options.instructions, {
+              lexicon: openOptions.lexicon,
+              sessionId: openOptions.sessionId,
+              text
+            });
+            const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/audio/speech`, {
+              body: JSON.stringify({
+                input: text,
+                instructions,
+                model,
+                response_format: "pcm",
+                speed: options.speed,
+                voice: voice2
+              }),
+              headers: {
+                authorization: `Bearer ${options.apiKey}`,
+                "content-type": "application/json"
+              },
+              method: "POST",
+              signal: abortController.signal
+            });
+            if (!response.ok) {
+              throw createTTSHTTPError(response);
+            }
+            if (!response.body) {
+              const chunk = new Uint8Array(await response.arrayBuffer());
+              if (!closed && chunk.byteLength > 0) {
+                await emit(listeners, "audio", {
+                  chunk,
+                  format: OPENAI_PCM24_FORMAT,
+                  receivedAt: Date.now(),
+                  type: "audio"
+                });
+              }
+              return;
+            }
+            const reader = response.body.getReader();
+            try {
+              while (!closed) {
+                const { done, value } = await reader.read();
+                if (done) {
+                  break;
+                }
+                if (value.byteLength > 0) {
+                  await emit(listeners, "audio", {
+                    chunk: new Uint8Array(value),
+                    format: OPENAI_PCM24_FORMAT,
+                    receivedAt: Date.now(),
+                    type: "audio"
+                  });
+                }
+              }
+            } finally {
+              reader.releaseLock();
+            }
+          } catch (error) {
+            if (closed || abortController.signal.aborted) {
+              return;
+            }
+            await emit(listeners, "error", {
+              error: error instanceof Error ? error : new Error(String(error)),
+              recoverable: true,
+              type: "error"
+            });
+          }
+        }
+      };
+    }
+  };
+};
 // src/providerAdapters.ts
 class VoiceIOProviderTimeoutError extends Error {
   provider;
@@ -12611,11 +12741,11 @@ var createResolver = (options) => {
       selectedProvider: preferred
     };
   };
-  const emit = async (event, input) => {
+  const emit2 = async (event, input) => {
     await options.onProviderEvent?.(event, input);
   };
   return {
-    emit,
+    emit: emit2,
     getSuppressionRemainingMs,
     providerIds,
     recordError,
@@ -16028,6 +16158,114 @@ var createTelnyxVoiceResponse = (options) => {
   ].filter((value) => Boolean(value)).join(" ");
   return `<?xml version="1.0" encoding="UTF-8"?><Response><Start><Stream ${attributes} /></Start></Response>`;
 };
+var parseTelnyxMessage = (raw) => {
+  if (typeof raw !== "string") {
+    return raw;
+  }
+  return JSON.parse(raw);
+};
+var normalizeTelnyxTrack = (track) => track === "outbound" || track === "outbound_track" ? "outbound" : "inbound";
+var telnyxToTwilioMessage = (message) => {
+  switch (message.event) {
+    case "connected":
+      return {
+        event: "connected",
+        version: message.version
+      };
+    case "start": {
+      const streamSid = message.stream_id ?? "telnyx-stream";
+      return {
+        event: "start",
+        start: {
+          callSid: message.start?.call_control_id ?? message.start?.call_session_id ?? message.start?.call_leg_id,
+          customParameters: {
+            ...message.start?.custom_parameters ?? {},
+            ...message.start?.call_session_id ? { sessionId: message.start.call_session_id } : {}
+          },
+          mediaFormat: {
+            channels: message.start?.media_format?.channels,
+            encoding: message.start?.media_format?.encoding,
+            sampleRate: message.start?.media_format?.sample_rate
+          },
+          streamSid
+        },
+        streamSid
+      };
+    }
+    case "media": {
+      const streamSid = message.stream_id ?? "telnyx-stream";
+      return {
+        event: "media",
+        media: {
+          chunk: message.media.chunk,
+          payload: message.media.payload,
+          timestamp: message.media.timestamp,
+          track: normalizeTelnyxTrack(message.media.track)
+        },
+        streamSid
+      };
+    }
+    case "mark":
+      return {
+        event: "mark",
+        mark: message.mark,
+        streamSid: message.stream_id ?? "telnyx-stream"
+      };
+    case "stop":
+      return {
+        event: "stop",
+        stop: {
+          callSid: message.stop?.call_control_id
+        },
+        streamSid: message.stream_id ?? "telnyx-stream"
+      };
+    case "dtmf":
+    case "error":
+      return null;
+  }
+};
+var createTelnyxTwilioSocketAdapter = (socket) => ({
+  close: (code, reason) => socket.close(code, reason),
+  send: async (data) => {
+    const message = JSON.parse(data);
+    const telnyxMessage = message.event === "media" ? {
+      event: "media",
+      media: {
+        payload: message.media.payload
+      }
+    } : message.event === "clear" ? {
+      event: "clear"
+    } : message.event === "mark" ? {
+      event: "mark",
+      mark: message.mark
+    } : null;
+    if (telnyxMessage) {
+      await Promise.resolve(socket.send(JSON.stringify(telnyxMessage)));
+    }
+  }
+});
+var createTelnyxMediaStreamBridge = (socket, options) => {
+  const bridge = createTwilioMediaStreamBridge(createTelnyxTwilioSocketAdapter(socket), {
+    ...options,
+    onVoiceMessage: options.onVoiceMessage ? (input) => options.onVoiceMessage?.({
+      callControlId: input.callSid,
+      message: input.message,
+      sessionId: input.sessionId,
+      streamId: input.streamSid
+    }) : undefined
+  });
+  return {
+    close: bridge.close,
+    getSessionId: bridge.getSessionId,
+    getStreamId: bridge.getStreamSid,
+    handleMessage: async (raw) => {
+      const message = telnyxToTwilioMessage(parseTelnyxMessage(raw));
+      if (message) {
+        await bridge.handleMessage(message);
+      }
+    }
+  };
+};
 var decodeBase64 = (value) => Uint8Array.from(Buffer4.from(value, "base64"));
 var verifyVoiceTelnyxWebhookSignature = async (input) => {
   if (!input.publicKey) {
@@ -16182,6 +16420,7 @@ var createTelnyxVoiceRoutes = (options = {}) => {
   const webhookPath = options.webhook?.path ?? "/api/voice/telnyx/webhook";
   const setupPath = options.setup?.path === false ? false : options.setup?.path ?? "/api/voice/telnyx/setup";
   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,
@@ -16219,6 +16458,31 @@ var createTelnyxVoiceRoutes = (options = {}) => {
         "content-type": "text/xml; charset=utf-8"
       }
     });
+  }).ws(streamPath, {
+    close: async (ws, _code, reason) => {
+      const bridge = bridges.get(ws);
+      bridges.delete(ws);
+      await bridge?.close(reason);
+    },
+    message: async (ws, raw) => {
+      if (!options.bridge) {
+        ws.close(1011, "Telnyx media bridge is not configured.");
+        return;
+      }
+      let bridge = bridges.get(ws);
+      if (!bridge) {
+        bridge = createTelnyxMediaStreamBridge({
+          close: (code, reason) => {
+            ws.close(code, reason);
+          },
+          send: (data) => {
+            ws.send(data);
+          }
+        }, options.bridge);
+        bridges.set(ws, bridge);
+      }
+      await bridge.handleMessage(raw);
+    }
   }).use(createVoiceTelephonyWebhookRoutes({
     ...options.webhook ?? {},
     context: options.context,
@@ -16327,6 +16591,123 @@ var createPlivoVoiceResponse = (options) => {
   const openTag = attributes ? `<Stream ${attributes}>` : "<Stream>";
   return `<?xml version="1.0" encoding="UTF-8"?><Response>${openTag}${escapeXml4(options.streamUrl)}</Stream></Response>`;
 };
+var parsePlivoMessage = (raw) => {
+  if (typeof raw !== "string") {
+    return raw;
+  }
+  return JSON.parse(raw);
+};
+var parsePlivoExtraHeaders = (headers) => {
+  if (!headers) {
+    return {};
+  }
+  return Object.fromEntries(headers.split(/[;,]/).map((header) => header.trim()).filter(Boolean).map((header) => {
+    const separator = header.indexOf("=");
+    if (separator === -1) {
+      return [header, ""];
+    }
+    return [
+      header.slice(0, separator).trim(),
+      header.slice(separator + 1).trim()
+    ];
+  }).filter((entry) => (entry[0] ?? "").length > 0));
+};
+var plivoToTwilioMessage = (message) => {
+  switch (message.event) {
+    case "start": {
+      const streamSid = message.streamId ?? message.start?.streamId ?? "plivo-stream";
+      const callSid = message.start?.callId ?? message.start?.callUuid;
+      const customParameters = parsePlivoExtraHeaders(message.start?.extra_headers);
+      return {
+        event: "start",
+        start: {
+          callSid,
+          customParameters,
+          mediaFormat: message.start?.mediaFormat,
+          streamSid
+        },
+        streamSid
+      };
+    }
+    case "media": {
+      const streamSid = message.streamId ?? "plivo-stream";
+      return {
+        event: "media",
+        media: {
+          payload: message.media.payload,
+          timestamp: message.media.timestamp,
+          track: message.media.track ?? "inbound"
+        },
+        streamSid
+      };
+    }
+    case "playedStream":
+      return {
+        event: "mark",
+        mark: {
+          name: message.name
+        },
+        streamSid: message.streamId ?? "plivo-stream"
+      };
+    case "stop":
+      return {
+        event: "stop",
+        stop: {
+          callSid: message.stop?.callId ?? message.stop?.callUuid
+        },
+        streamSid: message.streamId ?? "plivo-stream"
+      };
+    case "clearedAudio":
+    case "dtmf":
+      return null;
+  }
+};
+var createPlivoTwilioSocketAdapter = (socket) => ({
+  close: (code, reason) => socket.close(code, reason),
+  send: async (data) => {
+    const message = JSON.parse(data);
+    const plivoMessage = message.event === "media" ? {
+      event: "playAudio",
+      media: {
+        contentType: "audio/x-mulaw",
+        payload: message.media.payload,
+        sampleRate: 8000
+      }
+    } : message.event === "clear" ? {
+      event: "clearAudio",
+      streamId: message.streamSid
+    } : message.event === "mark" ? {
+      event: "checkpoint",
+      name: message.mark.name,
+      streamId: message.streamSid
+    } : null;
+    if (plivoMessage) {
+      await Promise.resolve(socket.send(JSON.stringify(plivoMessage)));
+    }
+  }
+});
+var createPlivoMediaStreamBridge = (socket, options) => {
+  const bridge = createTwilioMediaStreamBridge(createPlivoTwilioSocketAdapter(socket), {
+    ...options,
+    onVoiceMessage: options.onVoiceMessage ? (input) => options.onVoiceMessage?.({
+      callId: input.callSid,
+      message: input.message,
+      sessionId: input.sessionId,
+      streamId: input.streamSid
+    }) : undefined
+  });
+  return {
+    close: bridge.close,
+    getSessionId: bridge.getSessionId,
+    getStreamId: bridge.getStreamSid,
+    handleMessage: async (raw) => {
+      const message = plivoToTwilioMessage(parsePlivoMessage(raw));
+      if (message) {
+        await bridge.handleMessage(message);
+      }
+    }
+  };
+};
 var toBase642 = (bytes) => Buffer5.from(new Uint8Array(bytes)).toString("base64");
 var timingSafeEqual3 = (left, right) => {
   const encoder = new TextEncoder;
@@ -16507,6 +16888,7 @@ var createPlivoVoiceRoutes = (options = {}) => {
   const webhookPath = options.webhook?.path ?? "/api/voice/plivo/webhook";
   const setupPath = options.setup?.path === false ? false : options.setup?.path ?? "/api/voice/plivo/setup";
   const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/plivo/smoke";
+  const bridges = new WeakMap;
   const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
   const verificationUrl = options.webhook?.verificationUrl;
   const verify = options.webhook?.verify ?? (options.webhook?.authToken ? (input) => verifyVoicePlivoWebhookSignature({
@@ -16548,6 +16930,31 @@ var createPlivoVoiceRoutes = (options = {}) => {
         "content-type": "text/xml; charset=utf-8"
       }
     });
+  }).ws(streamPath, {
+    close: async (ws, _code, reason) => {
+      const bridge = bridges.get(ws);
+      bridges.delete(ws);
+      await bridge?.close(reason);
+    },
+    message: async (ws, raw) => {
+      if (!options.bridge) {
+        ws.close(1011, "Plivo media bridge is not configured.");
+        return;
+      }
+      let bridge = bridges.get(ws);
+      if (!bridge) {
+        bridge = createPlivoMediaStreamBridge({
+          close: (code, reason) => {
+            ws.close(code, reason);
+          },
+          send: (data) => {
+            ws.send(data);
+          }
+        }, options.bridge);
+        bridges.set(ws, bridge);
+      }
+      await bridge.handleMessage(raw);
+    }
   }).use(createVoiceTelephonyWebhookRoutes({
     ...options.webhook ?? {},
     context: options.context,
@@ -17013,6 +17420,7 @@ export {
   createTwilioMediaStreamBridge,
   createTelnyxVoiceRoutes,
   createTelnyxVoiceResponse,
+  createTelnyxMediaStreamBridge,
   createStoredVoiceOpsTask,
   createStoredVoiceIntegrationEvent,
   createStoredVoiceExternalObjectMap,
@@ -17020,7 +17428,9 @@ export {
   createRiskyTurnCorrectionHandler,
   createPlivoVoiceRoutes,
   createPlivoVoiceResponse,
+  createPlivoMediaStreamBridge,
   createPhraseHintCorrectionHandler,
+  createOpenAIVoiceTTS,
   createOpenAIVoiceAssistantModel,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,
   createJSONVoiceAssistantModel,

package/dist/openaiTTS.d.ts

@@ -0,0 +1,18 @@
+import type { TTSAdapter, TTSAdapterOpenOptions, VoiceLexiconEntry } from './types';
+export type OpenAIVoiceTTSVoice = 'alloy' | 'ash' | 'ballad' | 'cedar' | 'coral' | 'echo' | 'fable' | 'marin' | 'nova' | 'onyx' | 'sage' | 'shimmer' | 'verse' | (string & {});
+export type OpenAIVoiceTTSOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    instructions?: string | ((input: {
+        lexicon?: VoiceLexiconEntry[];
+        sessionId: string;
+        text: string;
+    }) => Promise<string | undefined> | string | undefined);
+    model?: 'gpt-4o-mini-tts' | 'tts-1' | 'tts-1-hd' | (string & {});
+    speed?: number;
+    voice?: OpenAIVoiceTTSVoice | {
+        id: string;
+    };
+};
+export declare const createOpenAIVoiceTTS: (options: OpenAIVoiceTTSOptions) => TTSAdapter<TTSAdapterOpenOptions>;

package/dist/telephony/plivo.d.ts

@@ -1,7 +1,95 @@
 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 { VoiceSessionRecord } from '../types';
+import type { VoiceServerMessage, VoiceSessionRecord } from '../types';
+import { type TwilioMediaStreamBridgeOptions } from './twilio';
+export type PlivoInboundMessage = {
+    event: 'start';
+    sequenceNumber?: number;
+    start?: {
+        callId?: string;
+        callUuid?: string;
+        extra_headers?: string;
+        mediaFormat?: {
+            channels?: number;
+            encoding?: string;
+            sampleRate?: number;
+        };
+        streamId?: string;
+    };
+    streamId?: string;
+} | {
+    event: 'media';
+    media: {
+        payload: string;
+        timestamp?: string;
+        track?: 'inbound' | 'outbound';
+    };
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: 'dtmf';
+    dtmf?: {
+        digit?: string;
+        timestamp?: string;
+        track?: string;
+    };
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: 'playedStream';
+    name?: string;
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: 'clearedAudio';
+    sequenceNumber?: number;
+    streamId?: string;
+} | {
+    event: 'stop';
+    sequenceNumber?: number;
+    stop?: {
+        callId?: string;
+        callUuid?: string;
+    };
+    streamId?: string;
+};
+export type PlivoOutboundPlayAudioMessage = {
+    event: 'playAudio';
+    media: {
+        contentType: 'audio/x-mulaw';
+        payload: string;
+        sampleRate: 8000;
+    };
+};
+export type PlivoOutboundClearAudioMessage = {
+    event: 'clearAudio';
+    streamId?: string;
+};
+export type PlivoOutboundCheckpointMessage = {
+    event: 'checkpoint';
+    name: string;
+    streamId?: string;
+};
+export type PlivoOutboundMessage = PlivoOutboundPlayAudioMessage | PlivoOutboundClearAudioMessage | PlivoOutboundCheckpointMessage;
+export type PlivoMediaStreamSocket = {
+    close: (code?: number, reason?: string) => void | Promise<void>;
+    send: (data: string) => void | Promise<void>;
+};
+export type PlivoMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>, 'onVoiceMessage'> & {
+    onVoiceMessage?: (input: {
+        callId?: string;
+        message: VoiceServerMessage<TResult>;
+        sessionId: string;
+        streamId?: string;
+    }) => Promise<void> | void;
+};
+export type PlivoMediaStreamBridge = {
+    close: (reason?: string) => Promise<void>;
+    getSessionId: () => string | null;
+    getStreamId: () => string | null;
+    handleMessage: (raw: string | PlivoInboundMessage) => Promise<void>;
+};
 export type PlivoVoiceResponseOptions = {
     audioTrack?: 'both' | 'inbound' | 'outbound';
     bidirectional?: boolean;
@@ -53,6 +141,7 @@ export type PlivoVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSe
             streamPath: string;
         }) => Promise<string> | string);
     };
+    bridge?: PlivoMediaStreamBridgeOptions<TContext, TSession, TResult>;
     context?: TContext;
     name?: string;
     outcomePolicy?: VoiceTelephonyOutcomePolicy;
@@ -70,6 +159,7 @@ export type PlivoVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSe
     };
 };
 export declare const createPlivoVoiceResponse: (options: PlivoVoiceResponseOptions) => string;
+export declare const createPlivoMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: PlivoMediaStreamSocket, options: PlivoMediaStreamBridgeOptions<TContext, TSession, TResult>) => PlivoMediaStreamBridge;
 export declare const signVoicePlivoWebhook: (input: {
     authToken: string;
     body?: unknown;
@@ -121,6 +211,16 @@ export declare const createPlivoVoiceRoutes: <TContext = unknown, TSession exten
             };
         };
     };
+} & {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
 } & {
     [x: string]: {
         post: {

package/dist/telephony/telnyx.d.ts

@@ -1,7 +1,103 @@
 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 { VoiceSessionRecord } from '../types';
+import type { VoiceServerMessage, VoiceSessionRecord } from '../types';
+import { type TwilioMediaStreamBridgeOptions } from './twilio';
+export type TelnyxMediaPayload = {
+    chunk?: string;
+    payload: string;
+    timestamp?: string;
+    track?: 'inbound' | 'outbound' | 'inbound_track' | 'outbound_track';
+};
+export type TelnyxInboundMessage = {
+    event: 'connected';
+    version?: string;
+} | {
+    event: 'start';
+    sequence_number?: string;
+    start?: {
+        call_control_id?: string;
+        call_leg_id?: string;
+        call_session_id?: string;
+        custom_parameters?: Record<string, string>;
+        media_format?: {
+            channels?: number;
+            encoding?: string;
+            sample_rate?: number;
+        };
+        user_id?: string;
+    };
+    stream_id?: string;
+} | {
+    event: 'media';
+    media: TelnyxMediaPayload;
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: 'mark';
+    mark?: {
+        name?: string;
+    };
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: 'dtmf';
+    dtmf?: {
+        digit?: string;
+    };
+    sequence_number?: string;
+    stream_id?: string;
+} | {
+    event: 'error';
+    payload?: {
+        code?: number;
+        detail?: string;
+        title?: string;
+    };
+    stream_id?: string;
+} | {
+    event: 'stop';
+    sequence_number?: string;
+    stop?: {
+        call_control_id?: string;
+        user_id?: string;
+    };
+    stream_id?: string;
+};
+export type TelnyxOutboundMediaMessage = {
+    event: 'media';
+    media: {
+        payload: string;
+    };
+};
+export type TelnyxOutboundClearMessage = {
+    event: 'clear';
+};
+export type TelnyxOutboundMarkMessage = {
+    event: 'mark';
+    mark: {
+        name: string;
+    };
+};
+export type TelnyxOutboundMessage = TelnyxOutboundMediaMessage | TelnyxOutboundClearMessage | TelnyxOutboundMarkMessage;
+export type TelnyxMediaStreamSocket = {
+    close: (code?: number, reason?: string) => void | Promise<void>;
+    send: (data: string) => void | Promise<void>;
+};
+export type TelnyxMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>, 'onVoiceMessage'> & {
+    onVoiceMessage?: (input: {
+        callControlId?: string;
+        message: VoiceServerMessage<TResult>;
+        sessionId: string;
+        streamId?: string;
+    }) => Promise<void> | void;
+};
+export type TelnyxMediaStreamBridge = {
+    close: (reason?: string) => Promise<void>;
+    getSessionId: () => string | null;
+    getStreamId: () => string | null;
+    handleMessage: (raw: string | TelnyxInboundMessage) => Promise<void>;
+};
 export type TelnyxVoiceResponseOptions = {
     bidirectionalCodec?: 'AMR-WB' | 'G722' | 'OPUS' | 'PCMA' | 'PCMU';
     bidirectionalMode?: 'mp3' | 'rtp';
@@ -38,6 +134,7 @@ export type TelnyxVoiceSmokeOptions = {
     title?: string;
 };
 export type TelnyxVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    bridge?: TelnyxMediaStreamBridgeOptions<TContext, TSession, TResult>;
     context?: TContext;
     name?: string;
     outcomePolicy?: VoiceTelephonyOutcomePolicy;
@@ -61,6 +158,7 @@ export type TelnyxVoiceRoutesOptions<TContext = unknown, TSession extends VoiceS
     };
 };
 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: {
     body: string;
     headers: Headers;
@@ -106,6 +204,16 @@ export declare const createTelnyxVoiceRoutes: <TContext = unknown, TSession exte
             };
         };
     };
+} & {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
 } & {
     [x: string]: {
         post: {

package/package.json

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