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

package/dist/core/reminderScheduler.d.ts

@@ -0,0 +1,43 @@
+export type VoiceReminderChannel = "call" | "sms" | "email";
+export type VoiceReminderTrigger = {
+    id: string;
+    channel: VoiceReminderChannel;
+    offsetMinutesBeforeStart: number;
+    templateId?: string;
+    retryOnFailure?: boolean;
+};
+export type VoiceReminderJob = {
+    id: string;
+    appointmentId: string;
+    triggerId: string;
+    channel: VoiceReminderChannel;
+    scheduledAtMs: number;
+    status: "pending" | "in-flight" | "sent" | "skipped" | "failed" | "cancelled";
+    attempts: number;
+    lastError?: string;
+    metadata?: Record<string, string>;
+};
+export type ScheduleVoiceRemindersInput = {
+    appointmentId: string;
+    appointmentStartMs: number;
+    triggers: VoiceReminderTrigger[];
+    metadata?: Record<string, string>;
+};
+export type CreateVoiceReminderSchedulerOptions = {
+    generateJobId?: () => string;
+    now?: () => number;
+    defaultTriggers?: VoiceReminderTrigger[];
+    maxAttempts?: number;
+};
+export declare const DEFAULT_VOICE_REMINDER_TRIGGERS: VoiceReminderTrigger[];
+export declare const createVoiceReminderScheduler: (options?: CreateVoiceReminderSchedulerOptions) => {
+    cancelForAppointment: (appointmentId: string) => number;
+    due: (at?: number) => VoiceReminderJob[];
+    markFailed: (jobId: string, error: string) => boolean;
+    markInFlight: (jobId: string) => boolean;
+    markSent: (jobId: string) => boolean;
+    schedule: (input: ScheduleVoiceRemindersInput) => VoiceReminderJob[];
+    list: (appointmentId?: string) => VoiceReminderJob[];
+    subscribe(listener: (job: VoiceReminderJob) => void): () => void;
+};
+export type VoiceReminderScheduler = ReturnType<typeof createVoiceReminderScheduler>;

package/dist/core/resilienceRoutes.d.ts

@@ -0,0 +1,146 @@
+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;
+    profileId?: string;
+    profileLabel?: string;
+    provider?: string;
+    providerRoutes?: Record<string, 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 createVoiceRoutingDecisionSummary: (options: VoiceRoutingDecisionSummaryOptions) => Promise<VoiceRoutingDecisionSummary | null>;
+export declare const summarizeVoiceRoutingSessions: (events: StoredVoiceTraceEvent[] | VoiceRoutingEvent[], options?: VoiceRoutingSessionSummaryOptions) => VoiceRoutingSessionSummary[];
+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: {};
+}>;

package/dist/core/retention.d.ts

@@ -0,0 +1,37 @@
+export type VoiceRetentionPolicyOptions = {
+    /** Maximum age in milliseconds; events older than this are eligible for purge. */
+    maxAgeMs: number;
+    /** Optional override that returns the timestamp for an event. Defaults to event.at. */
+    resolveAt?: (event: unknown) => number | undefined;
+};
+export type VoiceRetentionStore<TRecord extends {
+    id: string;
+}> = {
+    list: (filter?: Record<string, unknown>) => Promise<TRecord[]> | TRecord[];
+    remove: (id: string) => Promise<void> | void;
+};
+export type VoicePurgeReport = {
+    attempted: number;
+    failed: number;
+    purgedIds: string[];
+    reason: "expired" | "manual";
+    removed: number;
+};
+export declare const purgeVoiceRetentionStore: <TRecord extends {
+    id: string;
+}>(store: VoiceRetentionStore<TRecord>, options: VoiceRetentionPolicyOptions, now?: number) => Promise<VoicePurgeReport>;
+export type VoiceRetentionScheduler = {
+    start: () => void;
+    stop: () => void;
+};
+export type CreateVoiceRetentionSchedulerOptions<TRecord extends {
+    id: string;
+}> = {
+    intervalMs?: number;
+    onReport?: (report: VoicePurgeReport) => void;
+    policy: VoiceRetentionPolicyOptions;
+    store: VoiceRetentionStore<TRecord>;
+};
+export declare const createVoiceRetentionScheduler: <TRecord extends {
+    id: string;
+}>(options: CreateVoiceRetentionSchedulerOptions<TRecord>) => VoiceRetentionScheduler;

package/dist/core/retryPolicy.d.ts

@@ -0,0 +1,38 @@
+export type VoiceRetryDispositionAction = "retry" | "abandon" | "escalate";
+export type VoiceRetryDispositionRule = {
+    disposition: string;
+    action: VoiceRetryDispositionAction;
+    cooldownMs?: number;
+    maxAttemptsOverride?: number;
+};
+export type VoiceRetryAttempt = {
+    disposition: string;
+    at: number;
+};
+export type VoiceRetryDecision = {
+    action: "retry";
+    attemptNumber: number;
+    retryAt: number;
+} | {
+    action: "abandon";
+    reason: "max-attempts" | "non-retryable" | "explicit";
+} | {
+    action: "escalate";
+    reason: string;
+};
+export type CreateVoiceRetryPolicyOptions = {
+    maxAttempts?: number;
+    defaultCooldownMs?: number;
+    jitterMs?: number;
+    backoffMultiplier?: number;
+    rules?: VoiceRetryDispositionRule[];
+    escalateAfterAttempts?: number;
+    now?: () => number;
+};
+export declare const createVoiceRetryPolicy: (options?: CreateVoiceRetryPolicyOptions) => {
+    decide: (history: VoiceRetryAttempt[], lastDisposition: string) => VoiceRetryDecision;
+    maxAttempts: number;
+    rules: () => VoiceRetryDispositionRule[];
+    updateRule(rule: VoiceRetryDispositionRule): void;
+};
+export type VoiceRetryPolicy = ReturnType<typeof createVoiceRetryPolicy>;

package/dist/core/routeAuth.d.ts

@@ -0,0 +1,58 @@
+import { Elysia } from "elysia";
+export type VoiceRouteAuthDecision = {
+    allow: true;
+} | {
+    allow: false;
+    reason: string;
+    status?: number;
+};
+export type VoiceRouteAuthInput = {
+    body?: string;
+    headers: Headers;
+    method: string;
+    url: string;
+};
+export type VoiceRouteAuthVerifier = (input: VoiceRouteAuthInput) => Promise<VoiceRouteAuthDecision> | VoiceRouteAuthDecision;
+export type VoiceRouteAuthOptions = {
+    bypassPaths?: ReadonlyArray<string>;
+    name?: string;
+    verify: VoiceRouteAuthVerifier;
+};
+export declare const createVoiceBearerAuthVerifier: (input: {
+    expectedToken: string;
+    headerName?: string;
+}) => VoiceRouteAuthVerifier;
+export declare const createVoiceHMACAuthVerifier: (input: {
+    secret: string;
+    toleranceMs?: number;
+}) => VoiceRouteAuthVerifier;
+export declare const createVoiceRouteAuth: (options: VoiceRouteAuthOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {
+        200: Response;
+    };
+}>;

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

@@ -1,3 +1,3 @@
-import type { VoiceSTTRoutingCorrectionMode, VoiceSTTRoutingGoal, VoiceSTTRoutingStrategy, VoiceTurnCorrectionHandler } from './types';
-export declare const resolveVoiceSTTRoutingStrategy: (goal?: VoiceSTTRoutingGoal) => VoiceSTTRoutingStrategy;
+import type { VoiceSTTRoutingCorrectionMode, VoiceSTTRoutingGoal, VoiceSTTRoutingStrategy, VoiceTurnCorrectionHandler } from "./types";
 export declare const createVoiceSTTRoutingCorrectionHandler: (mode?: VoiceSTTRoutingCorrectionMode) => VoiceTurnCorrectionHandler | undefined;
+export declare const resolveVoiceSTTRoutingStrategy: (goal?: VoiceSTTRoutingGoal) => VoiceSTTRoutingStrategy;

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

@@ -1,6 +1,6 @@
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact } from './testing/review';
-import type { VoiceOpsTask } from './ops';
-import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from './types';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact } from "../testing/review";
+import type { VoiceOpsTask } from "./ops";
+import type { VoiceCallDisposition, VoiceRuntimeOpsConfig, VoiceSessionHandle, VoiceSessionRecord } from "./types";
 export declare const createVoiceCallReviewFromSession: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(input: {
     disposition: VoiceCallDisposition;
     generatedAt?: number;

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

@@ -1,14 +1,23 @@
-import type { S3Client, S3Options } from 'bun';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import type { S3Client, S3Options } from "bun";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "../testing/review";
+import type { VoiceRecordingStore } from "./recordingStore";
 export type VoiceS3ReviewStoreFile = {
     delete: () => Promise<void>;
     exists: () => Promise<boolean>;
     text: () => Promise<string>;
     write: (data: string) => Promise<number>;
 };
-export type VoiceS3ReviewStoreClient = Pick<S3Client, 'file' | 'list'>;
+export type VoiceS3ReviewStoreClient = Pick<S3Client, "file" | "list">;
 export type VoiceS3ReviewStoreOptions = S3Options & {
     client?: VoiceS3ReviewStoreClient;
     keyPrefix?: string;
 };
 export declare const createVoiceS3ReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceS3ReviewStoreOptions) => VoiceCallReviewStore<TArtifact>;
+type VoiceS3RecordingStoreClient = Pick<S3Client, "file" | "list">;
+type VoiceS3RecordingStoreOptions = S3Options & {
+    client?: VoiceS3RecordingStoreClient;
+    keyPrefix?: string;
+    publicUrlBase?: string;
+};
+export declare const createVoiceS3RecordingStore: (options: VoiceS3RecordingStoreOptions) => VoiceRecordingStore;
+export {};

package/dist/core/scorecardCalibration.d.ts

@@ -0,0 +1,31 @@
+import type { VoiceScorecard } from "./callScorecard";
+export type VoiceScorecardCalibrationPair = {
+    sessionId: string;
+    human: VoiceScorecard;
+    llm: VoiceScorecard;
+};
+export type VoiceScorecardCalibrationDivergence = {
+    sessionId: string;
+    criterionId: string;
+    humanScore: number;
+    llmScore: number;
+    normalizedGap: number;
+};
+export type VoiceScorecardCalibrationReport = {
+    pairsCompared: number;
+    meanAbsoluteError: number;
+    rootMeanSquareError: number;
+    weightedScoreCorrelation: number;
+    gradeAgreementRate: number;
+    perCriterion: {
+        criterionId: string;
+        meanAbsoluteError: number;
+        averageHumanScore: number;
+        averageLLMScore: number;
+        bias: number;
+    }[];
+    worstDivergences: VoiceScorecardCalibrationDivergence[];
+};
+export declare const computeVoiceScorecardCalibration: (pairs: VoiceScorecardCalibrationPair[], options?: {
+    topDivergences?: number;
+}) => VoiceScorecardCalibrationReport;

package/dist/core/scribe.d.ts

@@ -0,0 +1,50 @@
+import type { AudioChunk, AudioFormat, STTAdapter, Transcript, VoiceCloseEvent, VoiceErrorEvent, VoiceLanguageStrategy, VoiceLexiconEntry, VoicePhraseHint } from "./types";
+export type VoiceScribeTurn = {
+    speaker: string;
+    text: string;
+    confidence?: number;
+    startedAtMs?: number;
+    endedAtMs?: number;
+};
+export type VoiceScribePartialEvent = {
+    type: "partial";
+    transcript: Transcript;
+};
+export type VoiceScribeTurnEvent = {
+    type: "turn";
+    turn: VoiceScribeTurn;
+};
+export type VoiceScribeEventMap = {
+    partial: VoiceScribePartialEvent;
+    turn: VoiceScribeTurnEvent;
+    error: VoiceErrorEvent;
+    close: VoiceCloseEvent;
+};
+export type VoiceScribeSession = {
+    on: <K extends keyof VoiceScribeEventMap>(event: K, handler: (payload: VoiceScribeEventMap[K]) => void | Promise<void>) => () => void;
+    /** Push a chunk of audio (same format declared in `open`). */
+    send: (audio: AudioChunk) => Promise<void>;
+    /** All finalized, speaker-labelled turns so far, in order. */
+    getTranscript: () => VoiceScribeTurn[];
+    close: (reason?: string) => Promise<void>;
+};
+export type VoiceScribeOptions = {
+    stt: STTAdapter;
+    sessionId: string;
+    format: AudioFormat;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
+    phraseHints?: VoicePhraseHint[];
+    signal?: AbortSignal;
+};
+/**
+ * A listen-only transcription session — a "scribe". It drives an STT adapter
+ * over a stream of audio chunks and emits diarized transcript turns, with NO
+ * assistant (no LLM) and NO TTS. Use it to turn any audio source — an
+ * onSpark-hosted meeting, or a meeting-bot adapter piping in an external call —
+ * into a live, speaker-labelled transcript that downstream consumers (e.g. a
+ * deal-call analyzer) read or act on. Diarization comes from the STT adapter
+ * (e.g. `deepgram({ diarize: true })`); speakers are surfaced as stable string
+ * labels on each turn.
+ */
+export declare const createVoiceScribe: (options: VoiceScribeOptions) => Promise<VoiceScribeSession>;

package/dist/core/semanticTurn.d.ts

@@ -0,0 +1,37 @@
+import type { AudioFormat, Transcript } from "./types";
+export type VoiceSemanticTurnInput = {
+    audioLevel?: number;
+    lastFinalTranscript?: Transcript;
+    partialText: string;
+    silenceMs: number;
+    transcripts: Transcript[];
+    /**
+     * The current turn's buffered user audio (PCM chunks, oldest→newest) and its
+     * format. Lets an AUDIO-based end-of-turn detector (e.g. a smart-turn / Whisper
+     * EOT model) judge completion from prosody — pitch, pace, trailing intonation —
+     * which a transcript-only judge fundamentally cannot see. Undefined when no
+     * audio was buffered for the turn (the runtime only stores chunks above the
+     * speech threshold).
+     */
+    turnAudio?: ReadonlyArray<Uint8Array>;
+    turnAudioFormat?: AudioFormat;
+};
+export type VoiceSemanticTurnVerdict = {
+    confidence?: number;
+    endOfTurn: boolean;
+    reason?: string;
+};
+export type VoiceSemanticTurnDetector = {
+    evaluate: (input: VoiceSemanticTurnInput) => Promise<VoiceSemanticTurnVerdict> | VoiceSemanticTurnVerdict;
+};
+export type CreatePunctuationSemanticTurnDetectorOptions = {
+    endPunctuation?: ReadonlyArray<string>;
+    fillerWords?: ReadonlyArray<string>;
+    minPartialWords?: number;
+};
+export declare const createPunctuationSemanticTurnDetector: (options?: CreatePunctuationSemanticTurnDetectorOptions) => VoiceSemanticTurnDetector;
+export type CreateRegexSemanticTurnDetectorOptions = {
+    endPattern: RegExp;
+    minPartialWords?: number;
+};
+export declare const createRegexSemanticTurnDetector: (options: CreateRegexSemanticTurnDetectorOptions) => VoiceSemanticTurnDetector;

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

@@ -1,2 +1,2 @@
-import type { CreateVoiceSessionOptions, VoiceSessionHandle, VoiceSessionRecord } from './types';
+import type { CreateVoiceSessionOptions, VoiceSessionHandle, VoiceSessionRecord } from "./types";
 export declare const createVoiceSession: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: CreateVoiceSessionOptions<TContext, TSession, TResult>) => VoiceSessionHandle<TContext, TSession, TResult>;

package/dist/core/sessionObservability.d.ts

@@ -0,0 +1,145 @@
+import { Elysia } from "elysia";
+import { type VoiceFailureReplayReport, type VoiceOperationsRecord, type VoiceOperationsRecordOptions } from "./operationsRecord";
+import type { StoredVoiceTraceEvent } from "./trace";
+export type VoiceSessionObservabilityStatus = "failed" | "healthy" | "warning";
+export type VoiceSessionObservabilityLink = {
+    href: string;
+    label: string;
+    rel: "call-debugger" | "incident-markdown" | "operations-record" | "trace-timeline" | "custom";
+};
+export type VoiceSessionObservabilityStage = {
+    at: number;
+    elapsedMs?: number;
+    label: string;
+    offsetMs: number;
+    provider?: string;
+    status?: string;
+    type: StoredVoiceTraceEvent["type"];
+};
+export type VoiceSessionObservabilityTurn = {
+    assistantReplies: number;
+    durationMs?: number;
+    endedAt?: number;
+    errors: number;
+    providerDecisions: number;
+    stages: VoiceSessionObservabilityStage[];
+    startedAt?: number;
+    toolCalls: number;
+    transcripts: number;
+    turnId: string;
+};
+export type VoiceSessionObservabilityReport = {
+    checkedAt: number;
+    failureReplay: VoiceFailureReplayReport;
+    incidentMarkdown: string;
+    links: VoiceSessionObservabilityLink[];
+    record: VoiceOperationsRecord;
+    sessionId: string;
+    status: VoiceSessionObservabilityStatus;
+    summary: {
+        durationMs?: number;
+        errors: number;
+        events: number;
+        fallbacks: number;
+        guardrailBlocks: number;
+        handoffs: number;
+        providerRecoveryStatus: VoiceOperationsRecord["providerDecisionSummary"]["recoveryStatus"];
+        providers: string[];
+        telephonyMediaEvents: number;
+        toolCalls: number;
+        turns: number;
+    };
+    turns: VoiceSessionObservabilityTurn[];
+};
+export type VoiceSessionObservabilityEvidenceStatus = "pass" | "warn" | "fail";
+export type VoiceSessionObservabilityEvidenceInput = {
+    requireHealthy?: boolean;
+    minStageCount?: number;
+    minTurns?: number;
+    minTurnWaterfalls?: number;
+    minProviderDecisions?: number;
+    minToolCalls?: number;
+    requireOperationsRecordLink?: boolean;
+    requireTraceTimelineLink?: boolean;
+    requireCallDebuggerLink?: boolean;
+    requireIncidentMarkdownLink?: boolean;
+    requireIncidentMarkdown?: boolean;
+    maxErrors?: number;
+    maxFallbacks?: number;
+    requireProviderRecoveryStatus?: VoiceOperationsRecord["providerDecisionSummary"]["recoveryStatus"] | readonly VoiceOperationsRecord["providerDecisionSummary"]["recoveryStatus"][];
+};
+export type VoiceSessionObservabilityEvidenceReport = {
+    checkedAt: number;
+    issues: string[];
+    ok: boolean;
+    status: VoiceSessionObservabilityEvidenceStatus;
+    summary: {
+        incidentMarkdownLength: number;
+        providerDecisions: number;
+        providerRecoveryStatus: VoiceOperationsRecord["providerDecisionSummary"]["recoveryStatus"];
+        reportStatus: VoiceSessionObservabilityStatus;
+        stages: number;
+        turns: number;
+        turnsWithWaterfalls: number;
+        toolCalls: number;
+        links: {
+            callDebugger: boolean;
+            incidentMarkdown: boolean;
+            operationsRecord: boolean;
+            traceTimeline: boolean;
+        };
+    };
+};
+export type VoiceSessionObservabilityReportOptions = Omit<VoiceOperationsRecordOptions, "sessionId"> & {
+    callDebuggerHref?: false | string | ((sessionId: string) => string);
+    customLinks?: readonly VoiceSessionObservabilityLink[];
+    incidentMarkdownHref?: false | string | ((sessionId: string) => string);
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    sessionId: string;
+    traceTimelineHref?: false | string | ((sessionId: string) => string);
+};
+export type VoiceSessionObservabilityRoutesOptions = Omit<VoiceSessionObservabilityReportOptions, "sessionId"> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    incidentPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceSessionObservabilityReport) => Promise<string> | string;
+    renderIncidentMarkdown?: (report: VoiceSessionObservabilityReport) => Promise<string> | string;
+    title?: string;
+};
+export declare const buildVoiceSessionObservabilityReport: (options: VoiceSessionObservabilityReportOptions) => Promise<VoiceSessionObservabilityReport>;
+export declare const renderVoiceSessionObservabilityHTML: (report: VoiceSessionObservabilityReport, options?: {
+    title?: string;
+}) => string;
+export declare const renderVoiceSessionObservabilityMarkdown: (report: VoiceSessionObservabilityReport) => string;
+export declare const assertVoiceSessionObservabilityEvidence: (report: VoiceSessionObservabilityReport, input?: VoiceSessionObservabilityEvidenceInput) => VoiceSessionObservabilityEvidenceReport;
+export declare const createVoiceSessionObservabilityRoutes: (options: VoiceSessionObservabilityRoutesOptions) => 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 evaluateVoiceSessionObservabilityEvidence: (report: VoiceSessionObservabilityReport, input?: VoiceSessionObservabilityEvidenceInput) => VoiceSessionObservabilityEvidenceReport;