@absolutejs/voice 0.0.22-beta.29 → 0.0.22-beta.290

package/dist/providerAdapters.d.ts

@@ -0,0 +1,48 @@
+import type { STTAdapter, STTAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from './types';
+import type { VoiceProviderRouterHealthOptions, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceProviderRouterPolicyPreset, VoiceProviderRouterPolicyWeights, VoiceProviderRouterStrategy } from './modelAdapters';
+type MaybePromise<T> = T | Promise<T>;
+type VoiceIOProviderKind = 'stt' | 'tts';
+type VoiceIOProviderStatus = 'error' | 'fallback' | 'success';
+export type VoiceIOProviderRouterEvent<TProvider extends string = string> = {
+    at: number;
+    attempt: number;
+    elapsedMs: number;
+    error?: string;
+    fallbackProvider?: TProvider;
+    kind: VoiceIOProviderKind;
+    latencyBudgetMs?: number;
+    operation: 'open' | 'send';
+    provider: TProvider;
+    providerHealth?: VoiceProviderRouterProviderHealth<TProvider>;
+    selectedProvider: TProvider;
+    status: VoiceIOProviderStatus;
+    suppressionRemainingMs?: number;
+    suppressedUntil?: number;
+    timedOut?: boolean;
+};
+export type VoiceIOProviderRouterPolicyConfig<TOpenOptions = unknown, TProvider extends string = string> = {
+    allowProviders?: readonly TProvider[] | ((input: TOpenOptions) => MaybePromise<readonly TProvider[]>);
+    maxCost?: number;
+    maxLatencyMs?: number;
+    minQuality?: number;
+    scoreProvider?: (provider: TProvider, profile: VoiceProviderRouterProviderProfile | undefined) => number;
+    strategy?: VoiceProviderRouterStrategy;
+    weights?: VoiceProviderRouterPolicyWeights;
+};
+export type VoiceIOProviderRouterPolicy<TOpenOptions = unknown, TProvider extends string = string> = VoiceProviderRouterStrategy | VoiceProviderRouterPolicyPreset | VoiceIOProviderRouterPolicyConfig<TOpenOptions, TProvider>;
+export type VoiceIOProviderRouterOptions<TProvider extends string, TAdapter, TOpenOptions> = {
+    adapters: Partial<Record<TProvider, TAdapter>>;
+    fallback?: readonly TProvider[] | ((input: TOpenOptions) => MaybePromise<readonly TProvider[]>);
+    isProviderError?: (error: unknown, provider: TProvider) => boolean;
+    onProviderEvent?: (event: VoiceIOProviderRouterEvent<TProvider>, input: TOpenOptions) => Promise<void> | void;
+    policy?: VoiceIOProviderRouterPolicy<TOpenOptions, TProvider>;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
+    selectProvider?: (input: TOpenOptions) => MaybePromise<TProvider | undefined>;
+    timeoutMs?: number;
+};
+export type VoiceSTTProviderRouterOptions<TProvider extends string = string, TOptions extends STTAdapterOpenOptions = STTAdapterOpenOptions> = VoiceIOProviderRouterOptions<TProvider, STTAdapter<TOptions>, TOptions>;
+export type VoiceTTSProviderRouterOptions<TProvider extends string = string, TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions> = VoiceIOProviderRouterOptions<TProvider, TTSAdapter<TOptions>, TOptions>;
+export declare const createVoiceSTTProviderRouter: <TProvider extends string = string, TOptions extends STTAdapterOpenOptions = STTAdapterOpenOptions>(options: VoiceSTTProviderRouterOptions<TProvider, TOptions>) => STTAdapter<TOptions>;
+export declare const createVoiceTTSProviderRouter: <TProvider extends string = string, TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions>(options: VoiceTTSProviderRouterOptions<TProvider, TOptions>) => TTSAdapter<TOptions>;
+export {};

package/dist/providerCapabilities.d.ts

@@ -0,0 +1,92 @@
+import { Elysia } from 'elysia';
+import { type VoiceProviderHealthStatus, type VoiceProviderHealthSummary, type VoiceProviderHealthSummaryOptions } from './providerHealth';
+export type VoiceProviderCapabilityKind = 'llm' | 'stt' | 'tts' | 'custom';
+export type VoiceProviderCapabilityDefinition<TProvider extends string = string> = {
+    configured?: boolean;
+    description?: string;
+    features?: string[];
+    kind: VoiceProviderCapabilityKind;
+    label?: string;
+    model?: string;
+    provider: TProvider;
+    selected?: boolean;
+};
+export type VoiceProviderCapabilitySummary<TProvider extends string = string> = VoiceProviderCapabilityDefinition<TProvider> & {
+    configured: boolean;
+    health?: VoiceProviderHealthSummary<TProvider>;
+    status: VoiceProviderHealthStatus | 'selected' | 'unconfigured';
+};
+export type VoiceProviderCapabilityReport<TProvider extends string = string> = {
+    capabilities: VoiceProviderCapabilitySummary<TProvider>[];
+    checkedAt: number;
+    configured: number;
+    selected: number;
+    total: number;
+    unconfigured: number;
+};
+export type VoiceProviderCapabilityOptions<TProvider extends string = string> = VoiceProviderHealthSummaryOptions<TProvider> & {
+    features?: Partial<Record<TProvider, string[]>>;
+    llmProviders?: readonly TProvider[];
+    models?: Partial<Record<TProvider, string>>;
+    providers?: readonly VoiceProviderCapabilityDefinition<TProvider>[];
+    selected?: Partial<Record<VoiceProviderCapabilityKind, TProvider>>;
+    sttProviders?: readonly TProvider[];
+    ttsProviders?: readonly TProvider[];
+};
+export type VoiceProviderCapabilityHandlerOptions<TProvider extends string = string> = VoiceProviderCapabilityOptions<TProvider>;
+export type VoiceProviderCapabilityHTMLHandlerOptions<TProvider extends string = string> = VoiceProviderCapabilityHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (report: VoiceProviderCapabilityReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderCapabilityRoutesOptions<TProvider extends string = string> = VoiceProviderCapabilityHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceProviderCapabilities: <TProvider extends string = string>(options: VoiceProviderCapabilityOptions<TProvider>) => Promise<VoiceProviderCapabilityReport<TProvider>>;
+export declare const renderVoiceProviderCapabilityHTML: <TProvider extends string = string>(report: VoiceProviderCapabilityReport<TProvider>, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProviderCapabilityJSONHandler: <TProvider extends string = string>(options: VoiceProviderCapabilityHandlerOptions<TProvider>) => () => Promise<VoiceProviderCapabilityReport<TProvider>>;
+export declare const createVoiceProviderCapabilityHTMLHandler: <TProvider extends string = string>(options: VoiceProviderCapabilityHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceProviderCapabilityRoutes: <TProvider extends string = string>(options: VoiceProviderCapabilityRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceProviderCapabilityReport<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/providerHealth.d.ts

@@ -15,6 +15,7 @@ export type VoiceProviderHealthSummary<TProvider extends string = string> = {
     status: VoiceProviderHealthStatus;
     suppressionRemainingMs?: number;
     suppressedUntil?: number;
+    timeoutCount: number;
 };
 export type VoiceProviderHealthSummaryOptions<TProvider extends string = string> = {
     events?: StoredVoiceTraceEvent[];

package/dist/providerRoutingContract.d.ts

@@ -0,0 +1,71 @@
+import { type VoiceRoutingEvent, type VoiceRoutingEventKind } from './resilienceRoutes';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceProviderRoutingStatus = 'error' | 'fallback' | 'success';
+export type VoiceProviderRoutingExpectation = {
+    fallbackProvider?: string;
+    kind?: VoiceRoutingEventKind;
+    operation?: string;
+    provider?: string;
+    selectedProvider?: string;
+    status?: VoiceProviderRoutingStatus;
+};
+export type VoiceProviderRoutingContractDefinition = {
+    description?: string;
+    expect: VoiceProviderRoutingExpectation[];
+    id: string;
+    label?: string;
+    scenarioId?: string;
+    sessionId?: string;
+};
+export type VoiceProviderRoutingContractIssue = {
+    code: string;
+    message: string;
+};
+export type VoiceProviderRoutingContractReport = {
+    contractId: string;
+    events: VoiceRoutingEvent[];
+    issues: VoiceProviderRoutingContractIssue[];
+    pass: boolean;
+    scenarioId?: string;
+    sessionId?: string;
+};
+export type VoiceProviderRoutingContractRunOptions = {
+    contract: VoiceProviderRoutingContractDefinition;
+    events?: StoredVoiceTraceEvent[] | VoiceRoutingEvent[];
+    store?: VoiceTraceEventStore;
+};
+export type VoiceProviderRoutingContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    minContracts?: number;
+    minEvents?: number;
+    requiredContractIds?: string[];
+    requiredFallbackProviders?: string[];
+    requiredKinds?: VoiceRoutingEventKind[];
+    requiredOperations?: string[];
+    requiredProviders?: string[];
+    requiredScenarioIds?: string[];
+    requiredSelectedProviders?: string[];
+    requiredStatuses?: VoiceProviderRoutingStatus[];
+};
+export type VoiceProviderRoutingContractAssertionReport = {
+    contractIds: string[];
+    events: number;
+    failed: number;
+    fallbackProviders: string[];
+    issues: string[];
+    issueCount: number;
+    kinds: VoiceRoutingEventKind[];
+    ok: boolean;
+    operations: string[];
+    passed: number;
+    providers: string[];
+    scenarioIds: string[];
+    selectedProviders: string[];
+    statuses: VoiceProviderRoutingStatus[];
+    total: number;
+};
+export declare const runVoiceProviderRoutingContract: (options: VoiceProviderRoutingContractRunOptions) => Promise<VoiceProviderRoutingContractReport>;
+export declare const assertVoiceProviderRoutingContract: (options: VoiceProviderRoutingContractRunOptions) => Promise<VoiceProviderRoutingContractReport>;
+export declare const evaluateVoiceProviderRoutingContractEvidence: (reports: readonly VoiceProviderRoutingContractReport[], input?: VoiceProviderRoutingContractAssertionInput) => VoiceProviderRoutingContractAssertionReport;
+export declare const assertVoiceProviderRoutingContractEvidence: (reports: readonly VoiceProviderRoutingContractReport[], input?: VoiceProviderRoutingContractAssertionInput) => VoiceProviderRoutingContractAssertionReport;

package/dist/providerSlo.d.ts

@@ -0,0 +1,142 @@
+import { Elysia } from 'elysia';
+import { type VoiceRoutingEvent, type VoiceRoutingEventKind } from './resilienceRoutes';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceProviderSloStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProviderSloThresholds = {
+    maxAverageElapsedMs?: number;
+    maxErrorRate?: number;
+    maxFallbackRate?: number;
+    maxP95ElapsedMs?: number;
+    maxTimeoutRate?: number;
+    minSamples?: number;
+};
+export type VoiceProviderSloThresholdConfig = Partial<Record<VoiceRoutingEventKind, VoiceProviderSloThresholds>>;
+export type VoiceProviderSloMetric = {
+    actual: number;
+    label: string;
+    pass: boolean;
+    threshold: number;
+    unit: 'count' | 'ms' | 'rate';
+};
+export type VoiceProviderSloIssue = {
+    code: string;
+    detail?: string;
+    kind?: VoiceRoutingEventKind;
+    label: string;
+    sessionId?: string;
+    status: Exclude<VoiceProviderSloStatus, 'pass'>;
+    value?: number | string;
+};
+export type VoiceProviderSloKindReport = {
+    events: number;
+    eventsWithLatency: number;
+    fallbacks: number;
+    issues: VoiceProviderSloIssue[];
+    kind: VoiceRoutingEventKind;
+    metrics: Record<string, VoiceProviderSloMetric>;
+    providers: string[];
+    status: VoiceProviderSloStatus;
+    thresholds: Required<VoiceProviderSloThresholds>;
+    timeouts: number;
+    unresolvedErrors: number;
+};
+export type VoiceProviderSloSessionReport = {
+    errorCount: number;
+    fallbackCount: number;
+    kinds: VoiceRoutingEventKind[];
+    lastEventAt: number;
+    maxElapsedMs?: number;
+    sessionId: string;
+    status: VoiceProviderSloStatus;
+    timeoutCount: number;
+};
+export type VoiceProviderSloReport = {
+    checkedAt: number;
+    events: number;
+    eventsWithLatency: number;
+    issues: VoiceProviderSloIssue[];
+    kinds: Record<VoiceRoutingEventKind, VoiceProviderSloKindReport>;
+    sessions: VoiceProviderSloSessionReport[];
+    status: VoiceProviderSloStatus;
+    thresholds: Record<VoiceRoutingEventKind, Required<VoiceProviderSloThresholds>>;
+};
+export type VoiceProviderSloReportOptions = {
+    events?: StoredVoiceTraceEvent[] | VoiceRoutingEvent[];
+    maxAgeMs?: number;
+    now?: number;
+    requiredKinds?: readonly VoiceRoutingEventKind[];
+    scenarioId?: string;
+    sessionId?: string;
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceProviderSloThresholdConfig;
+};
+export type VoiceProviderSloRoutesOptions = VoiceProviderSloReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceProviderSloReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderSloAssertionInput = {
+    fallbackKinds?: VoiceRoutingEventKind[];
+    maxAverageElapsedMs?: Partial<Record<VoiceRoutingEventKind, number>>;
+    maxIssues?: number;
+    maxP95ElapsedMs?: Partial<Record<VoiceRoutingEventKind, number>>;
+    maxStatus?: VoiceProviderSloStatus;
+    maxTimeouts?: number;
+    maxUnresolvedErrors?: number;
+    minEvents?: number;
+    minFallbacks?: number;
+    minLatencySamples?: number;
+    requiredKinds?: VoiceRoutingEventKind[];
+    requiredProviders?: string[];
+};
+export type VoiceProviderSloAssertionReport = {
+    events: number;
+    eventsWithLatency: number;
+    fallbacks: number;
+    issues: string[];
+    kinds: VoiceRoutingEventKind[];
+    ok: boolean;
+    providers: string[];
+    status: VoiceProviderSloStatus;
+    timeouts: number;
+    unresolvedErrors: number;
+};
+export declare const buildVoiceProviderSloReport: (options?: VoiceProviderSloReportOptions) => Promise<VoiceProviderSloReport>;
+export declare const evaluateVoiceProviderSloEvidence: (report: VoiceProviderSloReport, input?: VoiceProviderSloAssertionInput) => VoiceProviderSloAssertionReport;
+export declare const assertVoiceProviderSloEvidence: (report: VoiceProviderSloReport, input?: VoiceProviderSloAssertionInput) => VoiceProviderSloAssertionReport;
+export declare const renderVoiceProviderSloMarkdown: (report: VoiceProviderSloReport) => string;
+export declare const renderVoiceProviderSloHTML: (report: VoiceProviderSloReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProviderSloRoutes: (options: VoiceProviderSloRoutesOptions) => 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/providerStackRecommendations.d.ts

@@ -0,0 +1,187 @@
+import { Elysia } from 'elysia';
+import type { VoiceReadinessProfileName } from './readinessProfiles';
+export type VoiceProviderStackKind = 'llm' | 'stt' | 'tts';
+export type VoiceProviderStackInput<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+};
+export type VoiceProviderStackChoice<TProvider extends string = string> = {
+    alternatives: TProvider[];
+    provider?: TProvider;
+    reasons: string[];
+};
+export type VoiceProviderStackRecommendation<TProvider extends string = string> = {
+    profile: VoiceReadinessProfileName;
+    reasons: string[];
+    recommended: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    stacks: Partial<Record<VoiceProviderStackKind, VoiceProviderStackChoice<TProvider>>>;
+};
+export type VoiceProviderStackCapabilities<TProvider extends string = string> = Partial<Record<VoiceProviderStackKind, Partial<Record<TProvider, readonly string[]>>>>;
+export type VoiceProviderStackCapabilityGap<TProvider extends string = string> = {
+    kind: VoiceProviderStackKind;
+    missing: string[];
+    present: string[];
+    provider?: TProvider;
+    required: string[];
+    status: 'fail' | 'pass' | 'warn';
+};
+export type VoiceProviderStackCapabilityGapReport<TProvider extends string = string> = {
+    gaps: VoiceProviderStackCapabilityGap<TProvider>[];
+    missing: number;
+    profile: VoiceReadinessProfileName;
+    status: 'fail' | 'pass' | 'warn';
+};
+export type VoiceProviderStackAssertionInput<TProvider extends string = string> = {
+    maxMissing?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    requireProviders?: boolean;
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    requiredCapabilities?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderStackAssertionReport<TProvider extends string = string> = {
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    missing: number;
+    ok: boolean;
+    providers: TProvider[];
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderStackCapabilityGapInput<TProvider extends string = string> = VoiceProviderStackInput<TProvider> & {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    recommendation?: VoiceProviderStackRecommendation<TProvider>;
+    required?: Partial<Record<VoiceProviderStackKind, readonly string[]>>;
+};
+export type VoiceProviderContractCheckStatus = 'fail' | 'pass' | 'warn';
+export type VoiceProviderContractRemediation = {
+    code: string;
+    detail: string;
+    href?: string;
+    label: string;
+};
+export type VoiceProviderContractCheck = {
+    detail?: string;
+    key: string;
+    label: string;
+    remediation?: VoiceProviderContractRemediation;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractDefinition<TProvider extends string = string> = {
+    capabilities?: readonly string[];
+    configured?: boolean;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: readonly TProvider[];
+    kind: VoiceProviderStackKind;
+    latencyBudgetMs?: number;
+    provider: TProvider;
+    requiredCapabilities?: readonly string[];
+    requiredEnv?: readonly string[];
+    remediationHref?: string;
+    selected?: boolean;
+    streaming?: boolean;
+};
+export type VoiceProviderContractMatrixInput<TProvider extends string = string> = {
+    contracts: readonly VoiceProviderContractDefinition<TProvider>[];
+};
+export type VoiceProviderContractMatrixPresetOptions<TProvider extends string = string> = {
+    capabilities?: VoiceProviderStackCapabilities<TProvider>;
+    configured?: Partial<Record<TProvider, boolean>>;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    latencyBudgets?: Partial<Record<TProvider, number>>;
+    providers: Partial<Record<VoiceProviderStackKind, readonly TProvider[]>>;
+    remediationHref?: string;
+    selected?: Partial<Record<VoiceProviderStackKind, TProvider>>;
+    streaming?: Partial<Record<TProvider, boolean>>;
+};
+export type VoiceProviderContractMatrixHandlerOptions<TProvider extends string = string> = VoiceProviderContractMatrixInput<TProvider> | (() => Promise<VoiceProviderContractMatrixInput<TProvider>> | VoiceProviderContractMatrixInput<TProvider>);
+export type VoiceProviderContractMatrixHTMLHandlerOptions<TProvider extends string = string> = {
+    matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>;
+    render?: (report: VoiceProviderContractMatrixReport<TProvider>) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceProviderContractMatrixRoutesOptions<TProvider extends string = string> = VoiceProviderContractMatrixHTMLHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export type VoiceProviderContractMatrixRow<TProvider extends string = string> = {
+    checks: VoiceProviderContractCheck[];
+    configured: boolean;
+    kind: VoiceProviderStackKind;
+    provider: TProvider;
+    selected: boolean;
+    status: VoiceProviderContractCheckStatus;
+};
+export type VoiceProviderContractMatrixReport<TProvider extends string = string> = {
+    failed: number;
+    passed: number;
+    rows: VoiceProviderContractMatrixRow<TProvider>[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export type VoiceProviderContractMatrixAssertionInput<TProvider extends string = string> = {
+    maxFailed?: number;
+    maxStatus?: VoiceProviderContractCheckStatus;
+    maxWarned?: number;
+    minRows?: number;
+    requireAllSelected?: boolean;
+    requiredCheckKeys?: string[];
+    requiredKinds?: VoiceProviderStackKind[];
+    requiredProviders?: TProvider[];
+    selectedKinds?: VoiceProviderStackKind[];
+};
+export type VoiceProviderContractMatrixAssertionReport<TProvider extends string = string> = {
+    failed: number;
+    issues: string[];
+    kinds: VoiceProviderStackKind[];
+    ok: boolean;
+    providers: TProvider[];
+    selectedKinds: VoiceProviderStackKind[];
+    status: VoiceProviderContractCheckStatus;
+    total: number;
+    warned: number;
+};
+export declare const recommendVoiceProviderStack: <TProvider extends string = string>(input: VoiceProviderStackInput<TProvider>) => VoiceProviderStackRecommendation<TProvider>;
+export declare const buildVoiceProviderContractMatrix: <TProvider extends string = string>(input: VoiceProviderContractMatrixInput<TProvider>) => VoiceProviderContractMatrixReport<TProvider>;
+export declare const evaluateVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const assertVoiceProviderContractMatrixEvidence: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, input?: VoiceProviderContractMatrixAssertionInput<TProvider>) => VoiceProviderContractMatrixAssertionReport<TProvider>;
+export declare const createVoiceProviderContractMatrixPreset: <TProvider extends string = string>(profile: VoiceReadinessProfileName, options: VoiceProviderContractMatrixPresetOptions<TProvider>) => VoiceProviderContractMatrixInput<TProvider>;
+export declare const renderVoiceProviderContractMatrixHTML: <TProvider extends string = string>(report: VoiceProviderContractMatrixReport<TProvider>, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceProviderContractMatrixJSONHandler: <TProvider extends string = string>(matrix: VoiceProviderContractMatrixHandlerOptions<TProvider>) => () => Promise<VoiceProviderContractMatrixReport<TProvider>>;
+export declare const createVoiceProviderContractMatrixHTMLHandler: <TProvider extends string = string>(options: VoiceProviderContractMatrixHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceProviderContractMatrixRoutes: <TProvider extends string = string>(options: VoiceProviderContractMatrixRoutesOptions<TProvider>) => 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 evaluateVoiceProviderStackGaps: <TProvider extends string = string>(input: VoiceProviderStackCapabilityGapInput<TProvider>) => VoiceProviderStackCapabilityGapReport<TProvider>;
+export declare const evaluateVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;
+export declare const assertVoiceProviderStackEvidence: <TProvider extends string = string>(report: VoiceProviderStackCapabilityGapReport<TProvider>, input?: VoiceProviderStackAssertionInput<TProvider>) => VoiceProviderStackAssertionReport<TProvider>;

package/dist/qualityRoutes.d.ts

@@ -0,0 +1,76 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceTraceEvent, type VoiceTraceEventStore } from './trace';
+export type VoiceQualityStatus = 'pass' | 'fail';
+export type VoiceQualityThresholds = {
+    maxDuplicateTurnRate?: number;
+    maxEmptyTurnRate?: number;
+    maxHandoffFailureRate?: number;
+    maxMissingAssistantReplyRate?: number;
+    maxProviderAverageLatencyMs?: number;
+    maxProviderErrorRate?: number;
+    maxProviderFallbackRate?: number;
+    maxProviderTimeoutRate?: number;
+};
+export type VoiceQualityMetric = {
+    actual: number;
+    label: string;
+    pass: boolean;
+    threshold: number;
+    unit: 'count' | 'ms' | 'rate';
+};
+export type VoiceQualityReport = {
+    checkedAt: number;
+    eventCount: number;
+    metrics: Record<string, VoiceQualityMetric>;
+    status: VoiceQualityStatus;
+    thresholds: Required<VoiceQualityThresholds>;
+};
+export type VoiceQualityLink = {
+    href: string;
+    label: string;
+};
+export type VoiceQualityRoutesOptions = {
+    events?: StoredVoiceTraceEvent[];
+    headers?: HeadersInit;
+    links?: VoiceQualityLink[];
+    name?: string;
+    path?: string;
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+};
+export declare const evaluateVoiceQuality: (input: {
+    events?: StoredVoiceTraceEvent[];
+    store?: VoiceTraceEventStore;
+    thresholds?: VoiceQualityThresholds;
+}) => Promise<VoiceQualityReport>;
+export declare const renderVoiceQualityHTML: (report: VoiceQualityReport, options?: {
+    links?: VoiceQualityLink[];
+}) => string;
+export declare const createVoiceQualityRoutes: (options: VoiceQualityRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;