@absolutejs/voice 0.0.22-beta.4 → 0.0.22-beta.400

package/dist/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 summarizeVoiceRoutingSessions: (events: StoredVoiceTraceEvent[] | VoiceRoutingEvent[], options?: VoiceRoutingSessionSummaryOptions) => VoiceRoutingSessionSummary[];
+export declare const createVoiceRoutingDecisionSummary: (options: VoiceRoutingDecisionSummaryOptions) => Promise<VoiceRoutingDecisionSummary | null>;
+export declare const renderVoiceResilienceHTML: (input: VoiceResiliencePageData) => string;
+export declare const createVoiceResilienceRoutes: (options: VoiceResilienceRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/sessionReplay.d.ts

@@ -0,0 +1,187 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceTraceEvent, type VoiceTraceEvaluationOptions, type VoiceTraceEventStore, type VoiceTraceRedactionConfig, type VoiceTraceSummary, type VoiceTraceEvaluation } from './trace';
+export type VoiceSessionReplayTurn = {
+    assistantReplies: string[];
+    committedText?: string;
+    errors: Array<Record<string, unknown>>;
+    id: string;
+    modelCalls: Array<Record<string, unknown>>;
+    tools: Array<Record<string, unknown>>;
+    transcripts: Array<{
+        isFinal: boolean;
+        text?: string;
+    }>;
+};
+export type VoiceSessionReplay = {
+    evaluation: VoiceTraceEvaluation;
+    events: StoredVoiceTraceEvent[];
+    html: string;
+    markdown: string;
+    sessionId: string;
+    summary: VoiceTraceSummary;
+    timeline: Array<{
+        at: number;
+        offsetMs?: number;
+        payload: Record<string, unknown>;
+        turnId?: string;
+        type: StoredVoiceTraceEvent['type'];
+    }>;
+    turns: VoiceSessionReplayTurn[];
+};
+export type VoiceSessionListStatus = 'failed' | 'healthy';
+export type VoiceSessionListItem = {
+    endedAt?: number;
+    errorCount: number;
+    eventCount: number;
+    latestOutcome?: string;
+    operationsRecordHref?: string;
+    providerErrors: Record<string, number>;
+    providers: string[];
+    replayHref: string;
+    sessionId: string;
+    startedAt?: number;
+    status: VoiceSessionListStatus;
+    transcriptCount: number;
+    turnCount: number;
+};
+export type VoiceProviderFallbackRecoverySummary = {
+    recovered: number;
+    recoveredSessions: number;
+    recoveredTurns: number;
+    status: 'fail' | 'pass';
+    total: number;
+    unresolvedErrors: number;
+    unresolvedSessions: number;
+};
+export type VoiceSessionListOptions = {
+    events?: StoredVoiceTraceEvent[];
+    limit?: number;
+    operationsRecordHref?: false | string | ((session: Omit<VoiceSessionListItem, 'operationsRecordHref' | 'replayHref'>) => string);
+    provider?: string;
+    q?: string;
+    replayHref?: false | string | ((session: Omit<VoiceSessionListItem, 'replayHref'>) => string);
+    status?: VoiceSessionListStatus | 'all';
+    store?: VoiceTraceEventStore;
+};
+export type VoiceSessionListHTMLHandlerOptions = VoiceSessionListOptions & {
+    headers?: HeadersInit;
+    render?: (sessions: VoiceSessionListItem[]) => string | Promise<string>;
+};
+export type VoiceSessionListRoutesOptions = VoiceSessionListHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceSessionReplayOptions = {
+    evaluation?: VoiceTraceEvaluationOptions;
+    events?: StoredVoiceTraceEvent[];
+    redact?: VoiceTraceRedactionConfig;
+    sessionId: string;
+    store?: VoiceTraceEventStore;
+    title?: string;
+};
+export type VoiceSessionReplayHTMLHandlerOptions = Omit<VoiceSessionReplayOptions, 'sessionId'> & {
+    headers?: HeadersInit;
+    render?: (replay: VoiceSessionReplay) => string | Promise<string>;
+};
+export type VoiceSessionReplayRoutesOptions = VoiceSessionReplayHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceProviderFallbackRecovery: (events: StoredVoiceTraceEvent[]) => VoiceProviderFallbackRecoverySummary;
+export declare const summarizeVoiceSessionReplay: (options: VoiceSessionReplayOptions) => Promise<VoiceSessionReplay>;
+export declare const summarizeVoiceSessions: (options?: VoiceSessionListOptions) => Promise<VoiceSessionListItem[]>;
+export declare const renderVoiceSessionsHTML: (sessions: VoiceSessionListItem[]) => string;
+export declare const createVoiceSessionsJSONHandler: (options?: VoiceSessionListOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceSessionListItem[]>;
+export declare const createVoiceSessionsHTMLHandler: (options?: VoiceSessionListHTMLHandlerOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceSessionListRoutes: (options?: VoiceSessionListRoutesOptions) => 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: VoiceSessionListItem[];
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export declare const createVoiceSessionReplayJSONHandler: (options: Omit<VoiceSessionReplayOptions, "sessionId">) => ({ params }: {
+    params: Record<string, string | undefined>;
+}) => Promise<VoiceSessionReplay>;
+export declare const createVoiceSessionReplayHTMLHandler: (options: VoiceSessionReplayHTMLHandlerOptions) => ({ params }: {
+    params: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceSessionReplayRoutes: (options: VoiceSessionReplayRoutesOptions) => 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: VoiceSessionReplay;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/sessionSnapshot.d.ts

@@ -0,0 +1,98 @@
+import { Elysia } from 'elysia';
+import type { MediaProcessorGraphSnapshot } from '@absolutejs/media';
+import type { VoiceProofAssertionResult, VoiceProofAssertionSummary } from './proofAssertions';
+import type { VoiceCampaignTelephonyOutcomeSnapshot } from './campaign';
+import type { StoredVoiceTraceEvent } from './trace';
+export type VoiceSessionSnapshotStatus = 'fail' | 'pass' | 'warn';
+export type VoiceSessionSnapshotQualityEvidence = {
+    name: string;
+    report: unknown;
+    status?: VoiceSessionSnapshotStatus;
+};
+export type VoiceSessionSnapshot = {
+    capturedAt: number;
+    media: readonly MediaProcessorGraphSnapshot[];
+    name?: string;
+    proofAssertions: readonly VoiceProofAssertionResult[];
+    proofSummary: VoiceProofAssertionSummary;
+    providerRoutingEvents: readonly StoredVoiceTraceEvent[];
+    quality: readonly VoiceSessionSnapshotQualityEvidence[];
+    scenarioId?: string;
+    schema: 'absolute.voice.session.snapshot.v1';
+    sessionId: string;
+    status: VoiceSessionSnapshotStatus;
+    telephonyOutcomes: readonly VoiceCampaignTelephonyOutcomeSnapshot[];
+    turnId?: string;
+};
+export type VoiceSessionSnapshotInput = {
+    media?: readonly MediaProcessorGraphSnapshot[];
+    name?: string;
+    proofAssertions?: readonly VoiceProofAssertionResult[];
+    providerRoutingEvents?: readonly StoredVoiceTraceEvent[];
+    quality?: readonly VoiceSessionSnapshotQualityEvidence[];
+    scenarioId?: string;
+    sessionId: string;
+    telephonyOutcomes?: readonly VoiceCampaignTelephonyOutcomeSnapshot[];
+    turnId?: string;
+};
+export type VoiceSessionSnapshotRouteSourceInput = {
+    request: Request;
+    sessionId: string;
+    turnId?: string;
+};
+export type VoiceSessionSnapshotRouteSource = VoiceSessionSnapshot | VoiceSessionSnapshotInput | ((input: VoiceSessionSnapshotRouteSourceInput) => Promise<VoiceSessionSnapshot | VoiceSessionSnapshotInput> | VoiceSessionSnapshot | VoiceSessionSnapshotInput);
+export type VoiceSessionSnapshotRoutesOptions = Partial<VoiceSessionSnapshotInput> & {
+    downloadPath?: false | string;
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    source?: VoiceSessionSnapshotRouteSource;
+};
+export declare const buildVoiceSessionSnapshotStatus: (input: {
+    media?: readonly Pick<MediaProcessorGraphSnapshot, "report">[];
+    proofSummary?: Pick<VoiceProofAssertionSummary, "ok">;
+    quality?: readonly Pick<VoiceSessionSnapshotQualityEvidence, "status">[];
+    telephonyOutcomes?: readonly Pick<VoiceCampaignTelephonyOutcomeSnapshot, "campaignOutcome" | "duplicate">[];
+}) => VoiceSessionSnapshotStatus;
+export declare const buildVoiceSessionSnapshot: (input: VoiceSessionSnapshotInput) => VoiceSessionSnapshot;
+export declare const parseVoiceSessionSnapshot: (snapshot: VoiceSessionSnapshot) => VoiceSessionSnapshot;
+export declare const createVoiceSessionSnapshotRoutes: (options?: VoiceSessionSnapshotRoutesOptions) => 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/simulationSuite.d.ts

@@ -0,0 +1,143 @@
+import { Elysia } from 'elysia';
+import { type VoiceEvalReport, type VoiceEvalRoutesOptions, type VoiceScenarioEvalDefinition, type VoiceScenarioEvalReport, type VoiceScenarioFixture, type VoiceScenarioFixtureEvalReport, type VoiceScenarioFixtureStore } from './evalRoutes';
+import { type VoiceOutcomeContractDefinition, type VoiceOutcomeContractOptions, type VoiceOutcomeContractSuiteReport } from './outcomeContract';
+import { type VoiceToolContractDefinition, type VoiceToolContractSuiteReport } from './toolContract';
+import type { VoiceQualityThresholds } from './qualityRoutes';
+import type { VoiceTraceEventStore } from './trace';
+import type { VoiceSessionRecord } from './types';
+export type VoiceSimulationSuiteStatus = 'pass' | 'fail';
+export type VoiceSimulationSuiteReport = {
+    actions: VoiceSimulationSuiteAction[];
+    checkedAt: number;
+    failed: number;
+    fixtures?: VoiceScenarioFixtureEvalReport;
+    outcomes?: VoiceOutcomeContractSuiteReport;
+    passed: number;
+    scenarios?: VoiceScenarioEvalReport;
+    sessions?: VoiceEvalReport;
+    status: VoiceSimulationSuiteStatus;
+    summary: {
+        fixtures?: VoiceSimulationSuiteSectionSummary;
+        outcomes?: VoiceSimulationSuiteSectionSummary;
+        scenarios?: VoiceSimulationSuiteSectionSummary;
+        sessions?: VoiceSimulationSuiteSectionSummary;
+        tools?: VoiceSimulationSuiteSectionSummary;
+    };
+    tools?: VoiceToolContractSuiteReport;
+    total: number;
+};
+export type VoiceSimulationSuiteAction = {
+    description: string;
+    href?: string;
+    label: string;
+    section: 'fixtures' | 'outcomes' | 'scenarios' | 'sessions' | 'tools';
+    severity: 'error' | 'warning';
+};
+export type VoiceSimulationSuiteSectionSummary = {
+    failed: number;
+    passed: number;
+    status: VoiceSimulationSuiteStatus;
+    total: number;
+};
+export type VoiceSimulationSuiteSection = 'fixtures' | 'outcomes' | 'scenarios' | 'sessions' | 'tools';
+export type VoiceSimulationSuiteAssertionInput = {
+    maxActions?: number;
+    maxFailed?: number;
+    minPassed?: number;
+    minSections?: number;
+    requiredSections?: VoiceSimulationSuiteSection[];
+    sectionMinimums?: Partial<Record<VoiceSimulationSuiteSection, number>>;
+};
+export type VoiceSimulationSuiteAssertionReport = {
+    actions: number;
+    failed: number;
+    issues: string[];
+    ok: boolean;
+    passed: number;
+    sections: VoiceSimulationSuiteSection[];
+    sectionTotals: Partial<Record<VoiceSimulationSuiteSection, number>>;
+    status: VoiceSimulationSuiteStatus;
+    total: number;
+};
+export type VoiceSimulationSuiteOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    actionLinks?: {
+        fixtures?: string;
+        outcomes?: string;
+        scenarios?: string;
+        sessions?: string;
+        tools?: string;
+    };
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    include?: {
+        fixtures?: boolean;
+        outcomes?: boolean;
+        scenarios?: boolean;
+        sessions?: boolean;
+        tools?: boolean;
+    };
+    limit?: number;
+    operationsRecordHref?: false | string | ((sessionId: string) => string);
+    outcomes?: Omit<VoiceOutcomeContractOptions<TSession>, 'contracts'> & {
+        contracts: VoiceOutcomeContractDefinition[];
+    };
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+    tools?: VoiceToolContractDefinition[];
+};
+export type VoiceSimulationSuiteRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceSimulationSuiteOptions<TSession> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceSimulationSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export declare const runVoiceSimulationSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSimulationSuiteOptions<TSession>) => Promise<VoiceSimulationSuiteReport>;
+export declare const evaluateVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const assertVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const renderVoiceSimulationSuiteHTML: (report: VoiceSimulationSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceSimulationSuiteRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSimulationSuiteRoutesOptions<TSession>) => 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: VoiceSimulationSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceSimulationSuiteEvalRoutesOptions = VoiceEvalRoutesOptions;