@absolutejs/voice 0.0.22-beta.80 → 0.0.22-beta.82

package/dist/index.d.ts

@@ -82,13 +82,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

@@ -11223,6 +11223,8 @@ var createVoiceTelephonyWebhookRoutes = (options = {}) => {
       }
       throw error;
     }
+  }, {
+    parse: "none"
   });
 };
 // src/fileStore.ts
@@ -16026,6 +16028,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) {
@@ -16180,6 +16290,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,
@@ -16217,6 +16328,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,
@@ -16325,6 +16461,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;
@@ -16505,6 +16758,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({
@@ -16546,6 +16800,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,
@@ -17011,6 +17290,7 @@ export {
   createTwilioMediaStreamBridge,
   createTelnyxVoiceRoutes,
   createTelnyxVoiceResponse,
+  createTelnyxMediaStreamBridge,
   createStoredVoiceOpsTask,
   createStoredVoiceIntegrationEvent,
   createStoredVoiceExternalObjectMap,
@@ -17018,6 +17298,7 @@ export {
   createRiskyTurnCorrectionHandler,
   createPlivoVoiceRoutes,
   createPlivoVoiceResponse,
+  createPlivoMediaStreamBridge,
   createPhraseHintCorrectionHandler,
   createOpenAIVoiceAssistantModel,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,

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/dist/testing/index.js

@@ -8533,6 +8533,8 @@ var createVoiceTelephonyWebhookRoutes = (options = {}) => {
       }
       throw error;
     }
+  }, {
+    parse: "none"
   });
 };
 

package/package.json

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