@absolutejs/voice 0.0.22-beta.6 → 0.0.22-beta.61

package/dist/modelAdapters.d.ts

@@ -29,11 +29,86 @@ export type GeminiVoiceAssistantModelOptions = {
     baseUrl?: string;
     fetch?: typeof fetch;
     maxOutputTokens?: number;
+    maxRetries?: number;
     model?: string;
     onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
     temperature?: number;
 };
+export type VoiceProviderRouterEvent<TProvider extends string = string> = {
+    at: number;
+    attempt: number;
+    elapsedMs: number;
+    error?: string;
+    fallbackProvider?: TProvider;
+    latencyBudgetMs?: number;
+    provider: TProvider;
+    providerHealth?: VoiceProviderRouterProviderHealth<TProvider>;
+    rateLimited?: boolean;
+    recovered?: boolean;
+    selectedProvider: TProvider;
+    suppressionRemainingMs?: number;
+    suppressedUntil?: number;
+    status: 'error' | 'fallback' | 'success';
+    timedOut?: boolean;
+};
+export type VoiceProviderRouterFallbackMode = 'never' | 'provider-error' | 'rate-limit';
+export type VoiceProviderRouterStrategy = 'balanced' | 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected' | 'quality-first';
+export type VoiceProviderRouterPolicyPreset = 'balanced' | 'cost-cap' | 'cost-first' | 'latency-first' | 'quality-first';
+export type VoiceProviderRouterPolicyWeights = {
+    cost?: number;
+    latencyMs?: number;
+    priority?: number;
+    quality?: number;
+};
+export type VoiceProviderRouterPolicy<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = VoiceProviderRouterStrategy | VoiceProviderRouterPolicyPreset | {
+    allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    fallbackMode?: VoiceProviderRouterFallbackMode;
+    maxCost?: number;
+    maxLatencyMs?: number;
+    minQuality?: number;
+    scoreProvider?: (provider: TProvider, profile: VoiceProviderRouterProviderProfile | undefined) => number;
+    strategy?: VoiceProviderRouterStrategy;
+    weights?: VoiceProviderRouterPolicyWeights;
+};
+export type VoiceProviderRouterProviderProfile = {
+    cost?: number;
+    latencyMs?: number;
+    priority?: number;
+    quality?: number;
+    timeoutMs?: number;
+};
+export declare const resolveVoiceProviderRoutingPolicyPreset: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string>(preset: VoiceProviderRouterPolicyPreset, options?: Omit<Extract<VoiceProviderRouterPolicy<TContext, TSession, TProvider>, Record<string, unknown>>, "strategy">) => Extract<VoiceProviderRouterPolicy<TContext, TSession, TProvider>, Record<string, unknown>>;
+export type VoiceProviderRouterHealthOptions = {
+    cooldownMs?: number;
+    failureThreshold?: number;
+    now?: () => number;
+    rateLimitCooldownMs?: number;
+};
+export type VoiceProviderRouterProviderHealth<TProvider extends string = string> = {
+    consecutiveFailures: number;
+    lastFailureAt?: number;
+    lastRateLimitedAt?: number;
+    provider: TProvider;
+    status: 'healthy' | 'suppressed';
+    suppressedUntil?: number;
+};
+export type VoiceProviderRouterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TProvider extends string = string> = {
+    allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    fallback?: TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    fallbackMode?: VoiceProviderRouterFallbackMode;
+    isProviderError?: (error: unknown, provider: TProvider) => boolean;
+    isRateLimitError?: (error: unknown, provider: TProvider) => boolean;
+    isTimeoutError?: (error: unknown, provider: TProvider) => boolean;
+    onProviderEvent?: (event: VoiceProviderRouterEvent<TProvider>, input: VoiceAgentModelInput<TContext, TSession>) => Promise<void> | void;
+    policy?: VoiceProviderRouterPolicy<TContext, TSession, TProvider>;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
+    timeoutMs?: number;
+    providers: Partial<Record<TProvider, VoiceAgentModel<TContext, TSession, TResult>>>;
+    selectProvider?: (input: VoiceAgentModelInput<TContext, TSession>) => TProvider | undefined | Promise<TProvider | undefined>;
+};
 export declare const createJSONVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceJSONAssistantModelOptions<TContext, TSession, TResult>) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createVoiceProviderRouter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TProvider extends string = string>(options: VoiceProviderRouterOptions<TContext, TSession, TResult, TProvider>) => VoiceAgentModel<TContext, TSession, TResult>;
 export declare const createOpenAIVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: OpenAIVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;
 export declare const createAnthropicVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: AnthropicVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;
 export declare const createGeminiVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: GeminiVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;

package/dist/opsConsoleRoutes.d.ts

@@ -0,0 +1,77 @@
+import { Elysia } from 'elysia';
+import { type VoiceQualityReport } from './qualityRoutes';
+import { type VoiceRoutingEvent } from './resilienceRoutes';
+import { type VoiceSessionListItem } from './sessionReplay';
+import { summarizeVoiceTrace, type VoiceTraceEventStore } from './trace';
+export type VoiceOpsConsoleLink = {
+    description?: string;
+    href: string;
+    label: string;
+    statusHref?: string;
+};
+export type VoiceOpsConsoleReport = {
+    checkedAt: number;
+    eventCount: number;
+    handoffs: {
+        failed: number;
+        total: number;
+    };
+    links: VoiceOpsConsoleLink[];
+    providers: {
+        degraded: number;
+        healthy: number;
+        total: number;
+    };
+    quality: VoiceQualityReport;
+    recentRoutingEvents: VoiceRoutingEvent[];
+    recentSessions: VoiceSessionListItem[];
+    sessions: {
+        failed: number;
+        healthy: number;
+        total: number;
+    };
+    trace: ReturnType<typeof summarizeVoiceTrace>;
+};
+export type VoiceOpsConsoleRoutesOptions = {
+    headers?: HeadersInit;
+    links?: VoiceOpsConsoleLink[];
+    llmProviders?: readonly string[];
+    name?: string;
+    path?: string;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    title?: string;
+    ttsProviders?: readonly string[];
+};
+export declare const buildVoiceOpsConsoleReport: (options: VoiceOpsConsoleRoutesOptions) => Promise<VoiceOpsConsoleReport>;
+export declare const renderVoiceOpsConsoleHTML: (report: VoiceOpsConsoleReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOpsConsoleRoutes: (options: VoiceOpsConsoleRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/opsWebhook.d.ts

@@ -0,0 +1,126 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceIntegrationEvent, VoiceIntegrationEventType } from './ops';
+import type { VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink } from './opsSinks';
+type MaybePromise<T> = T | Promise<T>;
+export type VoiceOpsWebhookLinkResolver = string | ((input: {
+    event: StoredVoiceIntegrationEvent;
+}) => MaybePromise<string | undefined>);
+export type VoiceOpsWebhookEntity = {
+    disposition?: string;
+    outcome?: string;
+    priority?: string;
+    queue?: string;
+    reviewId?: string;
+    scenarioId?: string;
+    sessionId?: string;
+    status?: string;
+    target?: string;
+    taskId?: string;
+};
+export type VoiceOpsWebhookEnvelope = {
+    entity: VoiceOpsWebhookEntity;
+    event: {
+        createdAt: number;
+        id: string;
+        payload: Record<string, unknown>;
+        type: VoiceIntegrationEventType;
+    };
+    links?: {
+        event?: string;
+        replay?: string;
+        review?: string;
+        task?: string;
+    };
+    schemaVersion: 1;
+    source: 'absolutejs-voice';
+};
+export type VoiceOpsWebhookSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions<VoiceOpsWebhookEnvelope>, 'body'> & {
+    baseUrl?: string;
+    eventHref?: VoiceOpsWebhookLinkResolver;
+    replayHref?: VoiceOpsWebhookLinkResolver;
+    reviewHref?: VoiceOpsWebhookLinkResolver;
+    taskHref?: VoiceOpsWebhookLinkResolver;
+};
+export type VoiceOpsWebhookVerificationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'invalid-signature' | 'missing-secret' | 'missing-signature' | 'missing-timestamp' | 'stale-timestamp' | 'unsupported-algorithm';
+};
+export type VoiceOpsWebhookReceiverRoutesOptions = {
+    onEnvelope?: (input: {
+        envelope: VoiceOpsWebhookEnvelope;
+        request: Request;
+    }) => MaybePromise<void>;
+    path?: string;
+    signingSecret?: string;
+    toleranceMs?: number;
+};
+export declare const createVoiceOpsWebhookEnvelope: (input: {
+    baseUrl?: string;
+    event: StoredVoiceIntegrationEvent;
+    eventHref?: VoiceOpsWebhookLinkResolver;
+    replayHref?: VoiceOpsWebhookLinkResolver;
+    reviewHref?: VoiceOpsWebhookLinkResolver;
+    taskHref?: VoiceOpsWebhookLinkResolver;
+}) => Promise<VoiceOpsWebhookEnvelope>;
+export declare const createVoiceOpsWebhookSink: (options: VoiceOpsWebhookSinkOptions) => VoiceIntegrationSink;
+export declare const verifyVoiceOpsWebhookSignature: (input: {
+    body: string;
+    now?: number;
+    secret?: string;
+    signature?: string | null;
+    timestamp?: string | null;
+    toleranceMs?: number;
+}) => Promise<VoiceOpsWebhookVerificationResult>;
+export declare const createVoiceOpsWebhookReceiverRoutes: (options?: VoiceOpsWebhookReceiverRoutesOptions) => 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: {
+                    ok: boolean;
+                    reason: "invalid-signature" | "missing-secret" | "missing-signature" | "missing-timestamp" | "stale-timestamp" | "unsupported-algorithm";
+                    eventId?: undefined;
+                    type?: undefined;
+                } | {
+                    eventId: string;
+                    ok: boolean;
+                    type: VoiceIntegrationEventType;
+                    reason?: undefined;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/providerAdapters.d.ts

@@ -0,0 +1,48 @@
+import type { STTAdapter, STTAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from './types';
+import type { VoiceProviderRouterHealthOptions, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceProviderRouterPolicyPreset, VoiceProviderRouterPolicyWeights, VoiceProviderRouterStrategy } from './modelAdapters';
+type MaybePromise<T> = T | Promise<T>;
+type VoiceIOProviderKind = 'stt' | 'tts';
+type VoiceIOProviderStatus = 'error' | 'fallback' | 'success';
+export type VoiceIOProviderRouterEvent<TProvider extends string = string> = {
+    at: number;
+    attempt: number;
+    elapsedMs: number;
+    error?: string;
+    fallbackProvider?: TProvider;
+    kind: VoiceIOProviderKind;
+    latencyBudgetMs?: number;
+    operation: 'open' | 'send';
+    provider: TProvider;
+    providerHealth?: VoiceProviderRouterProviderHealth<TProvider>;
+    selectedProvider: TProvider;
+    status: VoiceIOProviderStatus;
+    suppressionRemainingMs?: number;
+    suppressedUntil?: number;
+    timedOut?: boolean;
+};
+export type VoiceIOProviderRouterPolicyConfig<TOpenOptions = unknown, TProvider extends string = string> = {
+    allowProviders?: readonly TProvider[] | ((input: TOpenOptions) => MaybePromise<readonly TProvider[]>);
+    maxCost?: number;
+    maxLatencyMs?: number;
+    minQuality?: number;
+    scoreProvider?: (provider: TProvider, profile: VoiceProviderRouterProviderProfile | undefined) => number;
+    strategy?: VoiceProviderRouterStrategy;
+    weights?: VoiceProviderRouterPolicyWeights;
+};
+export type VoiceIOProviderRouterPolicy<TOpenOptions = unknown, TProvider extends string = string> = VoiceProviderRouterStrategy | VoiceProviderRouterPolicyPreset | VoiceIOProviderRouterPolicyConfig<TOpenOptions, TProvider>;
+export type VoiceIOProviderRouterOptions<TProvider extends string, TAdapter, TOpenOptions> = {
+    adapters: Partial<Record<TProvider, TAdapter>>;
+    fallback?: readonly TProvider[] | ((input: TOpenOptions) => MaybePromise<readonly TProvider[]>);
+    isProviderError?: (error: unknown, provider: TProvider) => boolean;
+    onProviderEvent?: (event: VoiceIOProviderRouterEvent<TProvider>, input: TOpenOptions) => Promise<void> | void;
+    policy?: VoiceIOProviderRouterPolicy<TOpenOptions, TProvider>;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
+    selectProvider?: (input: TOpenOptions) => MaybePromise<TProvider | undefined>;
+    timeoutMs?: number;
+};
+export type VoiceSTTProviderRouterOptions<TProvider extends string = string, TOptions extends STTAdapterOpenOptions = STTAdapterOpenOptions> = VoiceIOProviderRouterOptions<TProvider, STTAdapter<TOptions>, TOptions>;
+export type VoiceTTSProviderRouterOptions<TProvider extends string = string, TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions> = VoiceIOProviderRouterOptions<TProvider, TTSAdapter<TOptions>, TOptions>;
+export declare const createVoiceSTTProviderRouter: <TProvider extends string = string, TOptions extends STTAdapterOpenOptions = STTAdapterOpenOptions>(options: VoiceSTTProviderRouterOptions<TProvider, TOptions>) => STTAdapter<TOptions>;
+export declare const createVoiceTTSProviderRouter: <TProvider extends string = string, TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions>(options: VoiceTTSProviderRouterOptions<TProvider, TOptions>) => TTSAdapter<TOptions>;
+export {};

package/dist/providerHealth.d.ts

@@ -0,0 +1,79 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceProviderHealthStatus = 'healthy' | 'idle' | 'rate-limited' | 'degraded' | 'recoverable' | 'suppressed';
+export type VoiceProviderHealthSummary<TProvider extends string = string> = {
+    averageElapsedMs?: number;
+    errorCount: number;
+    fallbackCount: number;
+    lastError?: string;
+    lastErrorAt?: number;
+    lastSuccessAt?: number;
+    provider: TProvider;
+    rateLimited: boolean;
+    recommended: boolean;
+    runCount: number;
+    status: VoiceProviderHealthStatus;
+    suppressionRemainingMs?: number;
+    suppressedUntil?: number;
+    timeoutCount: number;
+};
+export type VoiceProviderHealthSummaryOptions<TProvider extends string = string> = {
+    events?: StoredVoiceTraceEvent[];
+    now?: number;
+    providers?: readonly TProvider[];
+    store?: VoiceTraceEventStore;
+};
+export type VoiceProviderHealthHandlerOptions<TProvider extends string = string> = VoiceProviderHealthSummaryOptions<TProvider>;
+export type VoiceProviderHealthHTMLHandlerOptions<TProvider extends string = string> = VoiceProviderHealthHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (providers: VoiceProviderHealthSummary<TProvider>[]) => string | Promise<string>;
+};
+export type VoiceProviderHealthRoutesOptions<TProvider extends string = string> = VoiceProviderHealthHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceProviderHealth: <TProvider extends string = string>(input: StoredVoiceTraceEvent[] | VoiceProviderHealthSummaryOptions<TProvider>) => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+export declare const renderVoiceProviderHealthHTML: (providers: VoiceProviderHealthSummary[]) => string;
+export declare const createVoiceProviderHealthJSONHandler: <TProvider extends string = string>(options: VoiceProviderHealthHandlerOptions<TProvider>) => () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+export declare const createVoiceProviderHealthHTMLHandler: <TProvider extends string = string>(options: VoiceProviderHealthHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceProviderHealthRoutes: <TProvider extends string = string>(options: VoiceProviderHealthRoutesOptions<TProvider>) => 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: VoiceProviderHealthSummary<TProvider>[];
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/qualityRoutes.d.ts

@@ -0,0 +1,76 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceTraceEvent, type VoiceTraceEventStore } from './trace';
+export type VoiceQualityStatus = 'pass' | 'fail';
+export type VoiceQualityThresholds = {
+    maxDuplicateTurnRate?: number;
+    maxEmptyTurnRate?: number;
+    maxHandoffFailureRate?: number;
+    maxMissingAssistantReplyRate?: number;
+    maxProviderAverageLatencyMs?: number;
+    maxProviderErrorRate?: number;
+    maxProviderFallbackRate?: number;
+    maxProviderTimeoutRate?: number;
+};
+export type VoiceQualityMetric = {
+    actual: number;
+    label: string;
+    pass: boolean;
+    threshold: number;
+    unit: 'count' | 'ms' | 'rate';
+};
+export type VoiceQualityReport = {
+    checkedAt: number;
+    eventCount: number;
+    metrics: Record<string, VoiceQualityMetric>;
+    status: VoiceQualityStatus;
+    thresholds: Required<VoiceQualityThresholds>;
+};
+export type VoiceQualityLink = {
+    href: string;
+    label: string;
+};
+export type VoiceQualityRoutesOptions = {
+    events?: StoredVoiceTraceEvent[];
+    headers?: HeadersInit;
+    links?: VoiceQualityLink[];
+    name?: string;
+    path?: string;
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+};
+export declare const evaluateVoiceQuality: (input: {
+    events?: StoredVoiceTraceEvent[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+}) => Promise<VoiceQualityReport>;
+export declare const renderVoiceQualityHTML: (report: VoiceQualityReport, options?: {
+    links?: VoiceQualityLink[];
+}) => string;
+export declare const createVoiceQualityRoutes: (options: VoiceQualityRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/queue.d.ts

@@ -1,6 +1,7 @@
 import type { RedisClient } from 'bun';
 import type { VoiceIntegrationSink } from './opsSinks';
 import type { VoiceTraceRedactionConfig, VoiceTraceSink, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryStore, VoiceTraceSinkDeliveryQueueStatus } from './trace';
+import type { StoredVoiceHandoffDelivery, VoiceHandoffAdapter, VoiceHandoffDeliveryQueueStatus, VoiceHandoffDeliveryStore, VoiceSessionHandle, VoiceSessionRecord } from './types';
 import type { VoiceOpsTaskPriority, StoredVoiceOpsTask, StoredVoiceIntegrationEvent, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventStore, VoiceIntegrationWebhookConfig, VoiceOpsTaskKind, VoiceOpsTaskStatus, VoiceOpsTaskStore } from './ops';
 export type VoiceOpsTaskLease = {
     expiresAt: number;
@@ -159,6 +160,50 @@ export type VoiceTraceSinkDeliveryQueueSummary = {
     skipped: number;
     total: number;
 };
+export type VoiceHandoffDeliveryWorkerOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TDelivery extends StoredVoiceHandoffDelivery<TContext, TSession, TResult> = StoredVoiceHandoffDelivery<TContext, TSession, TResult>> = {
+    adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
+    api: VoiceSessionHandle<TContext, TSession, TResult>;
+    deadLetters?: VoiceHandoffDeliveryStore<TDelivery>;
+    deliveries: VoiceHandoffDeliveryStore<TDelivery>;
+    failMode?: 'record' | 'throw';
+    idempotency?: VoiceIdempotencyStore;
+    idempotencyTtlSeconds?: number;
+    leaseMs?: number;
+    leases: VoiceRedisTaskLeaseCoordinator;
+    maxFailures?: number;
+    onDeadLetter?: (delivery: TDelivery) => Promise<void> | void;
+    statuses?: VoiceHandoffDeliveryQueueStatus[];
+    workerId: string;
+};
+export type VoiceHandoffDeliveryWorkerResult = {
+    alreadyProcessed: number;
+    attempted: number;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    skipped: number;
+};
+export type VoiceHandoffDeliveryWorkerLoopOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TDelivery extends StoredVoiceHandoffDelivery<TContext, TSession, TResult> = StoredVoiceHandoffDelivery<TContext, TSession, TResult>> = {
+    onError?: (error: unknown) => Promise<void> | void;
+    pollIntervalMs?: number;
+    worker: ReturnType<typeof createVoiceHandoffDeliveryWorker<TContext, TSession, TResult, TDelivery>>;
+};
+export type VoiceHandoffDeliveryWorkerLoop = {
+    isRunning: () => boolean;
+    start: () => void;
+    stop: () => void;
+    tick: () => Promise<VoiceHandoffDeliveryWorkerResult>;
+};
+export type VoiceHandoffDeliveryQueueSummary = {
+    byAction: Array<[StoredVoiceHandoffDelivery['action'], number]>;
+    deadLettered: number;
+    delivered: number;
+    failed: number;
+    pending: number;
+    retryEligible: number;
+    skipped: number;
+    total: number;
+};
 export type VoiceOpsTaskWorkerOptions<TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask> = {
     leaseMs?: number;
     leases: VoiceRedisTaskLeaseCoordinator;
@@ -252,6 +297,9 @@ export declare const summarizeVoiceIntegrationEvents: <TEvent extends StoredVoic
 export declare const summarizeVoiceTraceSinkDeliveries: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(deliveries: TDelivery[], input?: {
     deadLetters?: VoiceTraceSinkDeliveryStore<TDelivery>;
 }) => Promise<VoiceTraceSinkDeliveryQueueSummary> | VoiceTraceSinkDeliveryQueueSummary;
+export declare const summarizeVoiceHandoffDeliveries: <TDelivery extends StoredVoiceHandoffDelivery = StoredVoiceHandoffDelivery>(deliveries: TDelivery[], input?: {
+    deadLetters?: VoiceHandoffDeliveryStore<TDelivery>;
+}) => Promise<VoiceHandoffDeliveryQueueSummary> | VoiceHandoffDeliveryQueueSummary;
 export declare const summarizeVoiceOpsTaskQueue: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(tasks: TTask[], input?: {
     deadLetters?: VoiceOpsTaskStore<TTask>;
 }) => Promise<VoiceOpsTaskQueueSummary> | VoiceOpsTaskQueueSummary;
@@ -269,6 +317,10 @@ export declare const createVoiceTraceSinkDeliveryWorker: <TDelivery extends Voic
     drain: () => Promise<VoiceTraceSinkDeliveryWorkerResult>;
 };
 export declare const createVoiceTraceSinkDeliveryWorkerLoop: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceTraceSinkDeliveryWorkerLoopOptions<TDelivery>) => VoiceTraceSinkDeliveryWorkerLoop;
+export declare const createVoiceHandoffDeliveryWorker: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TDelivery extends StoredVoiceHandoffDelivery<TContext, TSession, TResult> = StoredVoiceHandoffDelivery<TContext, TSession, TResult>>(options: VoiceHandoffDeliveryWorkerOptions<TContext, TSession, TResult, TDelivery>) => {
+    drain: () => Promise<VoiceHandoffDeliveryWorkerResult>;
+};
+export declare const createVoiceHandoffDeliveryWorkerLoop: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TDelivery extends StoredVoiceHandoffDelivery<TContext, TSession, TResult> = StoredVoiceHandoffDelivery<TContext, TSession, TResult>>(options: VoiceHandoffDeliveryWorkerLoopOptions<TContext, TSession, TResult, TDelivery>) => VoiceHandoffDeliveryWorkerLoop;
 export declare const createVoiceOpsTaskWorker: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskWorkerOptions<TTask>) => VoiceOpsTaskWorker<TTask>;
 export declare const createVoiceOpsTaskProcessorWorker: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskProcessorWorkerOptions<TTask>) => {
     drain: () => Promise<VoiceOpsTaskProcessorWorkerResult>;

package/dist/react/VoiceOpsStatus.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceOpsStatusWidgetOptions } from '../client/opsStatusWidget';
+export type VoiceOpsStatusProps = VoiceOpsStatusWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceOpsStatus: ({ className, path, ...options }: VoiceOpsStatusProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProviderSimulationControls.d.ts

@@ -0,0 +1,5 @@
+import type { VoiceProviderSimulationControlsOptions } from '../client/providerSimulationControls';
+export type VoiceProviderSimulationControlsProps<TProvider extends string = string> = VoiceProviderSimulationControlsOptions<TProvider> & {
+    className?: string;
+};
+export declare const VoiceProviderSimulationControls: <TProvider extends string = string>({ className, ...options }: VoiceProviderSimulationControlsProps<TProvider>) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceProviderStatus.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceProviderStatusWidgetOptions } from '../client/providerStatusWidget';
+export type VoiceProviderStatusProps = VoiceProviderStatusWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceProviderStatus: ({ className, path, ...options }: VoiceProviderStatusProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/VoiceRoutingStatus.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceRoutingStatusWidgetOptions } from '../client/routingStatusWidget';
+export type VoiceRoutingStatusProps = VoiceRoutingStatusWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceRoutingStatus: ({ className, path, ...options }: VoiceRoutingStatusProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/index.d.ts

@@ -1,2 +1,11 @@
+export { VoiceOpsStatus } from './VoiceOpsStatus';
+export { VoiceProviderSimulationControls } from './VoiceProviderSimulationControls';
+export { VoiceProviderStatus } from './VoiceProviderStatus';
+export { VoiceRoutingStatus } from './VoiceRoutingStatus';
+export { useVoiceAppKitStatus } from './useVoiceAppKitStatus';
 export { useVoiceStream } from './useVoiceStream';
 export { useVoiceController } from './useVoiceController';
+export { useVoiceProviderStatus } from './useVoiceProviderStatus';
+export { useVoiceProviderSimulationControls } from './useVoiceProviderSimulationControls';
+export { useVoiceRoutingStatus } from './useVoiceRoutingStatus';
+export { useVoiceWorkflowStatus } from './useVoiceWorkflowStatus';