@absolutejs/voice 0.0.22-beta.7 → 0.0.22-beta.70

package/dist/client/opsStatusWidget.d.ts

@@ -0,0 +1,40 @@
+import type { VoiceAppKitStatusReport } from '../appKit';
+import { type VoiceAppKitStatusClientOptions, type VoiceAppKitStatusSnapshot } from './appKitStatus';
+export type VoiceOpsStatusSurfaceView = {
+    detail: string;
+    failed: number;
+    id: string;
+    label: string;
+    status: 'pass' | 'fail';
+    total: number;
+};
+export type VoiceOpsStatusViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    links: Array<{
+        href: string;
+        label: string;
+    }>;
+    passed: number;
+    status: 'pass' | 'fail' | 'loading' | 'error';
+    surfaces: VoiceOpsStatusSurfaceView[];
+    title: string;
+    total: number;
+    updatedAt?: number;
+};
+export type VoiceOpsStatusWidgetOptions = VoiceAppKitStatusClientOptions & {
+    description?: string;
+    includeLinks?: boolean;
+    title?: string;
+};
+export declare const getVoiceOpsStatusLabel: (report?: VoiceAppKitStatusReport | null, error?: string | null) => "Passing" | "Unavailable" | "Checking" | "Needs attention";
+export declare const createVoiceOpsStatusViewModel: (snapshot: VoiceAppKitStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => VoiceOpsStatusViewModel;
+export declare const renderVoiceOpsStatusHTML: (snapshot: VoiceAppKitStatusSnapshot, options?: VoiceOpsStatusWidgetOptions) => string;
+export declare const getVoiceOpsStatusCSS: () => string;
+export declare const mountVoiceOpsStatus: (element: Element, path?: string, options?: VoiceOpsStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceAppKitStatusReport | undefined>;
+};
+export declare const defineVoiceOpsStatusElement: (tagName?: string) => void;

package/dist/client/providerCapabilities.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProviderCapabilityReport } from '../providerCapabilities';
+export type VoiceProviderCapabilitiesClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProviderCapabilitiesSnapshot<TProvider extends string = string> = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceProviderCapabilityReport<TProvider>;
+    updatedAt?: number;
+};
+export declare const fetchVoiceProviderCapabilities: <TProvider extends string = string>(path?: string, options?: Pick<VoiceProviderCapabilitiesClientOptions, "fetch">) => Promise<VoiceProviderCapabilityReport<TProvider>>;
+export declare const createVoiceProviderCapabilitiesStore: <TProvider extends string = string>(path?: string, options?: VoiceProviderCapabilitiesClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProviderCapabilitiesSnapshot<TProvider>;
+    getSnapshot: () => VoiceProviderCapabilitiesSnapshot<TProvider>;
+    refresh: () => Promise<VoiceProviderCapabilityReport<TProvider> | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/providerCapabilitiesWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceProviderCapabilitySummary } from '../providerCapabilities';
+import { type VoiceProviderCapabilitiesClientOptions, type VoiceProviderCapabilitiesSnapshot } from './providerCapabilities';
+export type VoiceProviderCapabilityCardView<TProvider extends string = string> = VoiceProviderCapabilitySummary<TProvider> & {
+    detail: string;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceProviderCapabilitiesViewModel<TProvider extends string = string> = {
+    capabilities: VoiceProviderCapabilityCardView<TProvider>[];
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    status: 'empty' | 'error' | 'loading' | 'ready' | 'warning';
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceProviderCapabilitiesWidgetOptions = VoiceProviderCapabilitiesClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceProviderCapabilitiesViewModel: <TProvider extends string = string>(snapshot: VoiceProviderCapabilitiesSnapshot<TProvider>, options?: VoiceProviderCapabilitiesWidgetOptions) => VoiceProviderCapabilitiesViewModel<TProvider>;
+export declare const renderVoiceProviderCapabilitiesHTML: <TProvider extends string = string>(snapshot: VoiceProviderCapabilitiesSnapshot<TProvider>, options?: VoiceProviderCapabilitiesWidgetOptions) => string;
+export declare const getVoiceProviderCapabilitiesCSS: () => string;
+export declare const mountVoiceProviderCapabilities: <TProvider extends string = string>(element: Element, path?: string, options?: VoiceProviderCapabilitiesWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceProviderCapabilityReport<TProvider> | undefined>;
+};
+export declare const defineVoiceProviderCapabilitiesElement: (tagName?: string) => void;

package/dist/client/providerSimulationControls.d.ts

@@ -0,0 +1,33 @@
+import type { VoiceIOProviderFailureSimulationMode, VoiceIOProviderFailureSimulationResult } from '../testing/ioProviderSimulator';
+export type VoiceProviderSimulationProvider<TProvider extends string = string> = {
+    configured?: boolean;
+    provider: TProvider;
+};
+export type VoiceProviderSimulationControlsOptions<TProvider extends string = string> = {
+    fallbackRequiredMessage?: string;
+    fallbackRequiredProvider?: TProvider;
+    failureMessage?: string;
+    failureProviders?: readonly TProvider[];
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    kind?: 'stt' | 'tts' | string;
+    pathPrefix?: string;
+    providers: readonly VoiceProviderSimulationProvider<TProvider>[];
+    recoveryMessage?: string;
+    title?: string;
+};
+export type VoiceProviderSimulationControlsSnapshot<TProvider extends string = string> = {
+    error: string | null;
+    isRunning: boolean;
+    lastResult: VoiceIOProviderFailureSimulationResult<TProvider> | null;
+    mode: VoiceIOProviderFailureSimulationMode | null;
+    provider: TProvider | null;
+    updatedAt?: number;
+};
+export declare const createVoiceProviderSimulationControlsStore: <TProvider extends string = string>(options: VoiceProviderSimulationControlsOptions<TProvider>) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProviderSimulationControlsSnapshot<TProvider>;
+    getSnapshot: () => VoiceProviderSimulationControlsSnapshot<TProvider>;
+    run: (provider: TProvider, mode: VoiceIOProviderFailureSimulationMode) => Promise<VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/providerSimulationControlsWidget.d.ts

@@ -0,0 +1,20 @@
+import { createVoiceProviderSimulationControlsStore, type VoiceProviderSimulationControlsOptions, type VoiceProviderSimulationControlsSnapshot, type VoiceProviderSimulationProvider } from './providerSimulationControls';
+export type VoiceProviderSimulationControlsViewModel<TProvider extends string = string> = {
+    canSimulateFailure: boolean;
+    description: string;
+    error: string | null;
+    failureProviders: VoiceProviderSimulationProvider<TProvider>[];
+    isRunning: boolean;
+    label: string;
+    providers: VoiceProviderSimulationProvider<TProvider>[];
+    resultText: string | null;
+    title: string;
+};
+export declare const createVoiceProviderSimulationControlsViewModel: <TProvider extends string = string>(snapshot: VoiceProviderSimulationControlsSnapshot<TProvider>, options: VoiceProviderSimulationControlsOptions<TProvider>) => VoiceProviderSimulationControlsViewModel<TProvider>;
+export declare const renderVoiceProviderSimulationControlsHTML: <TProvider extends string = string>(snapshot: VoiceProviderSimulationControlsSnapshot<TProvider>, options: VoiceProviderSimulationControlsOptions<TProvider>) => string;
+export declare const bindVoiceProviderSimulationControls: <TProvider extends string = string>(element: Element, store: ReturnType<typeof createVoiceProviderSimulationControlsStore<TProvider>>) => () => void;
+export declare const mountVoiceProviderSimulationControls: <TProvider extends string = string>(element: Element, options: VoiceProviderSimulationControlsOptions<TProvider>) => {
+    close: () => void;
+    run: (provider: TProvider, mode: import("../testing").VoiceIOProviderFailureSimulationMode) => Promise<import("../testing").VoiceIOProviderFailureSimulationResult<TProvider> | null>;
+};
+export declare const defineVoiceProviderSimulationControlsElement: (tagName?: string) => void;

package/dist/client/providerStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export type VoiceProviderStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProviderStatusSnapshot<TProvider extends string = string> = {
+    error: string | null;
+    isLoading: boolean;
+    providers: VoiceProviderHealthSummary<TProvider>[];
+    updatedAt?: number;
+};
+export declare const fetchVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: Pick<VoiceProviderStatusClientOptions, "fetch">) => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+export declare const createVoiceProviderStatusStore: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProviderStatusSnapshot<TProvider>;
+    getSnapshot: () => VoiceProviderStatusSnapshot<TProvider>;
+    refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/providerStatusWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+import { type VoiceProviderStatusClientOptions, type VoiceProviderStatusSnapshot } from './providerStatus';
+export type VoiceProviderStatusCardView<TProvider extends string = string> = VoiceProviderHealthSummary<TProvider> & {
+    detail: string;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceProviderStatusViewModel<TProvider extends string = string> = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    providers: VoiceProviderStatusCardView<TProvider>[];
+    status: 'empty' | 'error' | 'loading' | 'ready' | 'warning';
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceProviderStatusWidgetOptions = VoiceProviderStatusClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceProviderStatusViewModel: <TProvider extends string = string>(snapshot: VoiceProviderStatusSnapshot<TProvider>, options?: VoiceProviderStatusWidgetOptions) => VoiceProviderStatusViewModel<TProvider>;
+export declare const renderVoiceProviderStatusHTML: <TProvider extends string = string>(snapshot: VoiceProviderStatusSnapshot<TProvider>, options?: VoiceProviderStatusWidgetOptions) => string;
+export declare const getVoiceProviderStatusCSS: () => string;
+export declare const mountVoiceProviderStatus: <TProvider extends string = string>(element: Element, path?: string, options?: VoiceProviderStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+};
+export declare const defineVoiceProviderStatusElement: (tagName?: string) => void;

package/dist/client/routingStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceRoutingDecisionSummary } from '../resilienceRoutes';
+export type VoiceRoutingStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceRoutingStatusSnapshot = {
+    decision: VoiceRoutingDecisionSummary | null;
+    error: string | null;
+    isLoading: boolean;
+    updatedAt?: number;
+};
+export declare const fetchVoiceRoutingStatus: (path?: string, options?: Pick<VoiceRoutingStatusClientOptions, "fetch">) => Promise<import("..").VoiceRoutingEvent | null>;
+export declare const createVoiceRoutingStatusStore: (path?: string, options?: VoiceRoutingStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceRoutingStatusSnapshot;
+    getSnapshot: () => VoiceRoutingStatusSnapshot;
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/routingStatusWidget.d.ts

@@ -0,0 +1,28 @@
+import type { VoiceRoutingDecisionSummary } from '../resilienceRoutes';
+import { type VoiceRoutingStatusClientOptions, type VoiceRoutingStatusSnapshot } from './routingStatus';
+export type VoiceRoutingStatusViewModel = {
+    decision: VoiceRoutingDecisionSummary | null;
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+    status: 'empty' | 'error' | 'loading' | 'ready';
+    title: string;
+    updatedAt?: number;
+};
+export type VoiceRoutingStatusWidgetOptions = VoiceRoutingStatusClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceRoutingStatusViewModel: (snapshot: VoiceRoutingStatusSnapshot, options?: VoiceRoutingStatusWidgetOptions) => VoiceRoutingStatusViewModel;
+export declare const renderVoiceRoutingStatusHTML: (snapshot: VoiceRoutingStatusSnapshot, options?: VoiceRoutingStatusWidgetOptions) => string;
+export declare const getVoiceRoutingStatusCSS: () => string;
+export declare const mountVoiceRoutingStatus: (element: Element, path?: string, options?: VoiceRoutingStatusWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceRoutingEvent | null>;
+};
+export declare const defineVoiceRoutingStatusElement: (tagName?: string) => void;

package/dist/client/turnQuality.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceTurnQualityReport } from '../turnQuality';
+export type VoiceTurnQualityClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceTurnQualitySnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceTurnQualityReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceTurnQuality: (path?: string, options?: Pick<VoiceTurnQualityClientOptions, "fetch">) => Promise<VoiceTurnQualityReport>;
+export declare const createVoiceTurnQualityStore: (path?: string, options?: VoiceTurnQualityClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceTurnQualitySnapshot;
+    getSnapshot: () => VoiceTurnQualitySnapshot;
+    refresh: () => Promise<VoiceTurnQualityReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/turnQualityWidget.d.ts

@@ -0,0 +1,32 @@
+import type { VoiceTurnQualityItem } from '../turnQuality';
+import { type VoiceTurnQualityClientOptions, type VoiceTurnQualitySnapshot } from './turnQuality';
+export type VoiceTurnQualityCardView = VoiceTurnQualityItem & {
+    detail: string;
+    label: string;
+    rows: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export type VoiceTurnQualityViewModel = {
+    description: string;
+    error: string | null;
+    isLoading: boolean;
+    label: string;
+    status: 'empty' | 'error' | 'loading' | 'ready' | 'warning';
+    title: string;
+    turns: VoiceTurnQualityCardView[];
+    updatedAt?: number;
+};
+export type VoiceTurnQualityWidgetOptions = VoiceTurnQualityClientOptions & {
+    description?: string;
+    title?: string;
+};
+export declare const createVoiceTurnQualityViewModel: (snapshot: VoiceTurnQualitySnapshot, options?: VoiceTurnQualityWidgetOptions) => VoiceTurnQualityViewModel;
+export declare const renderVoiceTurnQualityHTML: (snapshot: VoiceTurnQualitySnapshot, options?: VoiceTurnQualityWidgetOptions) => string;
+export declare const getVoiceTurnQualityCSS: () => string;
+export declare const mountVoiceTurnQuality: (element: Element, path?: string, options?: VoiceTurnQualityWidgetOptions) => {
+    close: () => void;
+    refresh: () => Promise<import("..").VoiceTurnQualityReport | undefined>;
+};
+export declare const defineVoiceTurnQualityElement: (tagName?: string) => void;

package/dist/client/workflowStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export type VoiceWorkflowStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceWorkflowStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceScenarioEvalReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceWorkflowStatus: (path?: string, options?: Pick<VoiceWorkflowStatusClientOptions, "fetch">) => Promise<VoiceScenarioEvalReport>;
+export declare const createVoiceWorkflowStatusStore: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceWorkflowStatusSnapshot;
+    getSnapshot: () => VoiceWorkflowStatusSnapshot;
+    refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/diagnosticsRoutes.d.ts

@@ -0,0 +1,44 @@
+import { Elysia } from 'elysia';
+import { evaluateVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEventFilter, type VoiceTraceEventStore, type VoiceTraceRedactionConfig } from './trace';
+export type VoiceDiagnosticsRoutesOptions = {
+    evaluation?: Parameters<typeof evaluateVoiceTrace>[1];
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    redact?: VoiceTraceRedactionConfig;
+    store: VoiceTraceEventStore;
+    title?: string;
+};
+export declare const resolveVoiceDiagnosticsTraceFilter: (query: Record<string, unknown>) => VoiceTraceEventFilter;
+export declare const buildVoiceDiagnosticsMarkdown: (events: StoredVoiceTraceEvent[], options?: {
+    evaluation?: Parameters<typeof evaluateVoiceTrace>[1];
+    title?: string;
+}) => string;
+export declare const createVoiceDiagnosticsRoutes: (options: VoiceDiagnosticsRoutesOptions) => 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/evalRoutes.d.ts

@@ -0,0 +1,213 @@
+import { Elysia } from 'elysia';
+import { type VoiceQualityReport, type VoiceQualityThresholds } from './qualityRoutes';
+import { summarizeVoiceTrace, type StoredVoiceTraceEvent, type VoiceTraceEventStore } from './trace';
+export type VoiceEvalStatus = 'pass' | 'fail';
+export type VoiceEvalSessionReport = {
+    endedAt?: number;
+    eventCount: number;
+    quality: VoiceQualityReport;
+    scenarioId?: string;
+    sessionId: string;
+    startedAt?: number;
+    status: VoiceEvalStatus;
+    summary: ReturnType<typeof summarizeVoiceTrace>;
+};
+export type VoiceEvalTrendBucket = {
+    endedAt: number;
+    failed: number;
+    key: string;
+    passed: number;
+    total: number;
+};
+export type VoiceEvalReport = {
+    checkedAt: number;
+    failed: number;
+    passed: number;
+    sessions: VoiceEvalSessionReport[];
+    status: VoiceEvalStatus;
+    total: number;
+    trend: VoiceEvalTrendBucket[];
+};
+export type VoiceEvalBaselineSummary = {
+    failed: number;
+    failedSessionIds: string[];
+    passRate: number;
+    passed: number;
+    total: number;
+};
+export type VoiceEvalBaselineComparison = {
+    baseline: VoiceEvalBaselineSummary;
+    checkedAt: number;
+    current: VoiceEvalBaselineSummary;
+    deltas: {
+        failed: number;
+        passRate: number;
+        passed: number;
+        total: number;
+    };
+    newFailedSessionIds: string[];
+    recoveredSessionIds: string[];
+    reasons: string[];
+    status: VoiceEvalStatus;
+};
+export type VoiceEvalBaselineComparisonOptions = {
+    failOnNewFailedSessions?: boolean;
+    maxFailedDelta?: number;
+    maxPassRateDrop?: number;
+};
+export type VoiceEvalBaselineStore = {
+    get: () => Promise<VoiceEvalReport | undefined>;
+    set: (report: VoiceEvalReport) => Promise<void>;
+};
+export type VoiceScenarioEvalDefinition = {
+    description?: string;
+    forbiddenHandoffActions?: string[];
+    forbiddenLifecycleTypes?: string[];
+    id: string;
+    label?: string;
+    maxProviderErrors?: number;
+    maxSessionErrors?: number;
+    minSessions?: number;
+    minTurns?: number;
+    requiredAssistantIncludes?: string[];
+    requiredDisposition?: string;
+    requiredHandoffActions?: string[];
+    requiredLifecycleTypes?: string[];
+    requiredPayloadPaths?: string[];
+    requiredTranscriptIncludes?: string[];
+    requiredWorkflowContracts?: string[];
+    scenarioId?: string;
+};
+export type VoiceScenarioEvalSessionResult = {
+    eventCount: number;
+    issues: string[];
+    sessionId: string;
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioEvalResult = {
+    description?: string;
+    failed: number;
+    id: string;
+    issues: string[];
+    label: string;
+    matchedSessions: number;
+    passed: number;
+    sessions: VoiceScenarioEvalSessionResult[];
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioEvalReport = {
+    checkedAt: number;
+    failed: number;
+    passed: number;
+    scenarios: VoiceScenarioEvalResult[];
+    status: VoiceEvalStatus;
+    total: number;
+};
+export type VoiceScenarioFixture = {
+    description?: string;
+    events: StoredVoiceTraceEvent[];
+    id: string;
+    label?: string;
+};
+export type VoiceScenarioFixtureStore = {
+    list: () => Promise<VoiceScenarioFixture[]>;
+};
+export type VoiceScenarioFixtureEvalResult = {
+    description?: string;
+    fixtureId: string;
+    label: string;
+    report: VoiceScenarioEvalReport;
+    status: VoiceEvalStatus;
+};
+export type VoiceScenarioFixtureEvalReport = {
+    checkedAt: number;
+    failed: number;
+    fixtures: VoiceScenarioFixtureEvalResult[];
+    passed: number;
+    status: VoiceEvalStatus;
+    total: number;
+};
+export type VoiceEvalLink = {
+    href: string;
+    label: string;
+};
+export type VoiceEvalRoutesOptions = {
+    baseline?: VoiceEvalReport | (() => Promise<VoiceEvalReport | undefined>);
+    baselineComparison?: VoiceEvalBaselineComparisonOptions;
+    baselineStore?: VoiceEvalBaselineStore;
+    events?: StoredVoiceTraceEvent[];
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    headers?: HeadersInit;
+    links?: VoiceEvalLink[];
+    limit?: number;
+    name?: string;
+    path?: string;
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+    title?: string;
+};
+export declare const runVoiceSessionEvals: (options?: {
+    events?: StoredVoiceTraceEvent[];
+    limit?: number;
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+}) => Promise<VoiceEvalReport>;
+export declare const runVoiceScenarioEvals: (options?: {
+    events?: StoredVoiceTraceEvent[];
+    scenarios?: VoiceScenarioEvalDefinition[];
+    store?: VoiceTraceEventStore;
+}) => Promise<VoiceScenarioEvalReport>;
+export declare const runVoiceScenarioFixtureEvals: (options?: {
+    fixtures?: VoiceScenarioFixture[];
+    fixtureStore?: VoiceScenarioFixtureStore;
+    scenarios?: VoiceScenarioEvalDefinition[];
+}) => Promise<VoiceScenarioFixtureEvalReport>;
+export declare const compareVoiceEvalBaseline: (currentReport: VoiceEvalReport, baselineReport: VoiceEvalReport, options?: VoiceEvalBaselineComparisonOptions) => VoiceEvalBaselineComparison;
+export declare const createVoiceFileEvalBaselineStore: (filePath: string) => VoiceEvalBaselineStore;
+export declare const createVoiceFileScenarioFixtureStore: (filePath: string) => VoiceScenarioFixtureStore;
+export declare const renderVoiceEvalHTML: (report: VoiceEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceEvalBaselineHTML: (comparison: VoiceEvalBaselineComparison, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceScenarioEvalHTML: (report: VoiceScenarioEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const renderVoiceScenarioFixtureEvalHTML: (report: VoiceScenarioFixtureEvalReport, options?: {
+    links?: VoiceEvalLink[];
+    title?: string;
+}) => string;
+export declare const createVoiceEvalRoutes: (options: VoiceEvalRoutesOptions) => 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/handoff.d.ts

@@ -0,0 +1,54 @@
+import type { VoiceHandoffAction, VoiceHandoffAdapter, VoiceHandoffConfig, VoiceHandoffDeliveryStore, VoiceHandoffInput, VoiceHandoffResult, VoiceSessionRecord, StoredVoiceHandoffDelivery } from './types';
+type MaybePromise<T> = T | Promise<T>;
+export type VoiceHandoffDelivery = VoiceHandoffResult & {
+    adapterId: string;
+    adapterKind?: string;
+};
+export type VoiceHandoffDeliveryRecord<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = StoredVoiceHandoffDelivery<TContext, TSession, TResult>;
+export type VoiceHandoffFanoutResult = {
+    action: VoiceHandoffAction;
+    deliveries: Record<string, VoiceHandoffDelivery>;
+    status: VoiceHandoffResult['status'];
+};
+export type VoiceHandoffDeliveryRecordInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceHandoffInput<TContext, TSession, TResult>, 'api'> & {
+    id?: string;
+};
+export type VoiceQueuedHandoffDeliveryOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
+    api: VoiceHandoffInput<TContext, TSession, TResult>['api'];
+    delivery: VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+    failMode?: VoiceHandoffConfig<TContext, TSession, TResult>['failMode'];
+};
+export type VoiceWebhookHandoffAdapterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    actions?: VoiceHandoffAction[];
+    body?: (input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<Record<string, unknown>>;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    id: string;
+    kind?: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    signingSecret?: string;
+    timeoutMs?: number;
+    url: string;
+};
+export type VoiceTwilioRedirectHandoffAdapterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    accountSid: string;
+    actions?: VoiceHandoffAction[];
+    authToken: string;
+    buildTwiML?: (input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<string>;
+    callSid?: string | ((input: VoiceHandoffInput<TContext, TSession, TResult>) => MaybePromise<string | undefined>);
+    fetch?: typeof fetch;
+    id?: string;
+    timeoutMs?: number;
+};
+export declare const deliverVoiceHandoff: <TContext, TSession extends VoiceSessionRecord, TResult>(input: {
+    config?: VoiceHandoffConfig<TContext, TSession, TResult>;
+    handoff: VoiceHandoffInput<TContext, TSession, TResult>;
+}) => Promise<VoiceHandoffFanoutResult | undefined>;
+export declare const createVoiceHandoffDeliveryRecord: <TContext, TSession extends VoiceSessionRecord, TResult>(input: VoiceHandoffDeliveryRecordInput<TContext, TSession, TResult>) => VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+export declare const applyVoiceHandoffDeliveryResult: <TContext, TSession extends VoiceSessionRecord, TResult>(delivery: VoiceHandoffDeliveryRecord<TContext, TSession, TResult>, result: VoiceHandoffFanoutResult) => VoiceHandoffDeliveryRecord<TContext, TSession, TResult>;
+export declare const deliverVoiceHandoffDelivery: <TContext, TSession extends VoiceSessionRecord, TResult>(options: VoiceQueuedHandoffDeliveryOptions<TContext, TSession, TResult>) => Promise<VoiceHandoffDeliveryRecord<TContext, TSession, TResult>>;
+export declare const createVoiceMemoryHandoffDeliveryStore: <TDelivery extends VoiceHandoffDeliveryRecord = VoiceHandoffDeliveryRecord>() => VoiceHandoffDeliveryStore<TDelivery>;
+export declare const createVoiceWebhookHandoffAdapter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceWebhookHandoffAdapterOptions<TContext, TSession, TResult>) => VoiceHandoffAdapter<TContext, TSession, TResult>;
+export declare const createVoiceTwilioRedirectHandoffAdapter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceTwilioRedirectHandoffAdapterOptions<TContext, TSession, TResult>) => VoiceHandoffAdapter<TContext, TSession, TResult>;
+export {};