@absolutejs/voice 0.0.22-beta.4 → 0.0.22-beta.400

package/dist/campaignDialers.d.ts

@@ -0,0 +1,111 @@
+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 type VoiceCampaignDialerProofAssertionInput = {
+    maxFailedProviders?: number;
+    minCarrierRequests?: number;
+    minProviders?: number;
+    minSuccessfulOutcomes?: number;
+    requiredProviders?: VoiceCampaignDialerProofProvider[];
+    requireDryRun?: boolean;
+    requireOk?: boolean;
+};
+export type VoiceCampaignDialerProofAssertionReport = {
+    carrierRequests: number;
+    failedProviders: number;
+    issues: string[];
+    mode: VoiceCampaignDialerProofReport['mode'];
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    successfulOutcomes: number;
+    totalProviders: number;
+};
+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 declare const evaluateVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
+export declare const assertVoiceCampaignDialerProofEvidence: (report: VoiceCampaignDialerProofReport, input?: VoiceCampaignDialerProofAssertionInput) => VoiceCampaignDialerProofAssertionReport;
+export {};

package/dist/client/actions.d.ts

@@ -7,10 +7,17 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     type: "audio";
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     text: string;
@@ -20,10 +27,17 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
@@ -33,10 +47,57 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    reconnect: import("..").VoiceReconnectClientState;
+    type: "connection";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
+    sessionId?: undefined;
+    event?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    scenarioId?: undefined;
+    sessionMetadata?: undefined;
+    status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    event: import("..").VoiceCallLifecycleEvent;
+    sessionId: string;
+    type: "call_lifecycle";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
+    reconnect?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    scenarioId?: undefined;
+    sessionMetadata?: undefined;
+    status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     message: string;
@@ -47,9 +108,16 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
@@ -60,9 +128,16 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     message?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     transcript: import("..").Transcript;
@@ -73,12 +148,40 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     message?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
+    turn?: undefined;
+} | {
+    assistantTexts: string[];
+    call: import("..").VoiceCallLifecycleState | undefined;
+    partial: string;
+    scenarioId: string | undefined;
+    sessionId: string;
+    sessionMetadata: Record<string, unknown> | undefined;
+    status: import("..").VoiceSessionStatus;
+    turns: import("..").VoiceTurnRecord<TResult>[];
+    type: "replay";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
+    message?: undefined;
+    transcript?: undefined;
     turn?: undefined;
 } | {
     sessionId: string;
+    sessionMetadata: Record<string, unknown> | undefined;
     scenarioId: string | undefined;
     status: import("..").VoiceSessionStatus;
     type: "session";
@@ -87,8 +190,14 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
+    turns?: undefined;
     turn?: undefined;
 } | {
     turn: import("..").VoiceTurnRecord<TResult>;
@@ -99,8 +208,15 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    reconnect?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
+    assistantTexts?: undefined;
+    call?: undefined;
+    partial?: undefined;
     scenarioId?: undefined;
+    sessionMetadata?: undefined;
     status?: undefined;
+    turns?: undefined;
 } | null;

package/dist/client/agentSquadStatus.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceTraceTimelineReport } from '../traceTimeline';
+import { type VoiceTraceTimelineClientOptions } from './traceTimeline';
+export type VoiceAgentSquadSpecialistStatus = 'active' | 'blocked' | 'handoff' | 'idle' | 'unknown-target';
+export type VoiceAgentSquadSpecialist = {
+    fromAgentId?: string;
+    lastEventAt?: number;
+    reason?: string;
+    sessionId: string;
+    status: VoiceAgentSquadSpecialistStatus;
+    summary?: string;
+    targetAgentId?: string;
+    turnId?: string;
+};
+export type VoiceAgentSquadStatusReport = {
+    active: VoiceAgentSquadSpecialist[];
+    checkedAt?: number;
+    current?: VoiceAgentSquadSpecialist;
+    sessionCount: number;
+    sessions: VoiceAgentSquadSpecialist[];
+};
+export type VoiceAgentSquadStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report: VoiceAgentSquadStatusReport;
+    updatedAt?: number;
+};
+export type VoiceAgentSquadStatusClientOptions = VoiceTraceTimelineClientOptions & {
+    sessionId?: string;
+};
+export declare const buildVoiceAgentSquadStatusReport: (timeline: VoiceTraceTimelineReport | null | undefined, options?: Pick<VoiceAgentSquadStatusClientOptions, "sessionId">) => VoiceAgentSquadStatusReport;
+export declare const createVoiceAgentSquadStatusStore: (path?: string, options?: VoiceAgentSquadStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceAgentSquadStatusSnapshot;
+    getSnapshot: () => VoiceAgentSquadStatusSnapshot;
+    refresh: () => Promise<VoiceTraceTimelineReport | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/agentSquadStatusWidget.d.ts

@@ -0,0 +1,24 @@
+import { type VoiceAgentSquadSpecialist, type VoiceAgentSquadStatusClientOptions, type VoiceAgentSquadStatusSnapshot } from './agentSquadStatus';
+export type VoiceAgentSquadStatusViewModel = {
+    current?: VoiceAgentSquadSpecialist;
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    sessionCount: number;
+    sessions: VoiceAgentSquadSpecialist[];
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceAgentSquadStatusWidgetOptions = VoiceAgentSquadStatusClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceAgentSquadStatusViewModel: (snapshot: VoiceAgentSquadStatusSnapshot, options?: VoiceAgentSquadStatusWidgetOptions) => VoiceAgentSquadStatusViewModel;
+export declare const renderVoiceAgentSquadStatusHTML: (snapshot: VoiceAgentSquadStatusSnapshot, options?: VoiceAgentSquadStatusWidgetOptions) => string;
+export declare const getVoiceAgentSquadStatusCSS: () => string;
+export declare const mountVoiceAgentSquadStatus: (element: Element | null, path?: string, options?: VoiceAgentSquadStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+};
+export declare const defineVoiceAgentSquadStatusElement: (tagName?: string, options?: VoiceAgentSquadStatusWidgetOptions) => void;

package/dist/client/bargeInMonitor.d.ts

@@ -0,0 +1,7 @@
+import type { VoiceBargeInMonitor } from '../types';
+export type VoiceBargeInMonitorOptions = {
+    fetch?: typeof fetch;
+    path?: string;
+    thresholdMs?: number;
+};
+export declare const createVoiceBargeInMonitor: (options?: VoiceBargeInMonitorOptions) => VoiceBargeInMonitor;

package/dist/client/browserMedia.d.ts

@@ -0,0 +1,8 @@
+import type { VoiceBrowserMediaReporterOptions, VoiceBrowserMediaReportPayload } from '../types';
+export type VoiceBrowserMediaReporter = {
+    close: () => void;
+    reportOnce: () => Promise<VoiceBrowserMediaReportPayload | undefined>;
+    start: () => void;
+    stop: () => void;
+};
+export declare const createVoiceBrowserMediaReporter: (options: VoiceBrowserMediaReporterOptions) => VoiceBrowserMediaReporter;

package/dist/client/campaignDialerProof.d.ts

@@ -0,0 +1,23 @@
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from '../campaignDialers';
+export type VoiceCampaignDialerProofClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    runPath?: string;
+};
+export type VoiceCampaignDialerProofSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceCampaignDialerProofReport;
+    status?: VoiceCampaignDialerProofStatus;
+    updatedAt?: number;
+};
+export declare const fetchVoiceCampaignDialerProofStatus: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofStatus>;
+export declare const runVoiceCampaignDialerProofAction: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofReport>;
+export declare const createVoiceCampaignDialerProofStore: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    getSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<VoiceCampaignDialerProofReport>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/connection.d.ts

@@ -1,5 +1,8 @@
 import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from '../types';
 type VoiceConnectionHandle = {
+    callControl: (message: Omit<VoiceClientMessage & {
+        type: 'call_control';
+    }, 'type'>) => void;
     start: (input?: {
         sessionId?: string;
         scenarioId?: string;

package/dist/client/deliveryRuntime.d.ts

@@ -0,0 +1,34 @@
+import type { VoiceDeliveryRuntimeReport } from '../deliveryRuntime';
+export type VoiceDeliveryRuntimeClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    requeueDeadLettersPath?: string;
+    tickPath?: string;
+};
+export type VoiceDeliveryRuntimeSnapshot = {
+    actionError: string | null;
+    actionStatus: 'idle' | 'running' | 'completed' | 'failed';
+    error: string | null;
+    isLoading: boolean;
+    lastAction?: VoiceDeliveryRuntimeActionResult;
+    report?: VoiceDeliveryRuntimeReport;
+    updatedAt?: number;
+};
+export type VoiceDeliveryRuntimeAction = 'tick' | 'requeue-dead-letters';
+export type VoiceDeliveryRuntimeActionResult = {
+    action: VoiceDeliveryRuntimeAction;
+    result?: unknown;
+    summary?: VoiceDeliveryRuntimeReport['summary'];
+    updatedAt: number;
+};
+export declare const fetchVoiceDeliveryRuntime: (path?: string, options?: Pick<VoiceDeliveryRuntimeClientOptions, "fetch">) => Promise<VoiceDeliveryRuntimeReport>;
+export declare const runVoiceDeliveryRuntimeAction: (action: VoiceDeliveryRuntimeAction, path?: string, options?: VoiceDeliveryRuntimeClientOptions) => Promise<VoiceDeliveryRuntimeActionResult>;
+export declare const createVoiceDeliveryRuntimeStore: (path?: string, options?: VoiceDeliveryRuntimeClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceDeliveryRuntimeSnapshot;
+    getSnapshot: () => VoiceDeliveryRuntimeSnapshot;
+    requeueDeadLetters: () => Promise<VoiceDeliveryRuntimeActionResult | undefined>;
+    refresh: () => Promise<VoiceDeliveryRuntimeReport | undefined>;
+    tick: () => Promise<VoiceDeliveryRuntimeActionResult | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/deliveryRuntimeWidget.d.ts

@@ -0,0 +1,37 @@
+import { type VoiceDeliveryRuntimeClientOptions, type VoiceDeliveryRuntimeSnapshot } from './deliveryRuntime';
+export type VoiceDeliveryRuntimeSurfaceView = {
+    deadLettered: number;
+    detail: string;
+    failed: number;
+    id: 'audit' | 'trace';
+    label: string;
+    pending: number;
+    status: 'pass' | 'warn' | 'disabled';
+    total: number;
+};
+export type VoiceDeliveryRuntimeViewModel = {
+    description: string;
+    error: string | null;
+    actionError: string | null;
+    actionStatus: VoiceDeliveryRuntimeSnapshot['actionStatus'];
+    isLoading: boolean;
+    isRunning: boolean;
+    label: string;
+    status: 'pass' | 'warn' | 'loading' | 'error';
+    surfaces: VoiceDeliveryRuntimeSurfaceView[];
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceDeliveryRuntimeWidgetOptions = VoiceDeliveryRuntimeClientOptions & {
+    description?: string;
+    includeActions?: boolean;
+    title?: string;
+};
+export declare const createVoiceDeliveryRuntimeViewModel: (snapshot: VoiceDeliveryRuntimeSnapshot, options?: VoiceDeliveryRuntimeWidgetOptions) => VoiceDeliveryRuntimeViewModel;
+export declare const renderVoiceDeliveryRuntimeHTML: (snapshot: VoiceDeliveryRuntimeSnapshot, options?: VoiceDeliveryRuntimeWidgetOptions) => string;
+export declare const getVoiceDeliveryRuntimeCSS: () => string;
+export declare const mountVoiceDeliveryRuntime: (element: Element, path?: string, options?: VoiceDeliveryRuntimeWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceDeliveryRuntimeReport | undefined>;
+};
+export declare const defineVoiceDeliveryRuntimeElement: (tagName?: string) => void;

package/dist/client/duplex.d.ts

@@ -1,3 +1,3 @@
 import type { VoiceAudioPlayer, VoiceBargeInBinding, VoiceBargeInOptions, VoiceController, VoiceDuplexController, VoiceDuplexControllerOptions } from '../types';
-export declare const bindVoiceBargeIn: <TResult = unknown>(controller: Pick<VoiceController<TResult>, "partial" | "sendAudio" | "subscribe">, player: Pick<VoiceAudioPlayer, "interrupt" | "isPlaying">, options?: VoiceBargeInOptions) => VoiceBargeInBinding;
+export declare const bindVoiceBargeIn: <TResult = unknown>(controller: Pick<VoiceController<TResult>, "partial" | "sendAudio" | "sessionId" | "subscribe">, player: Pick<VoiceAudioPlayer, "interrupt" | "isPlaying" | "lastInterruptLatencyMs" | "lastPlaybackStopLatencyMs">, options?: VoiceBargeInOptions) => VoiceBargeInBinding;
 export declare const createVoiceDuplexController: <TResult = unknown>(path: string, options?: VoiceDuplexControllerOptions) => VoiceDuplexController<TResult>;