@absolutejs/voice 0.0.22-beta.9 → 0.0.22-beta.90

package/dist/telephony/twilio.d.ts

@@ -1,3 +1,6 @@
+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';
 type TwilioMediaPayload = {
@@ -107,10 +110,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 {};

package/dist/telephonyOutcome.d.ts

@@ -0,0 +1,201 @@
+import { Elysia } from 'elysia';
+import type { VoiceCallDisposition, VoiceRouteResult, VoiceSessionHandle, VoiceSessionRecord } from './types';
+export type VoiceTelephonyOutcomeAction = 'complete' | 'escalate' | 'ignore' | 'no-answer' | 'transfer' | 'voicemail';
+export type VoiceTelephonyOutcomeProviderEvent = {
+    answeredBy?: string;
+    durationMs?: number;
+    from?: string;
+    metadata?: Record<string, unknown>;
+    provider?: string;
+    reason?: string;
+    sipCode?: number;
+    status?: string;
+    target?: string;
+    to?: string;
+};
+export type VoiceTelephonyOutcomeDecision = {
+    action: VoiceTelephonyOutcomeAction;
+    confidence: 'high' | 'low' | 'medium';
+    disposition?: VoiceCallDisposition;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    source: 'answered-by' | 'duration' | 'explicit-target' | 'policy' | 'sip' | 'status';
+    target?: string;
+};
+export type VoiceTelephonyOutcomeStatusDecision = VoiceTelephonyOutcomeAction | Omit<VoiceTelephonyOutcomeDecision, 'confidence' | 'source'> & {
+    confidence?: VoiceTelephonyOutcomeDecision['confidence'];
+    source?: VoiceTelephonyOutcomeDecision['source'];
+};
+export type VoiceTelephonyOutcomePolicy = {
+    completedStatuses?: string[];
+    escalationStatuses?: string[];
+    failedAsNoAnswer?: boolean;
+    failedStatuses?: string[];
+    includeProviderPayload?: boolean;
+    machineDetectionVoicemailValues?: string[];
+    metadata?: Record<string, unknown>;
+    minAnsweredDurationMs?: number;
+    noAnswerOnZeroDuration?: boolean;
+    noAnswerSipCodes?: number[];
+    noAnswerStatuses?: string[];
+    statusMap?: Record<string, VoiceTelephonyOutcomeStatusDecision>;
+    transferStatuses?: string[];
+    transferTarget?: string | ((event: VoiceTelephonyOutcomeProviderEvent) => string | undefined);
+    voicemailStatuses?: string[];
+};
+export type VoiceTelephonyOutcomeRouteResult<TResult = unknown> = VoiceRouteResult<TResult>;
+export type VoiceTelephonyWebhookProvider = 'generic' | 'plivo' | 'telnyx' | 'twilio';
+export type VoiceTelephonyWebhookParseInput = {
+    body: unknown;
+    headers: Headers;
+    provider: VoiceTelephonyWebhookProvider;
+    query: Record<string, unknown>;
+    request: Request;
+};
+export type VoiceTelephonyWebhookDecision<TResult = unknown> = {
+    applied: boolean;
+    decision: VoiceTelephonyOutcomeDecision;
+    duplicate?: boolean;
+    event: VoiceTelephonyOutcomeProviderEvent;
+    idempotencyKey?: string;
+    routeResult: VoiceTelephonyOutcomeRouteResult<TResult>;
+    sessionId?: string;
+};
+export type StoredVoiceTelephonyWebhookDecision<TResult = unknown> = VoiceTelephonyWebhookDecision<TResult> & {
+    createdAt: number;
+    updatedAt: number;
+};
+export type VoiceTelephonyWebhookIdempotencyStore<TResult = unknown> = {
+    get: (key: string) => Promise<StoredVoiceTelephonyWebhookDecision<TResult> | undefined> | StoredVoiceTelephonyWebhookDecision<TResult> | undefined;
+    set: (key: string, decision: StoredVoiceTelephonyWebhookDecision<TResult>) => Promise<void> | void;
+};
+export type VoiceTelephonyWebhookVerificationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'invalid-signature' | 'missing-secret' | 'missing-signature' | 'unsupported-provider';
+};
+export type VoiceTelephonyWebhookHandlerOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    apply?: boolean | ((input: VoiceTelephonyWebhookDecision<TResult>) => boolean);
+    context?: TContext;
+    getSessionHandle?: (input: {
+        context: TContext;
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        request: Request;
+        sessionId?: string;
+    }) => Promise<VoiceSessionHandle<TContext, TSession, TResult> | undefined> | VoiceSessionHandle<TContext, TSession, TResult> | undefined;
+    idempotency?: {
+        enabled?: boolean;
+        key?: (input: {
+            body: unknown;
+            event: VoiceTelephonyOutcomeProviderEvent;
+            provider: VoiceTelephonyWebhookProvider;
+            query: Record<string, unknown>;
+            request: Request;
+            sessionId?: string;
+        }) => Promise<string | undefined> | string | undefined;
+        store?: VoiceTelephonyWebhookIdempotencyStore<TResult>;
+    };
+    onDecision?: (input: VoiceTelephonyWebhookDecision<TResult> & {
+        context: TContext;
+        request: Request;
+    }) => Promise<void> | void;
+    parse?: (input: VoiceTelephonyWebhookParseInput) => Promise<VoiceTelephonyOutcomeProviderEvent> | VoiceTelephonyOutcomeProviderEvent;
+    policy?: VoiceTelephonyOutcomePolicy;
+    provider?: VoiceTelephonyWebhookProvider;
+    requireVerification?: boolean;
+    resolveSessionId?: (input: {
+        body: unknown;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<string | undefined> | string | undefined;
+    result?: TResult | ((input: {
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        sessionId?: string;
+    }) => Promise<TResult | undefined> | TResult | undefined);
+    signingSecret?: string;
+    verificationUrl?: string | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => string);
+    verify?: (input: {
+        body: unknown;
+        headers: Headers;
+        provider: VoiceTelephonyWebhookProvider;
+        query: Record<string, unknown>;
+        rawBody: string;
+        request: Request;
+    }) => Promise<VoiceTelephonyWebhookVerificationResult> | VoiceTelephonyWebhookVerificationResult;
+};
+export type VoiceTelephonyWebhookRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult> & {
+    name?: string;
+    path?: string;
+};
+export declare class VoiceTelephonyWebhookVerificationError extends Error {
+    result: VoiceTelephonyWebhookVerificationResult;
+    constructor(result: VoiceTelephonyWebhookVerificationResult);
+}
+export declare const createMemoryVoiceTelephonyWebhookIdempotencyStore: <TResult = unknown>() => VoiceTelephonyWebhookIdempotencyStore<TResult>;
+export declare const createVoiceTelephonyOutcomePolicy: (policy?: VoiceTelephonyOutcomePolicy) => Required<Pick<VoiceTelephonyOutcomePolicy, "completedStatuses" | "escalationStatuses" | "failedAsNoAnswer" | "failedStatuses" | "includeProviderPayload" | "machineDetectionVoicemailValues" | "noAnswerOnZeroDuration" | "noAnswerSipCodes" | "noAnswerStatuses" | "transferStatuses" | "voicemailStatuses">> & VoiceTelephonyOutcomePolicy;
+export declare const resolveVoiceTelephonyOutcome: (event: VoiceTelephonyOutcomeProviderEvent, policyInput?: VoiceTelephonyOutcomePolicy) => VoiceTelephonyOutcomeDecision;
+export declare const voiceTelephonyOutcomeToRouteResult: <TResult = unknown>(decision: VoiceTelephonyOutcomeDecision, result?: TResult) => VoiceTelephonyOutcomeRouteResult<TResult>;
+export declare const applyVoiceTelephonyOutcome: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(api: VoiceSessionHandle<TContext, TSession, TResult>, decision: VoiceTelephonyOutcomeDecision, result?: TResult) => Promise<void>;
+export declare const signVoiceTwilioWebhook: (input: {
+    authToken: string;
+    body?: unknown;
+    url: string;
+}) => Promise<string>;
+export declare const verifyVoiceTwilioWebhookSignature: (input: {
+    authToken?: string;
+    body?: unknown;
+    headers: Headers;
+    url: string;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const parseVoiceTelephonyWebhookEvent: (input: VoiceTelephonyWebhookParseInput) => VoiceTelephonyOutcomeProviderEvent;
+export declare const createVoiceTelephonyWebhookHandler: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult>) => (input: {
+    query?: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoiceTelephonyWebhookDecision<TResult>>;
+export declare const createVoiceTelephonyWebhookRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/testing/index.d.ts

@@ -3,6 +3,8 @@ export * from './benchmark';
 export * from './corrected';
 export * from './duplex';
 export * from './fixtures';
+export * from './ioProviderSimulator';
+export * from './providerSimulator';
 export * from './resilience';
 export * from './review';
 export * from './sessionBenchmark';