@absolutejs/voice 0.0.22-beta.3 → 0.0.22-beta.300

package/dist/react/useVoiceAgentSquadStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceAgentSquadStatusClientOptions } from '../client/agentSquadStatus';
+export declare const useVoiceAgentSquadStatus: (path?: string, options?: VoiceAgentSquadStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    error: string | null;
+    isLoading: boolean;
+    report: import("../client").VoiceAgentSquadStatusReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceCampaignDialerProof.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceCampaignDialerProofClientOptions } from '../client/campaignDialerProof';
+export declare const useVoiceCampaignDialerProof: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    refresh: () => Promise<import("..").VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<import("..").VoiceCampaignDialerProofReport>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceCampaignDialerProofReport;
+    status?: import("..").VoiceCampaignDialerProofStatus;
+    updatedAt?: number;
+};

package/dist/react/useVoiceController.d.ts

@@ -1,15 +1,18 @@
 import type { VoiceControllerOptions } from '../types';
 export declare const useVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => {
     bindHTMX: (options: import("..").VoiceHTMXBindingOptions) => () => void;
+    callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
     close: () => void;
     endTurn: () => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
     startRecording: () => Promise<void>;
     stopRecording: () => void;
     toggleRecording: () => Promise<void>;
+    call: import("..").VoiceCallLifecycleState | null;
     sessionId: string | null;
     scenarioId: string | null;
     status: import("..").VoiceSessionStatus | "idle";
+    reconnect: import("..").VoiceReconnectClientState;
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];

package/dist/react/useVoiceDeliveryRuntime.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceDeliveryRuntimeClientOptions } from '../client/deliveryRuntime';
+export declare const useVoiceDeliveryRuntime: (path?: string, options?: VoiceDeliveryRuntimeClientOptions) => {
+    requeueDeadLetters: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    refresh: () => Promise<import("..").VoiceDeliveryRuntimeReport | undefined>;
+    tick: () => Promise<import("../client").VoiceDeliveryRuntimeActionResult | undefined>;
+    actionError: string | null;
+    actionStatus: "idle" | "running" | "completed" | "failed";
+    error: string | null;
+    isLoading: boolean;
+    lastAction?: import("../client").VoiceDeliveryRuntimeActionResult;
+    report?: import("..").VoiceDeliveryRuntimeReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceLiveOps.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceLiveOpsClientOptions } from '../client/liveOps';
+export declare const useVoiceLiveOps: (options?: VoiceLiveOpsClientOptions) => {
+    run: (input: import("..").VoiceLiveOpsActionInput) => Promise<import("..").VoiceLiveOpsActionResult | undefined>;
+    error: string | null;
+    isRunning: boolean;
+    lastResult?: import("..").VoiceLiveOpsActionResult;
+    runningAction?: import("..").VoiceLiveOpsAction;
+    updatedAt?: number;
+};

package/dist/react/useVoiceOpsActionCenter.d.ts

@@ -0,0 +1,11 @@
+import { type VoiceOpsActionCenterClientOptions } from '../client/opsActionCenter';
+export declare const useVoiceOpsActionCenter: (options?: VoiceOpsActionCenterClientOptions) => {
+    run: (actionId: string) => Promise<import("../client").VoiceOpsActionRunResult | undefined>;
+    setActions: (actions: import("../client").VoiceOpsActionDescriptor[]) => void;
+    actions: import("../client").VoiceOpsActionDescriptor[];
+    error: string | null;
+    isRunning: boolean;
+    lastResult?: import("../client").VoiceOpsActionRunResult;
+    runningActionId?: string;
+    updatedAt?: number;
+};

package/dist/react/useVoiceOpsStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceOpsStatusClientOptions } from '../client/opsStatus';
+export declare const useVoiceOpsStatus: (path?: string, options?: VoiceOpsStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceOpsStatusReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceOpsStatusReport;
+    updatedAt?: number;
+};

package/dist/react/useVoicePlatformCoverage.d.ts

@@ -0,0 +1,8 @@
+import { type VoicePlatformCoverageClientOptions } from '../client/platformCoverage';
+export declare const useVoicePlatformCoverage: (path?: string, options?: VoicePlatformCoverageClientOptions) => {
+    refresh: () => Promise<import("..").VoicePlatformCoverageSummary | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoicePlatformCoverageSummary;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProofTrends.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProofTrendsClientOptions } from '../client/proofTrends';
+export declare const useVoiceProofTrends: (path?: string, options?: VoiceProofTrendsClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProofTrendReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProofTrendReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderCapabilities.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProviderCapabilitiesClientOptions } from '../client/providerCapabilities';
+export declare const useVoiceProviderCapabilities: <TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProviderCapabilityReport<TProvider> | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProviderCapabilityReport<TProvider> | undefined;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderContracts.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProviderContractsClientOptions } from '../client/providerContracts';
+export declare const useVoiceProviderContracts: <TProvider extends string = string>(path?: string, options?: VoiceProviderContractsClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProviderContractMatrixReport<TProvider> | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProviderContractMatrixReport<TProvider> | undefined;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderSimulationControls.d.ts

@@ -0,0 +1,10 @@
+import { type VoiceProviderSimulationControlsOptions } from '../client/providerSimulationControls';
+export declare const useVoiceProviderSimulationControls: <TProvider extends string = string>(options: VoiceProviderSimulationControlsOptions<TProvider>) => {
+    run: (provider: TProvider, mode: import("../testing").VoiceIOProviderFailureSimulationMode) => Promise<import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+    error: string | null;
+    isRunning: boolean;
+    lastResult: import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null;
+    mode: import("../testing").VoiceIOProviderFailureSimulationMode | null;
+    provider: TProvider | null;
+    updatedAt?: number;
+};

package/dist/react/useVoiceProviderStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+export declare const useVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProviderHealthSummary<TProvider>[]>;
+    error: string | null;
+    isLoading: boolean;
+    providers: import("..").VoiceProviderHealthSummary<TProvider>[];
+    updatedAt?: number;
+};

package/dist/react/useVoiceReadinessFailures.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceReadinessFailuresClientOptions } from '../client/readinessFailures';
+export declare const useVoiceReadinessFailures: (path?: string, options?: VoiceReadinessFailuresClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProductionReadinessReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceProductionReadinessReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceRoutingStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceRoutingStatusClientOptions } from '../client/routingStatus';
+export declare const useVoiceRoutingStatus: (path?: string, options?: VoiceRoutingStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+    decision: import("..").VoiceRoutingDecisionSummary | null;
+    error: string | null;
+    isLoading: boolean;
+    updatedAt?: number;
+};

package/dist/react/useVoiceStream.d.ts

@@ -1,11 +1,14 @@
 import type { VoiceConnectionOptions } from '../types';
 export declare const useVoiceStream: <TResult = unknown>(path: string, options?: VoiceConnectionOptions) => {
+    callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
     close: () => void;
     endTurn: () => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    call: import("..").VoiceCallLifecycleState | null;
     sessionId: string | null;
     scenarioId: string | null;
     status: import("..").VoiceSessionStatus | "idle";
+    reconnect: import("..").VoiceReconnectClientState;
     partial: string;
     turns: import("..").VoiceTurnRecord<TResult>[];
     assistantTexts: string[];

package/dist/react/useVoiceTraceTimeline.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceTraceTimelineClientOptions } from '../client/traceTimeline';
+export declare const useVoiceTraceTimeline: (path?: string, options?: VoiceTraceTimelineClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTraceTimelineReport | null>;
+    error: string | null;
+    isLoading: boolean;
+    report: import("..").VoiceTraceTimelineReport | null;
+    updatedAt?: number;
+};

package/dist/react/useVoiceTurnLatency.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceTurnLatencyClientOptions } from '../client/turnLatency';
+export declare const useVoiceTurnLatency: (path?: string, options?: VoiceTurnLatencyClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTurnLatencyReport | undefined>;
+    runProof: () => Promise<import("..").VoiceTurnLatencyReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceTurnLatencyReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceTurnQuality.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceTurnQualityClientOptions } from '../client/turnQuality';
+export declare const useVoiceTurnQuality: (path?: string, options?: VoiceTurnQualityClientOptions) => {
+    refresh: () => Promise<import("..").VoiceTurnQualityReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceTurnQualityReport;
+    updatedAt?: number;
+};

package/dist/react/useVoiceWorkflowStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+export declare const useVoiceWorkflowStatus: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceScenarioEvalReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceScenarioEvalReport;
+    updatedAt?: number;
+};

package/dist/readinessProfiles.d.ts

@@ -0,0 +1,38 @@
+import type { VoiceProductionReadinessAuditOptions, VoiceProductionReadinessAuditDeliveryOptions, VoiceProductionReadinessOpsActionHistoryOptions, VoiceProductionReadinessRoutesOptions, VoiceProductionReadinessTraceDeliveryOptions } from './productionReadiness';
+export type VoiceReadinessProfileName = 'meeting-recorder' | 'ops-heavy' | 'phone-agent';
+export type VoiceReadinessProfileOptions = {
+    audit?: VoiceProductionReadinessAuditOptions;
+    auditDeliveries?: VoiceProductionReadinessAuditDeliveryOptions;
+    bargeInReports?: VoiceProductionReadinessRoutesOptions['bargeInReports'];
+    campaignReadiness?: VoiceProductionReadinessRoutesOptions['campaignReadiness'];
+    carriers?: VoiceProductionReadinessRoutesOptions['carriers'];
+    deliveryRuntime?: VoiceProductionReadinessRoutesOptions['deliveryRuntime'];
+    explain?: boolean;
+    gate?: VoiceProductionReadinessRoutesOptions['gate'];
+    links?: VoiceProductionReadinessRoutesOptions['links'];
+    observabilityExportDeliveryHistory?: VoiceProductionReadinessRoutesOptions['observabilityExportDeliveryHistory'];
+    opsActionHistory?: VoiceProductionReadinessOpsActionHistoryOptions;
+    phoneAgentSmokes?: VoiceProductionReadinessRoutesOptions['phoneAgentSmokes'];
+    proofSources?: VoiceProductionReadinessRoutesOptions['proofSources'];
+    providerRoutingContracts?: VoiceProductionReadinessRoutesOptions['providerRoutingContracts'];
+    reconnectContracts?: VoiceProductionReadinessRoutesOptions['reconnectContracts'];
+    telephonyWebhookSecurity?: VoiceProductionReadinessRoutesOptions['telephonyWebhookSecurity'];
+    traceDeliveries?: VoiceProductionReadinessTraceDeliveryOptions;
+};
+export type VoiceReadinessProfileRoutesOptions = Partial<Omit<VoiceProductionReadinessRoutesOptions, 'store'>>;
+export type VoiceReadinessProfileRecommendationScore = {
+    configured: string[];
+    confidence: number;
+    missing: string[];
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+};
+export type VoiceReadinessProfileRecommendation = {
+    confidence: number;
+    missing: string[];
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+    scores: VoiceReadinessProfileRecommendationScore[];
+};
+export declare const createVoiceReadinessProfile: (profile: VoiceReadinessProfileName, options?: VoiceReadinessProfileOptions) => VoiceReadinessProfileRoutesOptions;
+export declare const recommendVoiceReadinessProfile: (options: VoiceReadinessProfileOptions) => VoiceReadinessProfileRecommendation;

package/dist/reconnectContract.d.ts

@@ -0,0 +1,88 @@
+import { Elysia } from 'elysia';
+import type { VoiceReconnectClientState } from './types';
+import type { StoredVoiceTraceEvent } from './trace';
+export type VoiceReconnectContractSnapshot = {
+    at: number;
+    reconnect: VoiceReconnectClientState;
+    turnIds?: readonly string[];
+};
+export type VoiceReconnectContractIssue = {
+    code: string;
+    message: string;
+    severity: 'error' | 'warning';
+};
+export type VoiceReconnectContractReport = {
+    checkedAt: number;
+    issues: VoiceReconnectContractIssue[];
+    pass: boolean;
+    resumeLatencyP95Ms?: number;
+    snapshotCount: number;
+    statuses: VoiceReconnectClientState['status'][];
+    summary: {
+        attempts: number;
+        maxAttempts: number;
+        reconnected: boolean;
+        resumed: boolean;
+        exhausted: boolean;
+        duplicateTurnIds: string[];
+    };
+};
+export type VoiceReconnectContractOptions = {
+    requireReconnect?: boolean;
+    requireResume?: boolean;
+    requireReplayProtection?: boolean;
+    snapshots: readonly VoiceReconnectContractSnapshot[];
+};
+export type VoiceReconnectContractRoutesOptions = Omit<VoiceReconnectContractOptions, 'snapshots'> & {
+    getSnapshots: () => readonly VoiceReconnectContractSnapshot[] | Promise<readonly VoiceReconnectContractSnapshot[]>;
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceReconnectContractReport) => string | Promise<string>;
+};
+export declare const summarizeVoiceReconnectContractSnapshots: (events: readonly StoredVoiceTraceEvent[], options?: {
+    sessionId?: string;
+}) => VoiceReconnectContractSnapshot[];
+export declare const runVoiceReconnectContract: (options: VoiceReconnectContractOptions) => VoiceReconnectContractReport;
+export declare const renderVoiceReconnectContractHTML: (report: VoiceReconnectContractReport) => string;
+export declare const createVoiceReconnectContractRoutes: (options: VoiceReconnectContractRoutesOptions) => 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;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/resilienceRoutes.d.ts

@@ -0,0 +1,143 @@
+import { Elysia } from 'elysia';
+import { type VoiceProviderHealthSummary } from './providerHealth';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import type { VoiceIOProviderFailureSimulationMode, VoiceIOProviderFailureSimulationResult } from './testing/ioProviderSimulator';
+export type VoiceRoutingEventKind = 'llm' | 'stt' | 'tts';
+export type VoiceRoutingEvent = {
+    at: number;
+    attempt?: number;
+    elapsedMs?: number;
+    error?: string;
+    fallbackProvider?: string;
+    kind: VoiceRoutingEventKind;
+    latencyBudgetMs?: number;
+    operation?: string;
+    provider?: string;
+    routing?: string;
+    scenarioId?: string;
+    selectedProvider?: string;
+    sessionId: string;
+    status?: string;
+    suppressionRemainingMs?: number;
+    timedOut: boolean;
+    turnId?: string;
+};
+export type VoiceRoutingDecisionSummary = VoiceRoutingEvent;
+export type VoiceRoutingDecisionSummaryOptions = {
+    kind?: VoiceRoutingEventKind;
+    limit?: number;
+    sessionId?: string;
+    store: VoiceTraceEventStore;
+};
+export type VoiceRoutingKindSummary = {
+    errorCount: number;
+    fallbackCount: number;
+    latest?: VoiceRoutingEvent;
+    providers: string[];
+    runCount: number;
+    timeoutCount: number;
+};
+export type VoiceRoutingSessionSummary = {
+    errorCount: number;
+    eventCount: number;
+    fallbackCount: number;
+    kinds: Record<VoiceRoutingEventKind, VoiceRoutingKindSummary>;
+    lastEventAt: number;
+    sessionId: string;
+    startedAt: number;
+    status: 'healthy' | 'fallback' | 'degraded';
+    timeoutCount: number;
+};
+export type VoiceRoutingSessionSummaryOptions = {
+    limit?: number;
+    sessionId?: string;
+};
+export type VoiceResilienceLink = {
+    href: string;
+    label: string;
+};
+export type VoiceResilienceSimulationProvider<TProvider extends string = string> = {
+    configured?: boolean;
+    provider: TProvider;
+};
+export type VoiceResilienceIOSimulator<TProvider extends string = string> = {
+    failureProviders?: readonly TProvider[];
+    fallbackRequiredProvider?: TProvider;
+    fallbackRequiredMessage?: string;
+    failureMessage?: string;
+    label?: string;
+    pathPrefix?: string;
+    providers: readonly VoiceResilienceSimulationProvider<TProvider>[];
+    recoveryMessage?: string;
+    run: (provider: TProvider, mode: VoiceIOProviderFailureSimulationMode) => Promise<VoiceIOProviderFailureSimulationResult<TProvider>>;
+};
+export type VoiceResiliencePageData = {
+    links?: readonly VoiceResilienceLink[];
+    llmProviderHealth: VoiceProviderHealthSummary<string>[];
+    routingEvents: VoiceRoutingEvent[];
+    routingSessions: VoiceRoutingSessionSummary[];
+    sttProviderHealth: VoiceProviderHealthSummary<string>[];
+    sttSimulation?: VoiceResilienceIOSimulator<string>;
+    title?: string;
+    ttsProviderHealth: VoiceProviderHealthSummary<string>[];
+    ttsSimulation?: VoiceResilienceIOSimulator<string>;
+};
+export type VoiceResilienceRoutesOptions = {
+    headers?: HeadersInit;
+    links?: readonly VoiceResilienceLink[];
+    llmProviders?: readonly string[];
+    name?: string;
+    path?: string;
+    render?: (input: VoiceResiliencePageData) => string | Promise<string>;
+    sttProviders?: readonly string[];
+    sttSimulation?: VoiceResilienceIOSimulator<string>;
+    store: VoiceTraceEventStore;
+    title?: string;
+    ttsProviders?: readonly string[];
+    ttsSimulation?: VoiceResilienceIOSimulator<string>;
+};
+export declare const listVoiceRoutingEvents: (events: StoredVoiceTraceEvent[]) => VoiceRoutingEvent[];
+export declare const summarizeVoiceRoutingDecision: (events: StoredVoiceTraceEvent[], options?: Omit<VoiceRoutingDecisionSummaryOptions, "store">) => VoiceRoutingDecisionSummary | null;
+export declare const summarizeVoiceRoutingSessions: (events: StoredVoiceTraceEvent[] | VoiceRoutingEvent[], options?: VoiceRoutingSessionSummaryOptions) => VoiceRoutingSessionSummary[];
+export declare const createVoiceRoutingDecisionSummary: (options: VoiceRoutingDecisionSummaryOptions) => Promise<VoiceRoutingDecisionSummary | null>;
+export declare const renderVoiceResilienceHTML: (input: VoiceResiliencePageData) => string;
+export declare const createVoiceResilienceRoutes: (options: VoiceResilienceRoutesOptions) => 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;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;