@absolutejs/voice 0.0.22-beta.43 → 0.0.22-beta.431

package/dist/operationsRecord.d.ts

@@ -0,0 +1,351 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from './audit';
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTaskStore } from './ops';
+import { type VoiceSessionReplay } from './sessionReplay';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import { type VoiceTraceTimelineEvent, type VoiceTraceTimelineProviderSummary } from './traceTimeline';
+import { type StoredVoiceTraceEvent, type VoiceTraceEvaluationOptions, type VoiceTraceEventStore, type VoiceTraceRedactionConfig, type VoiceTraceSummary } from './trace';
+export type VoiceOperationsRecordStatus = 'failed' | 'healthy' | 'warning';
+export type VoiceOperationsRecordOutcome = {
+    assistantReplies: number;
+    complete: boolean;
+    escalated: boolean;
+    noAnswer: boolean;
+    transferred: boolean;
+    voicemail: boolean;
+};
+export type VoiceOperationsRecordAgentHandoff = {
+    at: number;
+    fromAgentId?: string;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    status?: string;
+    summary?: string;
+    targetAgentId?: string;
+    turnId?: string;
+};
+export type VoiceOperationsRecordTool = {
+    at: number;
+    elapsedMs?: number;
+    error?: string;
+    status?: string;
+    toolCallId?: string;
+    toolName?: string;
+    turnId?: string;
+};
+export type VoiceOperationsRecordTranscriptTurn = {
+    assistantReplies: string[];
+    committedText?: string;
+    errors: string[];
+    id: string;
+    transcripts: string[];
+};
+export type VoiceOperationsRecordProviderDecision = {
+    at: number;
+    elapsedMs?: number;
+    error?: string;
+    fallbackProvider?: string;
+    kind?: string;
+    provider?: string;
+    reason?: string;
+    selectedProvider?: string;
+    status?: string;
+    surface?: string;
+    type: StoredVoiceTraceEvent['type'];
+    turnId?: string;
+};
+export type VoiceOperationsRecordProviderDecisionRecoveryStatus = 'degraded' | 'failed' | 'none' | 'recovered' | 'selected';
+export type VoiceOperationsRecordProviderDecisionSummary = {
+    degraded: number;
+    errors: number;
+    fallbacks: number;
+    providers: string[];
+    recoveryStatus: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+    selected: number;
+    surfaces: string[];
+    total: number;
+};
+export type VoiceOperationsRecordAuditSummary = {
+    error: number;
+    events: StoredVoiceAuditEvent[];
+    skipped: number;
+    success: number;
+    total: number;
+};
+export type VoiceOperationsRecordReviewSummary = {
+    failed: number;
+    reviews: StoredVoiceCallReviewArtifact[];
+    total: number;
+};
+export type VoiceOperationsRecordTaskSummary = {
+    done: number;
+    inProgress: number;
+    open: number;
+    overdue: number;
+    tasks: StoredVoiceOpsTask[];
+    total: number;
+};
+export type VoiceOperationsRecordIntegrationEventSummary = {
+    delivered: number;
+    events: StoredVoiceIntegrationEvent[];
+    failed: number;
+    pending: number;
+    sinkDeliveries: number;
+    skipped: number;
+    total: number;
+};
+export type VoiceOperationsRecordGuardrailFinding = {
+    action?: string;
+    label?: string;
+    ruleId?: string;
+};
+export type VoiceOperationsRecordGuardrailDecision = {
+    allowed?: boolean;
+    at: number;
+    findings: VoiceOperationsRecordGuardrailFinding[];
+    metadata?: Record<string, unknown>;
+    proof?: string;
+    stage?: string;
+    status?: string;
+    toolName?: string;
+    turnId?: string;
+};
+export type VoiceOperationsRecordGuardrailSummary = {
+    blocked: number;
+    decisions: VoiceOperationsRecordGuardrailDecision[];
+    passed: number;
+    stages: string[];
+    total: number;
+    warned: number;
+};
+export type VoiceOperationsRecordTelephonyMediaEvent = {
+    at: number;
+    audioBytes: number;
+    callSid?: string;
+    carrier?: string;
+    direction?: string;
+    event: string;
+    sequenceNumber?: string;
+    streamId?: string;
+};
+export type VoiceOperationsRecordTelephonyMediaSummary = {
+    audioBytes: number;
+    carriers: string[];
+    clears: number;
+    errors: number;
+    events: VoiceOperationsRecordTelephonyMediaEvent[];
+    inbound: number;
+    marks: number;
+    media: number;
+    outbound: number;
+    starts: number;
+    stops: number;
+    streamIds: string[];
+    total: number;
+};
+export type VoiceOperationsRecordGuardrailAssertionInput = {
+    minBlocked?: number;
+    minDecisions?: number;
+    minPassed?: number;
+    minWarned?: number;
+    proofs?: string[];
+    ruleIds?: string[];
+    stages?: string[];
+    statuses?: string[];
+    toolNames?: string[];
+};
+export type VoiceOperationsRecordGuardrailAssertionReport = {
+    blocked: number;
+    decisions: number;
+    issues: string[];
+    ok: boolean;
+    passed: number;
+    proofs: string[];
+    ruleIds: string[];
+    stages: string[];
+    statuses: string[];
+    toolNames: string[];
+    warned: number;
+};
+export type VoiceOperationsRecordProviderRecoveryAssertionInput = {
+    minDegraded?: number;
+    minErrors?: number;
+    minFallbacks?: number;
+    minSelected?: number;
+    minTotal?: number;
+    recoveryStatus?: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+    requiredFallbackProviders?: string[];
+    requiredProviders?: string[];
+    requiredReasonIncludes?: string[];
+    requiredSelectedProviders?: string[];
+    requiredStatuses?: string[];
+    requiredSurfaces?: string[];
+};
+export type VoiceOperationsRecordProviderRecoveryAssertionReport = {
+    degraded: number;
+    errors: number;
+    fallbacks: number;
+    issues: string[];
+    ok: boolean;
+    providers: string[];
+    recoveryStatus: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+    selected: number;
+    selectedProviders: string[];
+    statuses: string[];
+    surfaces: string[];
+    total: number;
+};
+export type VoiceOperationsRecord = {
+    audit?: VoiceOperationsRecordAuditSummary;
+    checkedAt: number;
+    guardrails: VoiceOperationsRecordGuardrailSummary;
+    handoffs: VoiceOperationsRecordAgentHandoff[];
+    integrationEvents?: VoiceOperationsRecordIntegrationEventSummary;
+    outcome: VoiceOperationsRecordOutcome;
+    providerDecisions: VoiceOperationsRecordProviderDecision[];
+    providerDecisionSummary: VoiceOperationsRecordProviderDecisionSummary;
+    providers: VoiceTraceTimelineProviderSummary[];
+    replay: VoiceSessionReplay;
+    reviews?: VoiceOperationsRecordReviewSummary;
+    sessionId: string;
+    status: VoiceOperationsRecordStatus;
+    summary: VoiceTraceSummary;
+    tasks?: VoiceOperationsRecordTaskSummary;
+    telephonyMedia: VoiceOperationsRecordTelephonyMediaSummary;
+    timeline: VoiceTraceTimelineEvent[];
+    tools: VoiceOperationsRecordTool[];
+    traceEvents: StoredVoiceTraceEvent[];
+    transcript: VoiceOperationsRecordTranscriptTurn[];
+};
+export type VoiceFailureReplayStatus = 'degraded' | 'failed' | 'healthy' | 'recovered';
+export type VoiceFailureReplayProviderStep = {
+    at: number;
+    elapsedMs?: number;
+    error?: string;
+    fallbackProvider?: string;
+    kind?: string;
+    provider?: string;
+    reason?: string;
+    selectedProvider?: string;
+    status?: string;
+    surface?: string;
+    turnId?: string;
+    userHeard: string[];
+};
+export type VoiceFailureReplayMediaStep = {
+    at: number;
+    audioBytes: number;
+    carrier?: string;
+    direction?: string;
+    event: string;
+    issue?: string;
+    streamId?: string;
+};
+export type VoiceFailureReplayTurn = {
+    assistantReplies: string[];
+    committedText?: string;
+    errors: string[];
+    id: string;
+    media: VoiceFailureReplayMediaStep[];
+    providers: VoiceFailureReplayProviderStep[];
+    transcripts: string[];
+};
+export type VoiceFailureReplayReport = {
+    incidentMarkdown: string;
+    media: {
+        audioBytes: number;
+        clears: number;
+        errors: number;
+        issues: string[];
+        steps: VoiceFailureReplayMediaStep[];
+        total: number;
+    };
+    ok: boolean;
+    operationsRecordHref?: string;
+    providers: {
+        degraded: number;
+        errors: number;
+        fallbacks: number;
+        recoveryStatus: VoiceOperationsRecordProviderDecisionRecoveryStatus;
+        selected: number;
+        steps: VoiceFailureReplayProviderStep[];
+        total: number;
+    };
+    sessionId: string;
+    status: VoiceFailureReplayStatus;
+    summary: {
+        callDurationMs?: number;
+        issues: string[];
+        userHeard: string[];
+    };
+    turns: VoiceFailureReplayTurn[];
+};
+export type VoiceFailureReplayOptions = {
+    operationsRecordHref?: string | ((input: {
+        record: VoiceOperationsRecord;
+        sessionId: string;
+    }) => string);
+};
+export type VoiceOperationsRecordOptions = {
+    audit?: VoiceAuditEventStore;
+    evaluation?: VoiceTraceEvaluationOptions;
+    events?: StoredVoiceTraceEvent[];
+    integrationEvents?: VoiceIntegrationEventStore;
+    redact?: VoiceTraceRedactionConfig;
+    reviews?: VoiceCallReviewStore;
+    sessionId: string;
+    store?: VoiceTraceEventStore;
+    tasks?: VoiceOpsTaskStore;
+};
+export type VoiceOperationsRecordRoutesOptions = Omit<VoiceOperationsRecordOptions, 'sessionId'> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    incidentHtmlPath?: false | string;
+    incidentPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (record: VoiceOperationsRecord) => string | Promise<string>;
+    renderIncidentMarkdown?: (record: VoiceOperationsRecord) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceOperationsRecord: (options: VoiceOperationsRecordOptions) => Promise<VoiceOperationsRecord>;
+export declare const evaluateVoiceOperationsRecordGuardrails: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordGuardrailAssertionInput) => VoiceOperationsRecordGuardrailAssertionReport;
+export declare const assertVoiceOperationsRecordGuardrails: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordGuardrailAssertionInput) => VoiceOperationsRecordGuardrailAssertionReport;
+export declare const evaluateVoiceOperationsRecordProviderRecovery: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordProviderRecoveryAssertionInput) => VoiceOperationsRecordProviderRecoveryAssertionReport;
+export declare const assertVoiceOperationsRecordProviderRecovery: (record: VoiceOperationsRecord, input?: VoiceOperationsRecordProviderRecoveryAssertionInput) => VoiceOperationsRecordProviderRecoveryAssertionReport;
+export declare const buildVoiceFailureReplay: (record: VoiceOperationsRecord, options?: VoiceFailureReplayOptions) => VoiceFailureReplayReport;
+export declare const renderVoiceFailureReplayMarkdown: (report: Omit<VoiceFailureReplayReport, "incidentMarkdown"> | VoiceFailureReplayReport) => string;
+export declare const renderVoiceOperationsRecordIncidentMarkdown: (record: VoiceOperationsRecord) => string;
+export declare const renderVoiceOperationsRecordGuardrailMarkdown: (record: VoiceOperationsRecord) => string;
+export declare const renderVoiceOperationsRecordHTML: (record: VoiceOperationsRecord, options?: {
+    incidentHref?: string;
+    title?: string;
+}) => string;
+export declare const createVoiceOperationsRecordRoutes: (options: VoiceOperationsRecordRoutesOptions) => 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/opsActionAuditRoutes.d.ts

@@ -0,0 +1,99 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceAuditEvent, type VoiceAuditEventStore } from './audit';
+import { type VoiceTraceEventStore } from './trace';
+export type VoiceOpsActionAuditRecord = {
+    actionId: string;
+    body?: unknown;
+    error?: string;
+    ok: boolean;
+    ranAt: number;
+    status: number;
+};
+export type VoiceOpsActionAuditRoutesOptions = {
+    audit?: VoiceAuditEventStore;
+    historyHtmlPath?: false | string;
+    historyPath?: false | string;
+    name?: string;
+    path?: string;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceOpsActionHistoryEntry = {
+    actionId: string;
+    at: number;
+    error?: string;
+    eventId: string;
+    ok: boolean;
+    status?: number;
+    traceId?: string;
+};
+export type VoiceOpsActionHistoryReport = {
+    checkedAt: number;
+    entries: VoiceOpsActionHistoryEntry[];
+    failed: number;
+    passed: number;
+    total: number;
+};
+export declare const recordVoiceOpsActionAudit: (record: VoiceOpsActionAuditRecord, options: Pick<VoiceOpsActionAuditRoutesOptions, "audit" | "trace">) => Promise<{
+    audit: StoredVoiceAuditEvent<Record<string, unknown>> | (Omit<import("./audit").VoiceAuditEvent<Record<string, unknown>>, "at" | "id"> & {
+        at: number;
+        id: string;
+    }) | undefined;
+    ok: boolean;
+    trace: (import("./trace").VoiceTraceEvent<Record<string, unknown>> & {
+        id: string;
+    }) | undefined;
+}>;
+export declare const createVoiceOpsActionAuditRoutes: (options: VoiceOpsActionAuditRoutesOptions) => 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: {
+                    audit: StoredVoiceAuditEvent<Record<string, unknown>> | (Omit<import("./audit").VoiceAuditEvent<Record<string, unknown>>, "at" | "id"> & {
+                        at: number;
+                        id: string;
+                    }) | undefined;
+                    ok: boolean;
+                    trace: (import("./trace").VoiceTraceEvent<Record<string, unknown>> & {
+                        id: string;
+                    }) | undefined;
+                } | {
+                    error: string;
+                    ok: boolean;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const buildVoiceOpsActionHistoryReport: (options: Pick<VoiceOpsActionAuditRoutesOptions, "audit">) => Promise<VoiceOpsActionHistoryReport>;
+export declare const renderVoiceOpsActionHistoryHTML: (report: VoiceOpsActionHistoryReport) => string;

package/dist/opsConsoleRoutes.d.ts

@@ -1,4 +1,5 @@
 import { Elysia } from 'elysia';
+import { type VoiceDeliverySinkReport, type VoiceDeliverySinkRoutesOptions } from './deliverySinkRoutes';
 import { type VoiceQualityReport } from './qualityRoutes';
 import { type VoiceRoutingEvent } from './resilienceRoutes';
 import { type VoiceSessionListItem } from './sessionReplay';
@@ -17,6 +18,7 @@ export type VoiceOpsConsoleReport = {
         total: number;
     };
     links: VoiceOpsConsoleLink[];
+    deliverySinks?: VoiceDeliverySinkReport;
     providers: {
         degraded: number;
         healthy: number;
@@ -34,6 +36,7 @@ export type VoiceOpsConsoleReport = {
 };
 export type VoiceOpsConsoleRoutesOptions = {
     headers?: HeadersInit;
+    deliverySinks?: false | VoiceDeliverySinkRoutesOptions;
     links?: VoiceOpsConsoleLink[];
     llmProviders?: readonly string[];
     name?: string;

package/dist/opsRecovery.d.ts

@@ -0,0 +1,137 @@
+import { Elysia } from 'elysia';
+import { type VoiceAuditSinkDeliveryQueueSummary, type VoiceAuditSinkDeliveryStore } from './auditSinks';
+import { type VoiceLatencySLOGateOptions, type VoiceLatencySLOGateReport } from './latencySlo';
+import { type VoiceHandoffDeliveryQueueSummary, type VoiceTraceSinkDeliveryQueueSummary } from './queue';
+import { type VoiceProviderHealthSummary } from './providerHealth';
+import type { VoiceProductionReadinessCheck } from './productionReadiness';
+import type { VoiceHandoffDeliveryStore } from './types';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore, VoiceTraceSinkDeliveryStore } from './trace';
+export type VoiceOpsRecoveryStatus = 'fail' | 'pass' | 'warn';
+export type VoiceOpsRecoveryIssueCode = 'voice.ops_recovery.audit_delivery_failed' | 'voice.ops_recovery.audit_delivery_pending' | 'voice.ops_recovery.handoff_failed' | 'voice.ops_recovery.handoff_pending' | 'voice.ops_recovery.latency_slo_failed' | 'voice.ops_recovery.latency_slo_warn' | 'voice.ops_recovery.provider_unresolved_failure' | 'voice.ops_recovery.trace_delivery_failed' | 'voice.ops_recovery.trace_delivery_pending';
+export type VoiceOpsRecoveryIssue = {
+    code: VoiceOpsRecoveryIssueCode;
+    detail?: string;
+    href?: string;
+    label: string;
+    severity: Exclude<VoiceOpsRecoveryStatus, 'pass'>;
+    value?: number | string;
+};
+export type VoiceOpsRecoveryProviderSummary<TProvider extends string = string> = {
+    healthy: number;
+    providers: VoiceProviderHealthSummary<TProvider>[];
+    recoveredFallbacks: number;
+    unresolvedFailures: number;
+};
+export type VoiceOpsRecoveryInterventionSummary = {
+    events: Array<{
+        action?: string;
+        at: number;
+        operatorId?: string;
+        sessionId: string;
+        traceId?: string;
+    }>;
+    total: number;
+};
+export type VoiceOpsRecoveryFailedSession = {
+    at: number;
+    error?: string;
+    operationsRecordHref?: string;
+    provider?: string;
+    sessionId: string;
+    traceId?: string;
+};
+export type VoiceOpsRecoveryReport<TProvider extends string = string> = {
+    auditDeliveries?: VoiceAuditSinkDeliveryQueueSummary;
+    checkedAt: number;
+    failedSessions: VoiceOpsRecoveryFailedSession[];
+    handoffDeliveries?: VoiceHandoffDeliveryQueueSummary;
+    interventions: VoiceOpsRecoveryInterventionSummary;
+    issues: VoiceOpsRecoveryIssue[];
+    latency?: VoiceLatencySLOGateReport;
+    providers: VoiceOpsRecoveryProviderSummary<TProvider>;
+    status: VoiceOpsRecoveryStatus;
+    traceDeliveries?: VoiceTraceSinkDeliveryQueueSummary;
+};
+export type VoiceOpsRecoveryLinks = {
+    auditDeliveries?: string;
+    handoffs?: string;
+    operationsRecords?: string | ((sessionId: string) => string);
+    providers?: string;
+    sessions?: string | ((sessionId: string) => string);
+    traceDeliveries?: string;
+    traces?: string | ((sessionId: string) => string);
+};
+export type VoiceOpsRecoveryReportOptions<TProvider extends string = string> = {
+    auditDeliveryDeadLetters?: VoiceAuditSinkDeliveryStore;
+    auditDeliveries?: VoiceAuditSinkDeliveryStore;
+    events?: StoredVoiceTraceEvent[];
+    handoffDeliveryDeadLetters?: VoiceHandoffDeliveryStore;
+    handoffDeliveries?: VoiceHandoffDeliveryStore;
+    latency?: VoiceLatencySLOGateOptions | false;
+    limit?: number;
+    links?: VoiceOpsRecoveryLinks;
+    providers?: readonly TProvider[];
+    traceDeliveryDeadLetters?: VoiceTraceSinkDeliveryStore;
+    traceDeliveries?: VoiceTraceSinkDeliveryStore;
+    traces?: VoiceTraceEventStore;
+};
+export type VoiceOpsRecoveryRoutesOptions<TProvider extends string = string> = VoiceOpsRecoveryReportOptions<TProvider> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceOpsRecoveryReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export declare const buildVoiceOpsRecoveryReport: <TProvider extends string = string>(options?: VoiceOpsRecoveryReportOptions<TProvider>) => Promise<VoiceOpsRecoveryReport<TProvider>>;
+export declare const buildVoiceOpsRecoveryReadinessCheck: (report: VoiceOpsRecoveryReport, options?: {
+    href?: string;
+    label?: string;
+}) => VoiceProductionReadinessCheck;
+export declare const renderVoiceOpsRecoveryMarkdown: (report: VoiceOpsRecoveryReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceOpsRecoveryHTML: (report: VoiceOpsRecoveryReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOpsRecoveryRoutes: <TProvider extends string = string>(options?: VoiceOpsRecoveryRoutesOptions<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: VoiceOpsRecoveryReport<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/opsStatus.d.ts

@@ -0,0 +1,76 @@
+import { type VoiceEvalLink, type VoiceEvalRoutesOptions } from './evalRoutes';
+import { type VoiceDeliverySinkRoutesOptions } from './deliverySinkRoutes';
+import { type VoiceQualityRoutesOptions } from './qualityRoutes';
+import { type VoiceProviderFallbackRecoverySummary } from './sessionReplay';
+import { type VoiceTraceEventStore } from './trace';
+export type VoiceOpsStatus = 'pass' | 'fail';
+export type VoiceOpsStatusLink = VoiceEvalLink & {
+    description?: string;
+    statusHref?: string;
+};
+export type VoiceOpsStatusOptions<TProvider extends string = string> = {
+    deliverySinks?: false | VoiceDeliverySinkRoutesOptions;
+    evals?: false | Partial<VoiceEvalRoutesOptions>;
+    include?: {
+        deliverySinks?: boolean;
+        handoffs?: boolean;
+        providers?: boolean;
+        providerRecovery?: boolean;
+        quality?: boolean;
+        sessions?: boolean;
+        workflows?: boolean;
+    };
+    links?: VoiceOpsStatusLink[];
+    llmProviders?: readonly TProvider[];
+    preferFixtureWorkflows?: boolean;
+    quality?: false | Partial<VoiceQualityRoutesOptions>;
+    store: VoiceTraceEventStore;
+    sttProviders?: readonly string[];
+    ttsProviders?: readonly string[];
+};
+export type VoiceOpsStatusReport = {
+    checkedAt: number;
+    failed: number;
+    links: VoiceOpsStatusLink[];
+    passed: number;
+    status: VoiceOpsStatus;
+    surfaces: {
+        handoffs?: {
+            failed: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        deliverySinks?: {
+            auditTotal: number;
+            status: VoiceOpsStatus;
+            traceTotal: number;
+        };
+        providers?: {
+            degraded: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        providerRecovery?: VoiceProviderFallbackRecoverySummary;
+        quality?: {
+            status: VoiceOpsStatus;
+        };
+        sessions?: {
+            failed: number;
+            status: VoiceOpsStatus;
+            total: number;
+        };
+        workflows?: {
+            failed: number;
+            source: 'fixtures' | 'live';
+            status: VoiceOpsStatus;
+            total: number;
+        };
+    };
+    total: number;
+};
+export type VoiceOpsStatusRoutesOptions<TProvider extends string = string> = VoiceOpsStatusOptions<TProvider> & {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceOpsStatus: <TProvider extends string = string>(options: VoiceOpsStatusOptions<TProvider>) => Promise<VoiceOpsStatusReport>;