@absolutejs/voice 0.0.22-beta.15 → 0.0.22-beta.150

package/dist/campaign.d.ts

@@ -0,0 +1,610 @@
+import { Elysia } from 'elysia';
+import type { VoiceRedisTaskLeaseCoordinator } from './queue';
+import type { VoiceTelephonyOutcomeDecision, VoiceTelephonyOutcomeProviderEvent, VoiceTelephonyWebhookDecision } from './telephonyOutcome';
+export type VoiceCampaignStatus = 'canceled' | 'completed' | 'draft' | 'paused' | 'running';
+export type VoiceCampaignRecipientStatus = 'canceled' | 'completed' | 'failed' | 'pending' | 'queued';
+export type VoiceCampaignAttemptStatus = 'canceled' | 'failed' | 'queued' | 'running' | 'succeeded';
+export type VoiceCampaignRecipient = {
+    attempts: number;
+    completedAt?: number;
+    createdAt: number;
+    error?: string;
+    id: string;
+    metadata?: Record<string, unknown>;
+    name?: string;
+    phone: string;
+    status: VoiceCampaignRecipientStatus;
+    updatedAt: number;
+    variables?: Record<string, string | number | boolean | undefined>;
+};
+export type VoiceCampaignAttempt = {
+    campaignId: string;
+    completedAt?: number;
+    createdAt: number;
+    error?: string;
+    externalCallId?: string;
+    id: string;
+    metadata?: Record<string, unknown>;
+    recipientId: string;
+    startedAt?: number;
+    status: VoiceCampaignAttemptStatus;
+    updatedAt: number;
+};
+export type VoiceCampaign = {
+    createdAt: number;
+    description?: string;
+    id: string;
+    maxAttempts: number;
+    maxConcurrentAttempts: number;
+    metadata?: Record<string, unknown>;
+    name: string;
+    status: VoiceCampaignStatus;
+    updatedAt: number;
+};
+export type VoiceCampaignRecord = {
+    attempts: VoiceCampaignAttempt[];
+    campaign: VoiceCampaign;
+    recipients: VoiceCampaignRecipient[];
+};
+export type VoiceCampaignStore = {
+    get: (id: string) => Promise<VoiceCampaignRecord | undefined> | VoiceCampaignRecord | undefined;
+    list: () => Promise<VoiceCampaignRecord[]> | VoiceCampaignRecord[];
+    remove: (id: string) => Promise<void> | void;
+    set: (id: string, record: VoiceCampaignRecord) => Promise<void> | void;
+};
+export type VoiceCampaignDialerInput = {
+    attempt: VoiceCampaignAttempt;
+    campaign: VoiceCampaign;
+    recipient: VoiceCampaignRecipient;
+};
+export type VoiceCampaignDialerResult = {
+    externalCallId?: string;
+    metadata?: Record<string, unknown>;
+    status?: 'queued' | 'running' | 'succeeded';
+};
+export type VoiceCampaignDialer = (input: VoiceCampaignDialerInput) => Promise<VoiceCampaignDialerResult> | VoiceCampaignDialerResult;
+export type VoiceCampaignCreateInput = {
+    description?: string;
+    id?: string;
+    maxAttempts?: number;
+    maxConcurrentAttempts?: number;
+    metadata?: Record<string, unknown>;
+    name: string;
+};
+export type VoiceCampaignRecipientInput = {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    name?: string;
+    phone: string;
+    variables?: VoiceCampaignRecipient['variables'];
+};
+export type VoiceCampaignAttemptResultInput = {
+    error?: string;
+    externalCallId?: string;
+    metadata?: Record<string, unknown>;
+    status: 'failed' | 'succeeded';
+};
+export type VoiceCampaignTickResult = {
+    attempted: number;
+    campaignId: string;
+    errors: Array<{
+        error: string;
+        recipientId: string;
+    }>;
+    started: VoiceCampaignAttempt[];
+};
+export type VoiceCampaignProofOptions = {
+    campaign?: VoiceCampaignCreateInput;
+    completeAttempts?: boolean;
+    recipients?: VoiceCampaignRecipientInput[];
+    runtime?: VoiceCampaignRuntime;
+    store?: VoiceCampaignStore;
+};
+export type VoiceCampaignProofReport = {
+    campaign: VoiceCampaignRecord;
+    created: VoiceCampaignRecord;
+    final: VoiceCampaignRecord;
+    proof: 'voice-campaign';
+    recipients: VoiceCampaignRecord;
+    summary: VoiceCampaignSummary;
+    tick: VoiceCampaignTickResult;
+};
+export type VoiceCampaignSummary = {
+    attempts: {
+        failed: number;
+        queued: number;
+        running: number;
+        succeeded: number;
+        total: number;
+    };
+    campaigns: {
+        canceled: number;
+        completed: number;
+        draft: number;
+        paused: number;
+        running: number;
+        total: number;
+    };
+    recipients: {
+        canceled: number;
+        completed: number;
+        failed: number;
+        pending: number;
+        queued: number;
+        total: number;
+    };
+};
+export type VoiceCampaignRuntimeOptions = {
+    dialer?: VoiceCampaignDialer;
+    store: VoiceCampaignStore;
+};
+export type VoiceCampaignRuntime = {
+    addRecipients: (campaignId: string, recipients: VoiceCampaignRecipientInput[]) => Promise<VoiceCampaignRecord>;
+    cancel: (campaignId: string) => Promise<VoiceCampaignRecord>;
+    completeAttempt: (campaignId: string, attemptId: string, result: VoiceCampaignAttemptResultInput) => Promise<VoiceCampaignRecord>;
+    create: (input: VoiceCampaignCreateInput) => Promise<VoiceCampaignRecord>;
+    enqueue: (campaignId: string) => Promise<VoiceCampaignRecord>;
+    get: (campaignId: string) => Promise<VoiceCampaignRecord | undefined>;
+    list: () => Promise<VoiceCampaignRecord[]>;
+    pause: (campaignId: string) => Promise<VoiceCampaignRecord>;
+    remove: (campaignId: string) => Promise<void>;
+    resume: (campaignId: string) => Promise<VoiceCampaignRecord>;
+    summarize: () => Promise<VoiceCampaignSummary>;
+    tick: (campaignId: string) => Promise<VoiceCampaignTickResult>;
+};
+export type VoiceCampaignRoutesOptions = VoiceCampaignRuntimeOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    observability?: VoiceCampaignObservabilityOptions;
+    name?: string;
+    path?: string;
+    title?: string;
+};
+export type VoiceCampaignWorkerOptions = {
+    campaignIds?: string[];
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    maxCampaigns?: number;
+    runtime?: VoiceCampaignRuntime;
+    statuses?: VoiceCampaignStatus[];
+    store?: VoiceCampaignStore;
+    workerId: string;
+};
+export type VoiceCampaignWorkerResult = {
+    attempted: number;
+    campaigns: number;
+    errors: Array<{
+        campaignId: string;
+        error: string;
+    }>;
+    skipped: number;
+    started: VoiceCampaignAttempt[];
+};
+export type VoiceCampaignWorker = {
+    drain: () => Promise<VoiceCampaignWorkerResult>;
+};
+export type VoiceCampaignWorkerLoopOptions = {
+    onError?: (error: unknown) => void | Promise<void>;
+    pollIntervalMs?: number;
+    worker: VoiceCampaignWorker;
+};
+export type VoiceCampaignWorkerLoop = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceCampaignWorkerResult>;
+};
+export type VoiceCampaignObservabilityOptions = {
+    leases?: VoiceRedisTaskLeaseCoordinator;
+    now?: number;
+    rateWindowMs?: number;
+    stuckAfterMs?: number;
+};
+export type VoiceCampaignObservabilityReport = {
+    attemptRate: {
+        failed: number;
+        started: number;
+        succeeded: number;
+        windowMs: number;
+    };
+    campaigns: Array<{
+        activeAttempts: number;
+        campaignId: string;
+        lease?: {
+            expiresAt: number;
+            workerId: string;
+        };
+        name: string;
+        queueDepth: number;
+        status: VoiceCampaignStatus;
+        stuckAttempts: number;
+        stuckRecipients: number;
+        updatedAt: number;
+    }>;
+    failureReasons: Array<{
+        count: number;
+        reason: string;
+    }>;
+    generatedAt: number;
+    leases: {
+        active: number;
+        known: boolean;
+    };
+    queue: {
+        activeAttempts: number;
+        queuedRecipients: number;
+        runningCampaigns: number;
+    };
+    stuck: {
+        attempts: Array<{
+            attemptId: string;
+            campaignId: string;
+            recipientId: string;
+            status: VoiceCampaignAttemptStatus;
+            updatedAt: number;
+        }>;
+        recipients: Array<{
+            campaignId: string;
+            recipientId: string;
+            status: VoiceCampaignRecipientStatus;
+            updatedAt: number;
+        }>;
+    };
+    summary: VoiceCampaignSummary;
+};
+export type VoiceCampaignTelephonyOutcomeInput<TResult = unknown> = {
+    campaignId?: string;
+    decision: VoiceTelephonyOutcomeDecision;
+    event?: VoiceTelephonyOutcomeProviderEvent;
+    externalCallId?: string;
+    routeResult?: TResult;
+    sessionId?: string;
+    attemptId?: string;
+};
+export type VoiceCampaignTelephonyOutcomeStatus = 'failed' | 'ignore' | 'succeeded';
+export type VoiceCampaignTelephonyOutcomeOptions<TResult = unknown> = {
+    resolveCampaignId?: (input: VoiceCampaignTelephonyOutcomeInput<TResult>) => Promise<string | undefined> | string | undefined;
+    resolveExternalCallId?: (input: VoiceCampaignTelephonyOutcomeInput<TResult>) => Promise<string | undefined> | string | undefined;
+    resolveAttemptId?: (input: VoiceCampaignTelephonyOutcomeInput<TResult>) => Promise<string | undefined> | string | undefined;
+    runtime?: VoiceCampaignRuntime;
+    statusForDecision?: (input: VoiceCampaignTelephonyOutcomeInput<TResult>) => Promise<VoiceCampaignTelephonyOutcomeStatus> | VoiceCampaignTelephonyOutcomeStatus;
+    store?: VoiceCampaignStore;
+};
+export type VoiceCampaignTelephonyOutcomeResult = {
+    applied: boolean;
+    campaignId?: string;
+    error?: string;
+    externalCallId?: string;
+    reason?: 'ignored' | 'missing-attempt' | 'missing-campaign' | 'missing-runtime' | 'terminal-attempt';
+    status?: 'failed' | 'succeeded';
+    attemptId?: string;
+};
+export declare const createVoiceMemoryCampaignStore: () => VoiceCampaignStore;
+export declare const summarizeVoiceCampaigns: (records: VoiceCampaignRecord[]) => VoiceCampaignSummary;
+export declare const buildVoiceCampaignObservabilityReport: (records: VoiceCampaignRecord[], options?: VoiceCampaignObservabilityOptions) => Promise<VoiceCampaignObservabilityReport>;
+export declare const createVoiceCampaign: (options: VoiceCampaignRuntimeOptions) => VoiceCampaignRuntime;
+export declare const createVoiceCampaignWorker: (options: VoiceCampaignWorkerOptions) => VoiceCampaignWorker;
+export declare const createVoiceCampaignWorkerLoop: (options: VoiceCampaignWorkerLoopOptions) => VoiceCampaignWorkerLoop;
+export declare const applyVoiceCampaignTelephonyOutcome: <TResult = unknown>(input: VoiceCampaignTelephonyOutcomeInput<TResult>, options?: VoiceCampaignTelephonyOutcomeOptions<TResult>) => Promise<VoiceCampaignTelephonyOutcomeResult>;
+export declare const createVoiceCampaignTelephonyOutcomeHandler: <TResult = unknown>(options: VoiceCampaignTelephonyOutcomeOptions<TResult>) => (input: VoiceTelephonyWebhookDecision<TResult>) => Promise<VoiceCampaignTelephonyOutcomeResult>;
+export declare const runVoiceCampaignProof: (options?: VoiceCampaignProofOptions) => Promise<VoiceCampaignProofReport>;
+export declare const renderVoiceCampaignsHTML: (records: VoiceCampaignRecord[], options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceCampaignObservabilityHTML: (report: VoiceCampaignObservabilityReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceCampaignRoutes: (options: VoiceCampaignRoutesOptions) => 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: {
+                    campaigns: VoiceCampaignRecord[];
+                    summary: VoiceCampaignSummary;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        observability: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: VoiceCampaignObservabilityReport;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceCampaignRecord;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            get: {
+                body: unknown;
+                params: {
+                    campaignId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            delete: {
+                body: unknown;
+                params: {
+                    campaignId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        ok: boolean;
+                    };
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            recipients: {
+                post: {
+                    body: unknown;
+                    params: {
+                        campaignId: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: VoiceCampaignRecord;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            enqueue: {
+                post: {
+                    body: unknown;
+                    params: {
+                        campaignId: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: VoiceCampaignRecord;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            pause: {
+                post: {
+                    body: unknown;
+                    params: {
+                        campaignId: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: VoiceCampaignRecord;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            resume: {
+                post: {
+                    body: unknown;
+                    params: {
+                        campaignId: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: VoiceCampaignRecord;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            cancel: {
+                post: {
+                    body: unknown;
+                    params: {
+                        campaignId: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: VoiceCampaignRecord;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            tick: {
+                post: {
+                    body: unknown;
+                    params: {
+                        campaignId: string;
+                    } & {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: VoiceCampaignTickResult;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":campaignId": {
+            attempts: {
+                ":attemptId": {
+                    result: {
+                        post: {
+                            body: unknown;
+                            params: {
+                                campaignId: string;
+                                attemptId: string;
+                            } & {};
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                200: VoiceCampaignRecord;
+                                422: {
+                                    type: "validation";
+                                    on: string;
+                                    summary?: string;
+                                    message?: string;
+                                    found?: unknown;
+                                    property?: string;
+                                    expected?: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/campaignDialers.d.ts

@@ -0,0 +1,90 @@
+import { applyVoiceCampaignTelephonyOutcome, VoiceCampaignDialer, VoiceCampaignDialerInput, type VoiceCampaignRecord, type VoiceCampaignStore, type VoiceCampaignTickResult } from './campaign';
+type VoiceCampaignDialerFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type VoiceCampaignDialerMetadataInput = VoiceCampaignDialerInput & {
+    provider: 'plivo' | 'telnyx' | 'twilio';
+};
+type VoiceCampaignDialerMetadata = Record<string, string | number | boolean | undefined> | ((input: VoiceCampaignDialerMetadataInput) => Record<string, string | number | boolean | undefined> | Promise<Record<string, string | number | boolean | undefined>>);
+type VoiceCampaignURLInput = {
+    attempt: VoiceCampaignDialerInput['attempt'];
+    campaign: VoiceCampaignDialerInput['campaign'];
+    recipient: VoiceCampaignDialerInput['recipient'];
+};
+type VoiceCampaignURLResolver = string | ((input: VoiceCampaignURLInput) => string | Promise<string>);
+export type VoiceTwilioCampaignDialerOptions = {
+    accountSid: string;
+    answerMethod?: 'GET' | 'POST';
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authToken: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    machineDetection?: string;
+    metadata?: VoiceCampaignDialerMetadata;
+    statusCallbackEvents?: string[];
+    statusCallbackMethod?: 'GET' | 'POST';
+    statusCallbackUrl?: VoiceCampaignURLResolver;
+};
+export type VoiceTelnyxCampaignDialerOptions = {
+    apiBaseUrl?: string;
+    apiKey: string;
+    clientState?: VoiceCampaignDialerMetadata;
+    connectionId: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    webhookUrl?: VoiceCampaignURLResolver;
+    webhookUrlMethod?: 'GET' | 'POST';
+};
+export type VoicePlivoCampaignDialerOptions = {
+    answerMethod?: 'GET' | 'POST';
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authId: string;
+    authToken: string;
+    callbackMethod?: 'GET' | 'POST';
+    callbackUrl?: VoiceCampaignURLResolver;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    metadata?: VoiceCampaignDialerMetadata;
+};
+export type VoiceCampaignDialerProofProvider = 'plivo' | 'telnyx' | 'twilio';
+export type VoiceCampaignDialerProofCarrierRequest = {
+    body: unknown;
+    method: string;
+    provider: VoiceCampaignDialerProofProvider;
+    url: string;
+};
+export type VoiceCampaignDialerProofProviderResult = {
+    campaignId: string;
+    carrierRequests: VoiceCampaignDialerProofCarrierRequest[];
+    final?: VoiceCampaignRecord;
+    outcomes: Awaited<ReturnType<typeof applyVoiceCampaignTelephonyOutcome>>[];
+    provider: VoiceCampaignDialerProofProvider;
+    tick: VoiceCampaignTickResult;
+};
+export type VoiceCampaignDialerProofReport = {
+    generatedAt: number;
+    mode: 'dry-run';
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProviderResult[];
+};
+export type VoiceCampaignDialerProofStatus = {
+    generatedAt: number;
+    mode: 'dry-run';
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    safe: true;
+};
+export type VoiceCampaignDialerProofOptions = {
+    baseUrl?: string;
+    from?: string;
+    providers?: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    store?: VoiceCampaignStore;
+};
+export declare const createVoiceTwilioCampaignDialer: (options: VoiceTwilioCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const createVoiceTelnyxCampaignDialer: (options: VoiceTelnyxCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const createVoicePlivoCampaignDialer: (options: VoicePlivoCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const getVoiceCampaignDialerProofStatus: (options?: Pick<VoiceCampaignDialerProofOptions, "providers" | "runPath">) => VoiceCampaignDialerProofStatus;
+export declare const runVoiceCampaignDialerProof: (options?: VoiceCampaignDialerProofOptions) => Promise<VoiceCampaignDialerProofReport>;
+export {};