@absolutejs/voice 0.0.22-beta.54 → 0.0.22-beta.540

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/semanticTurn.d.ts

@@ -0,0 +1,27 @@
+import type { Transcript } from "./types";
+export type VoiceSemanticTurnInput = {
+    audioLevel?: number;
+    lastFinalTranscript?: Transcript;
+    partialText: string;
+    silenceMs: number;
+    transcripts: Transcript[];
+};
+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;

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

@@ -1,5 +1,5 @@
-import { Elysia } from 'elysia';
-import { type StoredVoiceTraceEvent, type VoiceTraceEvaluationOptions, type VoiceTraceEventStore, type VoiceTraceRedactionConfig, type VoiceTraceSummary, type VoiceTraceEvaluation } from './trace';
+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;
@@ -24,16 +24,17 @@ export type VoiceSessionReplay = {
         offsetMs?: number;
         payload: Record<string, unknown>;
         turnId?: string;
-        type: StoredVoiceTraceEvent['type'];
+        type: StoredVoiceTraceEvent["type"];
     }>;
     turns: VoiceSessionReplayTurn[];
 };
-export type VoiceSessionListStatus = 'failed' | 'healthy';
+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;
@@ -43,13 +44,23 @@ export type VoiceSessionListItem = {
     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';
+    replayHref?: false | string | ((session: Omit<VoiceSessionListItem, "replayHref">) => string);
+    status?: VoiceSessionListStatus | "all";
     store?: VoiceTraceEventStore;
 };
 export type VoiceSessionListHTMLHandlerOptions = VoiceSessionListOptions & {
@@ -69,7 +80,7 @@ export type VoiceSessionReplayOptions = {
     store?: VoiceTraceEventStore;
     title?: string;
 };
-export type VoiceSessionReplayHTMLHandlerOptions = Omit<VoiceSessionReplayOptions, 'sessionId'> & {
+export type VoiceSessionReplayHTMLHandlerOptions = Omit<VoiceSessionReplayOptions, "sessionId"> & {
     headers?: HeadersInit;
     render?: (replay: VoiceSessionReplay) => string | Promise<string>;
 };
@@ -78,15 +89,7 @@ export type VoiceSessionReplayRoutesOptions = VoiceSessionReplayHTMLHandlerOptio
     name?: string;
     path?: string;
 };
-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 summarizeVoiceProviderFallbackRecovery: (events: StoredVoiceTraceEvent[]) => VoiceProviderFallbackRecoverySummary;
 export declare const createVoiceSessionListRoutes: (options?: VoiceSessionListRoutesOptions) => Elysia<"", {
     decorator: {};
     store: {};
@@ -127,12 +130,12 @@ export declare const createVoiceSessionListRoutes: (options?: VoiceSessionListRo
     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 createVoiceSessionReplayJSONHandler: (options: Omit<VoiceSessionReplayOptions, "sessionId">) => ({ params }: {
+    params: Record<string, string | undefined>;
+}) => Promise<VoiceSessionReplay>;
 export declare const createVoiceSessionReplayRoutes: (options: VoiceSessionReplayRoutesOptions) => Elysia<"", {
     decorator: {};
     store: {};
@@ -173,3 +176,12 @@ export declare const createVoiceSessionReplayRoutes: (options: VoiceSessionRepla
     standaloneSchema: {};
     response: {};
 }>;
+export declare const createVoiceSessionsHTMLHandler: (options?: VoiceSessionListHTMLHandlerOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceSessionsJSONHandler: (options?: VoiceSessionListOptions) => ({ query }: {
+    query?: Record<string, string | undefined>;
+}) => Promise<VoiceSessionListItem[]>;
+export declare const renderVoiceSessionsHTML: (sessions: VoiceSessionListItem[]) => string;
+export declare const summarizeVoiceSessionReplay: (options: VoiceSessionReplayOptions) => Promise<VoiceSessionReplay>;
+export declare const summarizeVoiceSessions: (options?: VoiceSessionListOptions) => Promise<VoiceSessionListItem[]>;

package/dist/core/sessionSnapshot.d.ts

@@ -0,0 +1,109 @@
+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 VoiceSessionSnapshotArtifactKind = "failure-replay" | "incident-bundle" | "operations-record" | "provider-fallback" | "trace" | "custom";
+export type VoiceSessionSnapshotArtifact = {
+    href?: string;
+    kind: VoiceSessionSnapshotArtifactKind;
+    label: string;
+    report?: unknown;
+    status?: VoiceSessionSnapshotStatus;
+};
+export type VoiceSessionSnapshot = {
+    artifacts: readonly VoiceSessionSnapshotArtifact[];
+    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 = {
+    artifacts?: readonly VoiceSessionSnapshotArtifact[];
+    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 buildVoiceSessionSnapshot: (input: VoiceSessionSnapshotInput) => VoiceSessionSnapshot;
+export declare const buildVoiceSessionSnapshotStatus: (input: {
+    artifacts?: readonly Pick<VoiceSessionSnapshotArtifact, "status">[];
+    media?: readonly Pick<MediaProcessorGraphSnapshot, "report">[];
+    proofSummary?: Pick<VoiceProofAssertionSummary, "ok">;
+    quality?: readonly Pick<VoiceSessionSnapshotQualityEvidence, "status">[];
+    telephonyOutcomes?: readonly Pick<VoiceCampaignTelephonyOutcomeSnapshot, "campaignOutcome" | "duplicate">[];
+}) => VoiceSessionSnapshotStatus;
+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/core/simulationSuite.d.ts

@@ -0,0 +1,144 @@
+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;
+};
+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 assertVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const evaluateVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+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 declare const renderVoiceSimulationSuiteHTML: (report: VoiceSimulationSuiteReport, options?: {
+    title?: string;
+}) => string;
+export type VoiceSimulationSuiteEvalRoutesOptions = VoiceEvalRoutesOptions;
+export {};