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

package/dist/core/providerSlo.d.ts

@@ -0,0 +1,142 @@
+import { Elysia } from "elysia";
+import { type VoiceRoutingEvent, type VoiceRoutingEventKind } from "./resilienceRoutes";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+export type VoiceProviderSloStatus = "fail" | "pass" | "warn";
+export type VoiceProviderSloThresholds = {
+    maxAverageElapsedMs?: number;
+    maxErrorRate?: number;
+    maxFallbackRate?: number;
+    maxP95ElapsedMs?: number;
+    maxTimeoutRate?: number;
+    minSamples?: number;
+};
+export type VoiceProviderSloThresholdConfig = Partial<Record<VoiceRoutingEventKind, VoiceProviderSloThresholds>>;
+export type VoiceProviderSloMetric = {
+    actual: number;
+    label: string;
+    pass: boolean;
+    threshold: number;
+    unit: "count" | "ms" | "rate";
+};
+export type VoiceProviderSloIssue = {
+    code: string;
+    detail?: string;
+    kind?: VoiceRoutingEventKind;
+    label: string;
+    sessionId?: string;
+    status: Exclude<VoiceProviderSloStatus, "pass">;
+    value?: number | string;
+};
+export type VoiceProviderSloKindReport = {
+    events: number;
+    eventsWithLatency: number;
+    fallbacks: number;
+    issues: VoiceProviderSloIssue[];
+    kind: VoiceRoutingEventKind;
+    metrics: Record<string, VoiceProviderSloMetric>;
+    providers: string[];
+    status: VoiceProviderSloStatus;
+    thresholds: Required<VoiceProviderSloThresholds>;
+    timeouts: number;
+    unresolvedErrors: number;
+};
+export type VoiceProviderSloSessionReport = {
+    errorCount: number;
+    fallbackCount: number;
+    kinds: VoiceRoutingEventKind[];
+    lastEventAt: number;
+    maxElapsedMs?: number;
+    sessionId: string;
+    status: VoiceProviderSloStatus;
+    timeoutCount: number;
+};
+export type VoiceProviderSloReport = {
+    checkedAt: number;
+    events: number;
+    eventsWithLatency: number;
+    issues: VoiceProviderSloIssue[];
+    kinds: Record<VoiceRoutingEventKind, VoiceProviderSloKindReport>;
+    sessions: VoiceProviderSloSessionReport[];
+    status: VoiceProviderSloStatus;
+    thresholds: Record<VoiceRoutingEventKind, Required<VoiceProviderSloThresholds>>;
+};
+export type VoiceProviderSloReportOptions = {
+    events?: StoredVoiceTraceEvent[] | VoiceRoutingEvent[];
+    maxAgeMs?: number;
+    now?: number;
+    requiredKinds?: readonly VoiceRoutingEventKind[];
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceProviderSloThresholdConfig;
+};
+export type VoiceProviderSloRoutesOptions = VoiceProviderSloReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProviderSloReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderSloAssertionInput = {
+    fallbackKinds?: VoiceRoutingEventKind[];
+    maxAverageElapsedMs?: Partial<Record<VoiceRoutingEventKind, number>>;
+    maxIssues?: number;
+    maxP95ElapsedMs?: Partial<Record<VoiceRoutingEventKind, number>>;
+    maxStatus?: VoiceProviderSloStatus;
+    maxTimeouts?: number;
+    maxUnresolvedErrors?: number;
+    minEvents?: number;
+    minFallbacks?: number;
+    minLatencySamples?: number;
+    requiredKinds?: VoiceRoutingEventKind[];
+    requiredProviders?: string[];
+};
+export type VoiceProviderSloAssertionReport = {
+    events: number;
+    eventsWithLatency: number;
+    fallbacks: number;
+    issues: string[];
+    kinds: VoiceRoutingEventKind[];
+    ok: boolean;
+    providers: string[];
+    status: VoiceProviderSloStatus;
+    timeouts: number;
+    unresolvedErrors: number;
+};
+export declare const assertVoiceProviderSloEvidence: (report: VoiceProviderSloReport, input?: VoiceProviderSloAssertionInput) => VoiceProviderSloAssertionReport;
+export declare const buildVoiceProviderSloReport: (options?: VoiceProviderSloReportOptions) => Promise<VoiceProviderSloReport>;
+export declare const evaluateVoiceProviderSloEvidence: (report: VoiceProviderSloReport, input?: VoiceProviderSloAssertionInput) => VoiceProviderSloAssertionReport;
+export declare const createVoiceProviderSloRoutes: (options: VoiceProviderSloRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceProviderSloHTML: (report: VoiceProviderSloReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceProviderSloMarkdown: (report: VoiceProviderSloReport) => string;

package/dist/core/providerStackRecommendations.d.ts

@@ -0,0 +1,188 @@
+import { Elysia } from "elysia";
+import type { VoiceReadinessProfileName } from "./readinessProfiles";
+export type VoiceProviderStackKind = "llm" | "stt" | "tts";
+export type VoiceProviderStackInput<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+};
+export type VoiceProviderStackChoice<TProvider extends string = string> = {
+    alternatives: TProvider[];
+    provider?: TProvider;
+    reasons: string[];
+};
+export type VoiceProviderStackRecommendation<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+    recommended: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    stacks: Partial<Record<VoiceProviderStackKind, VoiceProviderStackChoice<TProvider>>>;
+};
+export type VoiceProviderStackCapabilities<TProvider extends string = string> = Partial<Record<VoiceProviderStackKind, Partial<Record<TProvider, readonly string[]>>>>;
+export type VoiceProviderStackCapabilityGap<TProvider extends string = string> = {
+    kind: VoiceProviderStackKind;
+    missing: string[];
+    present: string[];
+    provider?: TProvider;
+    required: string[];
+    status: "fail" | "pass" | "warn";
+};
+export type VoiceProviderStackCapabilityGapReport<TProvider extends string = string> = {
+    gaps: VoiceProviderStackCapabilityGap<TProvider>[];
+    missing: number;
+    profile: VoiceReadinessProfileName;
+    status: "fail" | "pass" | "warn";
+};
+export type VoiceProviderStackAssertionInput<TProvider extends string = string> = {
+    maxMissing?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    requireProviders?: boolean;
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    requiredCapabilities?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderStackAssertionReport<TProvider extends string = string> = {
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    missing: number;
+    ok: boolean;
+    providers: TProvider[];
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderStackCapabilityGapInput<TProvider extends string = string> = VoiceProviderStackInput<TProvider> & {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    recommendation?: VoiceProviderStackRecommendation<TProvider>;
+    required?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderContractCheckStatus = "fail" | "pass" | "warn";
+type VoiceProviderContractRemediation = {
+    code: string;
+    detail: string;
+    href?: string;
+    label: string;
+};
+export type VoiceProviderContractCheck = {
+    detail?: string;
+    key: string;
+    label: string;
+    remediation?: VoiceProviderContractRemediation;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractDefinition<TProvider extends string = string> = {
+    capabilities?: readonly string[];
+    configured?: boolean;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: readonly TProvider[];
+    kind: VoiceProviderStackKind;
+    latencyBudgetMs?: number;
+    provider: TProvider;
+    requiredCapabilities?: readonly string[];
+    requiredEnv?: readonly string[];
+    remediationHref?: string;
+    selected?: boolean;
+    streaming?: boolean;
+};
+export type VoiceProviderContractMatrixInput<TProvider extends string = string> = {
+    contracts: readonly VoiceProviderContractDefinition<TProvider>[];
+};
+export type VoiceProviderContractMatrixPresetOptions<TProvider extends string = string> = {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    configured?: Partial<Record<TProvider, boolean>>;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    latencyBudgets?: Partial<Record<TProvider, number>>;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    remediationHref?: string;
+    selected?: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    streaming?: Partial<Record<TProvider, boolean>>;
+};
+export type VoiceProviderContractMatrixHandlerOptions<TProvider extends string = string> = VoiceProviderContractMatrixInput<TProvider> | (() => Promise<VoiceProviderContractMatrixInput<TProvider>> | VoiceProviderContractMatrixInput<TProvider>);
+export type VoiceProviderContractMatrixHTMLHandlerOptions<TProvider extends string = string> = {
+    matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>;
+    render?: (report: VoiceProviderContractMatrixReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderContractMatrixRoutesOptions<TProvider extends string = string> = VoiceProviderContractMatrixHTMLHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceProviderContractMatrixRow<TProvider extends string = string> = {
+    checks: VoiceProviderContractCheck[];
+    configured: boolean;
+    kind: VoiceProviderStackKind;
+    provider: TProvider;
+    selected: boolean;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractMatrixReport<TProvider extends string = string> = {
+    failed: number;
+    passed: number;
+    rows: VoiceProviderContractMatrixRow<TProvider>[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceProviderContractMatrixAssertionInput<TProvider extends string = string> = {
+    maxFailed?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    maxWarned?: number;
+    minRows?: number;
+    requireAllSelected?: boolean;
+    requiredCheckKeys?: string[];
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    selectedKinds?: VoiceProviderStackKind[];
+};
+export type VoiceProviderContractMatrixAssertionReport<TProvider extends string = string> = {
+    failed: number;
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    ok: boolean;
+    providers: TProvider[];
+    selectedKinds: VoiceProviderStackKind[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export declare const recommendVoiceProviderStack: <TProvider extends string = string>(input: VoiceProviderStackInput<TProvider>) => VoiceProviderStackRecommendation<TProvider>;
+export declare const assertVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const buildVoiceProviderContractMatrix: <TProvider extends string = string>(input: VoiceProviderContractMatrixInput<TProvider>) => VoiceProviderContractMatrixReport<TProvider>;
+export declare const createVoiceProviderContractMatrixPreset: <TProvider extends string = string>(profile: VoiceReadinessProfileName, options: VoiceProviderContractMatrixPresetOptions<TProvider>) => VoiceProviderContractMatrixInput<TProvider>;
+export declare const evaluateVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const createVoiceProviderContractMatrixHTMLHandler: <TProvider extends string = string>(options: VoiceProviderContractMatrixHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceProviderContractMatrixJSONHandler: <TProvider extends string = string>(matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>) => () => Promise<VoiceProviderContractMatrixReport<TProvider>>;
+export declare const createVoiceProviderContractMatrixRoutes: <TProvider extends string = string>(options: VoiceProviderContractMatrixRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const renderVoiceProviderContractMatrixHTML: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, options?: {
+    title?: string;
+}) => string;
+export declare const assertVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;
+export declare const evaluateVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;
+export declare const evaluateVoiceProviderStackGaps: <TProvider extends string = string>(input: VoiceProviderStackCapabilityGapInput<TProvider>) => VoiceProviderStackCapabilityGapReport<TProvider>;
+export {};

package/dist/core/qualityDriftDetector.d.ts

@@ -0,0 +1,44 @@
+import type { VoiceScorecard } from "./callScorecard";
+export type VoiceQualityDriftSeverity = "ok" | "watch" | "regression";
+export type VoiceQualityDriftCriterionAlert = {
+    criterionId: string;
+    baselineAverage: number;
+    currentAverage: number;
+    delta: number;
+    severity: VoiceQualityDriftSeverity;
+};
+export type VoiceQualityDriftReport = {
+    rubricId: string;
+    scope: {
+        from: number;
+        to: number;
+    };
+    baselineWindow: {
+        from: number;
+        to: number;
+        sampleSize: number;
+    };
+    currentWindow: {
+        from: number;
+        to: number;
+        sampleSize: number;
+    };
+    overall: {
+        baselineAverage: number;
+        currentAverage: number;
+        delta: number;
+        severity: VoiceQualityDriftSeverity;
+    };
+    criteria: VoiceQualityDriftCriterionAlert[];
+    alertCount: number;
+};
+export type DetectVoiceQualityDriftInput = {
+    rubricId: string;
+    scorecards: VoiceScorecard[];
+    baselineWindowMs?: number;
+    currentWindowMs?: number;
+    now?: () => number;
+    watchThreshold?: number;
+    regressionThreshold?: number;
+};
+export declare const detectVoiceQualityDrift: (input: DetectVoiceQualityDriftInput) => VoiceQualityDriftReport;

package/dist/core/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 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: {};
+}>;
+export declare const renderVoiceQualityHTML: (report: VoiceQualityReport, options?: {
+    links?: VoiceQualityLink[];
+}) => string;

package/dist/{queue.d.ts → core/queue.d.ts}

@@ -1,13 +1,15 @@
-import type { RedisClient } from 'bun';
-import type { VoiceIntegrationSink } from './opsSinks';
-import type { VoiceTraceRedactionConfig, VoiceTraceSink, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryStore, VoiceTraceSinkDeliveryQueueStatus } from './trace';
-import type { VoiceOpsTaskPriority, StoredVoiceOpsTask, StoredVoiceIntegrationEvent, VoiceIntegrationDeliveryStatus, VoiceIntegrationEventStore, VoiceIntegrationWebhookConfig, VoiceOpsTaskKind, VoiceOpsTaskStatus, VoiceOpsTaskStore } from './ops';
+import type { RedisClient } from "bun";
+import type { VoiceIntegrationSink } from "./opsSinks";
+import type { VoiceTraceRedactionConfig, VoiceTraceSink, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryStore, VoiceTraceSinkDeliveryQueueStatus } from "./trace";
+import type { VoiceTelephonyWebhookIdempotencyStore } from "./telephonyOutcome";
+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;
     taskId: string;
     workerId: string;
 };
-export type VoiceRedisTaskLeaseClient = Pick<RedisClient, 'get' | 'send' | 'set'>;
+export type VoiceRedisTaskLeaseClient = Pick<RedisClient, "get" | "send" | "set">;
 export type VoiceRedisTaskLeaseCoordinatorOptions = {
     client?: VoiceRedisTaskLeaseClient;
     keyPrefix?: string;
@@ -37,13 +39,20 @@ export type VoiceIdempotencyStore = {
         ttlSeconds?: number;
     }) => Promise<void> | void;
 };
-export type VoiceRedisIdempotencyClient = Pick<RedisClient, 'del' | 'exists' | 'set'>;
+export type VoiceRedisIdempotencyClient = Pick<RedisClient, "del" | "exists" | "set">;
 export type VoiceRedisIdempotencyStoreOptions = {
     client?: VoiceRedisIdempotencyClient;
     keyPrefix?: string;
     ttlSeconds?: number;
     url?: string;
 };
+export type VoiceRedisTelephonyWebhookIdempotencyClient = Pick<RedisClient, "get" | "set">;
+export type VoiceRedisTelephonyWebhookIdempotencyStoreOptions = {
+    client?: VoiceRedisTelephonyWebhookIdempotencyClient;
+    keyPrefix?: string;
+    ttlSeconds?: number;
+    url?: string;
+};
 export type VoiceWebhookDeliveryWorkerOptions<TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
     deadLetters?: VoiceIntegrationEventStore<TEvent>;
     events: VoiceIntegrationEventStore<TEvent>;
@@ -66,7 +75,7 @@ export type VoiceWebhookDeliveryWorkerResult = {
     skipped: number;
 };
 export type VoiceIntegrationEventQueueSummary = {
-    byType: Array<[StoredVoiceIntegrationEvent['type'], number]>;
+    byType: Array<[StoredVoiceIntegrationEvent["type"], number]>;
     deadLettered: number;
     delivered: number;
     failed: number;
@@ -159,6 +168,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;
@@ -217,11 +270,11 @@ export type VoiceOpsTaskProcessorWorkerOptions<TTask extends StoredVoiceOpsTask
     maxFailures?: number;
     onDeadLetter?: (task: TTask) => Promise<void> | void;
     onError?: (error: unknown, task: TTask) => Promise<void> | void;
-    process: (task: TTask) => Promise<void | 'complete' | 'requeue' | {
-        action?: 'complete' | 'requeue';
+    process: (task: TTask) => Promise<void | "complete" | "requeue" | {
+        action?: "complete" | "requeue";
         detail?: string;
-    }> | void | 'complete' | 'requeue' | {
-        action?: 'complete' | 'requeue';
+    }> | void | "complete" | "requeue" | {
+        action?: "complete" | "requeue";
         detail?: string;
     };
     tasks: VoiceOpsTaskStore<TTask>;
@@ -246,31 +299,39 @@ export type VoiceOpsTaskProcessorWorkerLoop = {
     stop: () => void;
     tick: () => Promise<VoiceOpsTaskProcessorWorkerResult>;
 };
-export declare const summarizeVoiceIntegrationEvents: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(events: TEvent[], input?: {
-    deadLetters?: VoiceIntegrationEventStore<TEvent>;
-}) => Promise<VoiceIntegrationEventQueueSummary> | VoiceIntegrationEventQueueSummary;
-export declare const summarizeVoiceTraceSinkDeliveries: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(deliveries: TDelivery[], input?: {
-    deadLetters?: VoiceTraceSinkDeliveryStore<TDelivery>;
-}) => Promise<VoiceTraceSinkDeliveryQueueSummary> | VoiceTraceSinkDeliveryQueueSummary;
-export declare const summarizeVoiceOpsTaskQueue: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(tasks: TTask[], input?: {
-    deadLetters?: VoiceOpsTaskStore<TTask>;
-}) => Promise<VoiceOpsTaskQueueSummary> | VoiceOpsTaskQueueSummary;
-export declare const createVoiceRedisTaskLeaseCoordinator: (options?: VoiceRedisTaskLeaseCoordinatorOptions) => VoiceRedisTaskLeaseCoordinator;
-export declare const createVoiceRedisIdempotencyStore: (options?: VoiceRedisIdempotencyStoreOptions) => VoiceIdempotencyStore;
-export declare const createVoiceWebhookDeliveryWorker: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceWebhookDeliveryWorkerOptions<TEvent>) => {
-    drain: () => Promise<VoiceWebhookDeliveryWorkerResult>;
+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 createVoiceWebhookDeliveryWorkerLoop: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceWebhookDeliveryWorkerLoopOptions<TEvent>) => VoiceWebhookDeliveryWorkerLoop;
+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 createVoiceIntegrationSinkWorker: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceIntegrationSinkWorkerOptions<TEvent>) => {
     drain: () => Promise<VoiceIntegrationSinkWorkerResult>;
 };
 export declare const createVoiceIntegrationSinkWorkerLoop: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceIntegrationSinkWorkerLoopOptions<TEvent>) => VoiceIntegrationSinkWorkerLoop;
+export declare const createVoiceOpsTaskProcessorWorker: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskProcessorWorkerOptions<TTask>) => {
+    drain: () => Promise<VoiceOpsTaskProcessorWorkerResult>;
+};
+export declare const createVoiceOpsTaskProcessorWorkerLoop: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskProcessorWorkerLoopOptions<TTask>) => VoiceOpsTaskProcessorWorkerLoop;
+export declare const createVoiceOpsTaskWorker: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskWorkerOptions<TTask>) => VoiceOpsTaskWorker<TTask>;
+export declare const createVoiceRedisIdempotencyStore: (options?: VoiceRedisIdempotencyStoreOptions) => VoiceIdempotencyStore;
+export declare const createVoiceRedisTaskLeaseCoordinator: (options?: VoiceRedisTaskLeaseCoordinatorOptions) => VoiceRedisTaskLeaseCoordinator;
+export declare const createVoiceRedisTelephonyWebhookIdempotencyStore: <TResult = unknown>(options?: VoiceRedisTelephonyWebhookIdempotencyStoreOptions) => VoiceTelephonyWebhookIdempotencyStore<TResult>;
 export declare const createVoiceTraceSinkDeliveryWorker: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceTraceSinkDeliveryWorkerOptions<TDelivery>) => {
     drain: () => Promise<VoiceTraceSinkDeliveryWorkerResult>;
 };
 export declare const createVoiceTraceSinkDeliveryWorkerLoop: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(options: VoiceTraceSinkDeliveryWorkerLoopOptions<TDelivery>) => VoiceTraceSinkDeliveryWorkerLoop;
-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>;
+export declare const createVoiceWebhookDeliveryWorker: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceWebhookDeliveryWorkerOptions<TEvent>) => {
+    drain: () => Promise<VoiceWebhookDeliveryWorkerResult>;
 };
-export declare const createVoiceOpsTaskProcessorWorkerLoop: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceOpsTaskProcessorWorkerLoopOptions<TTask>) => VoiceOpsTaskProcessorWorkerLoop;
+export declare const createVoiceWebhookDeliveryWorkerLoop: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceWebhookDeliveryWorkerLoopOptions<TEvent>) => VoiceWebhookDeliveryWorkerLoop;
+export declare const summarizeVoiceHandoffDeliveries: <TDelivery extends StoredVoiceHandoffDelivery = StoredVoiceHandoffDelivery>(deliveries: TDelivery[], input?: {
+    deadLetters?: VoiceHandoffDeliveryStore<TDelivery>;
+}) => Promise<VoiceHandoffDeliveryQueueSummary> | VoiceHandoffDeliveryQueueSummary;
+export declare const summarizeVoiceIntegrationEvents: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(events: TEvent[], input?: {
+    deadLetters?: VoiceIntegrationEventStore<TEvent>;
+}) => Promise<VoiceIntegrationEventQueueSummary> | VoiceIntegrationEventQueueSummary;
+export declare const summarizeVoiceOpsTaskQueue: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(tasks: TTask[], input?: {
+    deadLetters?: VoiceOpsTaskStore<TTask>;
+}) => Promise<VoiceOpsTaskQueueSummary> | VoiceOpsTaskQueueSummary;
+export declare const summarizeVoiceTraceSinkDeliveries: <TDelivery extends VoiceTraceSinkDeliveryRecord = VoiceTraceSinkDeliveryRecord>(deliveries: TDelivery[], input?: {
+    deadLetters?: VoiceTraceSinkDeliveryStore<TDelivery>;
+}) => Promise<VoiceTraceSinkDeliveryQueueSummary> | VoiceTraceSinkDeliveryQueueSummary;