@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.511

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,18 +1,21 @@
-import { type VoiceCallReviewArtifact, type VoiceCallReviewConfig } from '../testing/review';
-import type { AudioFormat, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from '../types';
+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, STTAdapter, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from "../types";
 type TwilioMediaPayload = {
     chunk?: string;
     payload: string;
     timestamp?: string;
-    track?: 'inbound' | 'outbound';
+    track?: "inbound" | "outbound";
 };
 type TwilioConnectedMessage = {
-    event: 'connected';
+    event: "connected";
     protocol?: string;
     version?: string;
 };
 type TwilioStartMessage = {
-    event: 'start';
+    event: "start";
     sequenceNumber?: string;
     start: {
         accountSid?: string;
@@ -29,13 +32,13 @@ type TwilioStartMessage = {
     streamSid?: string;
 };
 type TwilioMediaMessage = {
-    event: 'media';
+    event: "media";
     media: TwilioMediaPayload;
     sequenceNumber?: string;
     streamSid: string;
 };
 type TwilioMarkMessage = {
-    event: 'mark';
+    event: "mark";
     mark?: {
         name?: string;
     };
@@ -43,7 +46,7 @@ type TwilioMarkMessage = {
     streamSid: string;
 };
 type TwilioStopMessage = {
-    event: 'stop';
+    event: "stop";
     sequenceNumber?: string;
     stop?: {
         accountSid?: string;
@@ -53,18 +56,18 @@ type TwilioStopMessage = {
 };
 export type TwilioInboundMessage = TwilioConnectedMessage | TwilioStartMessage | TwilioMediaMessage | TwilioMarkMessage | TwilioStopMessage;
 export type TwilioOutboundMediaMessage = {
-    event: 'media';
+    event: "media";
     media: {
         payload: string;
     };
     streamSid: string;
 };
 export type TwilioOutboundClearMessage = {
-    event: 'clear';
+    event: "clear";
     streamSid: string;
 };
 export type TwilioOutboundMarkMessage = {
-    event: 'mark';
+    event: "mark";
     mark: {
         name: 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,8 @@ export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends
     };
     scenarioId?: string;
     sessionId?: string;
+    stt: STTAdapter;
+    telephonyMediaCarrier?: "plivo" | "telnyx" | "twilio";
 };
 export type TwilioMediaStreamBridge = {
     close: (reason?: string) => Promise<void>;
@@ -105,7 +110,56 @@ export type TwilioVoiceResponseOptions = {
     parameters?: Record<string, string | number | boolean | undefined>;
     streamName?: string;
     streamUrl: string;
-    track?: 'both_tracks' | 'inbound_track' | 'outbound_track';
+    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;
@@ -113,4 +167,84 @@ export declare const transcodeTwilioInboundPayloadToPCM16: (payload: string) =>
 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 {};

package/dist/telephonyMediaRoutes.d.ts

@@ -0,0 +1,72 @@
+import { Elysia } from "elysia";
+import type { MediaFrame, MediaTelephonyCarrier, MediaTelephonyEnvelope, MediaTelephonyStreamLifecycleReport } from "@absolutejs/media";
+import type { VoiceTraceEventStore } from "./trace";
+export type VoiceTelephonyMediaStatus = "fail" | "pass";
+export type VoiceTelephonyMediaCarrierInput = {
+    carrier: MediaTelephonyCarrier;
+    envelope?: MediaTelephonyEnvelope;
+    lifecycleEnvelopes?: readonly MediaTelephonyEnvelope[];
+};
+export type VoiceTelephonyMediaCarrierReport = {
+    audioBytes: number;
+    carrier: MediaTelephonyCarrier;
+    frame?: MediaFrame;
+    issues: string[];
+    lifecycle: MediaTelephonyStreamLifecycleReport;
+    serialized?: MediaTelephonyEnvelope;
+    status: VoiceTelephonyMediaStatus;
+};
+export type VoiceTelephonyMediaReport = {
+    carriers: readonly VoiceTelephonyMediaCarrierReport[];
+    checkedAt: number;
+    issues: string[];
+    status: VoiceTelephonyMediaStatus;
+};
+export type VoiceTelephonyMediaRoutesOptions = {
+    carriers?: readonly VoiceTelephonyMediaCarrierInput[];
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    store?: VoiceTraceEventStore;
+    title?: string;
+};
+export type VoiceTelephonyMediaTraceReportOptions = {
+    carriers?: readonly MediaTelephonyCarrier[];
+    store: VoiceTraceEventStore;
+};
+export declare const buildVoiceTelephonyMediaReport: (input?: {
+    carriers?: readonly VoiceTelephonyMediaCarrierInput[];
+}) => VoiceTelephonyMediaReport;
+export declare const getLatestVoiceTelephonyMediaReport: (options: VoiceTelephonyMediaTraceReportOptions) => Promise<VoiceTelephonyMediaReport | undefined>;
+export declare const renderVoiceTelephonyMediaHTML: (report: VoiceTelephonyMediaReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceTelephonyMediaRoutes: (options?: VoiceTelephonyMediaRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;