@absolutejs/voice 0.0.22-beta.31 → 0.0.22-beta.311

package/dist/telephony/telnyx.d.ts

@@ -0,0 +1,291 @@
+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;
+    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';
+    codec?: 'AMR-WB' | 'G722' | 'OPUS' | 'PCMA' | 'PCMU' | 'default';
+    streamName?: string;
+    streamUrl: string;
+    track?: 'both_tracks' | 'inbound_track' | 'outbound_track';
+};
+export type TelnyxVoiceSetupStatus = VoiceTelephonySetupStatus<'telnyx'> & {
+    urls: VoiceTelephonySetupStatus<'telnyx'>['urls'] & {
+        texml: string;
+    };
+};
+export type TelnyxVoiceSetupOptions = {
+    path?: false | string;
+    requiredEnv?: Record<string, string | undefined>;
+    title?: string;
+};
+export type TelnyxVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type TelnyxVoiceSmokeReport = VoiceTelephonySmokeReport<'telnyx'> & {
+    contract: VoiceTelephonyContractReport<'telnyx'>;
+    setup: TelnyxVoiceSetupStatus;
+    texml?: {
+        status: number;
+        streamUrl?: string;
+    };
+};
+export type TelnyxVoiceSmokeOptions = {
+    callControlId?: string;
+    callLegId?: string;
+    eventType?: string;
+    path?: false | string;
+    sessionId?: string;
+    title?: string;
+};
+export type TelnyxVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    bridge?: TelnyxMediaStreamBridgeOptions<TContext, TSession, TResult>;
+    context?: TContext;
+    name?: string;
+    outcomePolicy?: VoiceTelephonyOutcomePolicy;
+    setup?: TelnyxVoiceSetupOptions;
+    smoke?: TelnyxVoiceSmokeOptions;
+    streamPath?: string;
+    texml?: {
+        path?: string;
+        response?: Omit<TelnyxVoiceResponseOptions, 'streamUrl'>;
+        streamUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+            streamPath: string;
+        }) => 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: {
+    body: string;
+    headers: Headers;
+    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: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | import("..").VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/telephony/twilio.d.ts

@@ -1,5 +1,8 @@
+import { Elysia } from 'elysia';
+import type { VoiceTelephonySetupStatus, VoiceTelephonySmokeCheck, VoiceTelephonySmokeReport } from './contract';
+import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions } from '../telephonyOutcome';
 import { type VoiceCallReviewArtifact, type VoiceCallReviewConfig } from '../testing/review';
-import type { AudioFormat, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from '../types';
+import type { AudioFormat, STTAdapter, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from '../types';
 type TwilioMediaPayload = {
     chunk?: string;
     payload: string;
@@ -75,7 +78,7 @@ export type TwilioMediaStreamSocket = {
     close: (code?: number, reason?: string) => void | Promise<void>;
     send: (data: string) => void | Promise<void>;
 };
-export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoicePluginConfig<TContext, TSession, TResult>, 'htmx' | 'path'> & {
+export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoicePluginConfig<TContext, TSession, TResult>, 'htmx' | 'path' | 'stt'> & {
     clearOnInboundMedia?: boolean;
     context: TContext;
     logger?: VoiceLogger;
@@ -94,6 +97,7 @@ export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends
     };
     scenarioId?: string;
     sessionId?: string;
+    stt: STTAdapter;
 };
 export type TwilioMediaStreamBridge = {
     close: (reason?: string) => Promise<void>;
@@ -107,10 +111,139 @@ export type TwilioVoiceResponseOptions = {
     streamUrl: string;
     track?: 'both_tracks' | 'inbound_track' | 'outbound_track';
 };
+export type TwilioVoiceRouteParameters = Record<string, string | number | boolean | undefined> | ((input: {
+    query: Record<string, unknown>;
+    request: Request;
+}) => Promise<Record<string, string | number | boolean | undefined>> | Record<string, string | number | boolean | undefined>);
+export type TwilioVoiceSetupStatus = VoiceTelephonySetupStatus<'twilio'> & {
+    urls: VoiceTelephonySetupStatus<'twilio'>['urls'] & {
+        twiml: string;
+    };
+};
+export type TwilioVoiceSetupOptions = {
+    path?: false | string;
+    requiredEnv?: Record<string, string | undefined>;
+    title?: string;
+};
+export type TwilioVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type TwilioVoiceSmokeReport = VoiceTelephonySmokeReport<'twilio'> & {
+    setup: TwilioVoiceSetupStatus;
+};
+export type TwilioVoiceSmokeOptions = {
+    callSid?: string;
+    path?: false | string;
+    scenarioId?: string;
+    sessionId?: string;
+    sipCode?: number;
+    status?: string;
+    title?: string;
+};
+export type TwilioVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = TwilioMediaStreamBridgeOptions<TContext, TSession, TResult> & {
+    name?: string;
+    outcomePolicy?: VoiceTelephonyOutcomePolicy;
+    smoke?: TwilioVoiceSmokeOptions;
+    setup?: TwilioVoiceSetupOptions;
+    streamPath?: string;
+    twiml?: {
+        parameters?: TwilioVoiceRouteParameters;
+        path?: string;
+        streamName?: string;
+        streamUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+            streamPath: string;
+        }) => Promise<string> | string);
+        track?: TwilioVoiceResponseOptions['track'];
+    };
+    webhook?: Omit<VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>, 'context' | 'path' | 'policy' | 'provider'> & {
+        path?: string;
+        policy?: VoiceTelephonyOutcomePolicy;
+    };
+};
 export declare const decodeTwilioMulawBase64: (payload: string) => Int16Array<ArrayBuffer>;
 export declare const encodeTwilioMulawBase64: (samples: Int16Array) => string;
 export declare const transcodeTwilioInboundPayloadToPCM16: (payload: string) => Uint8Array<ArrayBuffer>;
 export declare const transcodePCMToTwilioOutboundPayload: (chunk: Uint8Array, format: AudioFormat) => string;
 export declare const createTwilioVoiceResponse: (options: TwilioVoiceResponseOptions) => string;
 export declare const createTwilioMediaStreamBridge: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(socket: TwilioMediaStreamSocket, options: TwilioMediaStreamBridgeOptions<TContext, TSession, TResult>) => TwilioMediaStreamBridge;
+export declare const createTwilioVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: TwilioVoiceRoutesOptions<TContext, TSession, TResult>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        subscribe: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {};
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | import("..").VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
 export {};