@absolutejs/voice 0.0.22-beta.53 → 0.0.22-beta.531

package/dist/mediaPipelineRoutes.d.ts

@@ -0,0 +1,171 @@
+import { Elysia } from "elysia";
+import { type MediaFrame, type MediaInterruptionReport, type MediaPipelineCalibrationIssue, type MediaPipelineCalibrationInput, type MediaPipelineCalibrationReport, type MediaPipelineStatus, type MediaProcessorGraphReport, type MediaProcessorGraphSummary, type MediaQualityReport, type MediaQualitySummary, type MediaResamplingPlan, type MediaTransportReport, type MediaTransportSummary, type MediaVadReport } from "@absolutejs/media";
+export type VoiceMediaPipelineReportOptions = MediaPipelineCalibrationInput & {
+    frames?: readonly MediaFrame[];
+    maxInterruptionLatencyMs?: number;
+    maxMediaBackpressureEvents?: number;
+    maxMediaGapMs?: number;
+    maxMediaJitterMs?: number;
+    maxMediaTimestampDriftMs?: number;
+    maxSilenceFrames?: number;
+    minMediaSpeechRatio?: number;
+    minSpeechFrames?: number;
+    processorGraph?: MediaProcessorGraphReport;
+    speechEndThreshold?: number;
+    speechStartThreshold?: number;
+    transport?: MediaTransportReport;
+};
+export type VoiceMediaPipelineReport = {
+    calibration: MediaPipelineCalibrationReport;
+    checkedAt: number;
+    frames: number;
+    interruption: MediaInterruptionReport;
+    ok: boolean;
+    quality: MediaQualityReport;
+    resampling?: MediaResamplingPlan;
+    processorGraph?: MediaProcessorGraphReport;
+    sessionIds: string[];
+    status: MediaPipelineStatus;
+    surface: string;
+    transport?: MediaTransportReport;
+    vad: MediaVadReport;
+};
+export type VoiceMediaPipelineAssertionInput = {
+    maxFirstAudioLatencyMs?: number;
+    maxInterruptionLatencyMs?: number;
+    maxMediaBackpressureEvents?: number;
+    maxMediaGapMs?: number;
+    maxMediaJitterMs?: number;
+    maxMediaTimestampDriftMs?: number;
+    minAssistantAudioFrames?: number;
+    minInputAudioFrames?: number;
+    minMediaSpeechRatio?: number;
+    minProcessorGraphEmittedFrames?: number;
+    minProcessorGraphNodes?: number;
+    minTransportInputFrames?: number;
+    minTransportOutputFrames?: number;
+    minTraceLinkedFrames?: number;
+    minVadSegments?: number;
+    maxTransportBackpressureEvents?: number;
+    requireInterruptionFrame?: boolean;
+    requirePass?: boolean;
+    requireProcessorGraph?: boolean;
+    requireQualityPass?: boolean;
+    requireResamplingReady?: boolean;
+    requireTransportConnected?: boolean;
+};
+export type VoiceMediaPipelineAssertionReport = {
+    issues: string[];
+    ok: boolean;
+    status: MediaPipelineStatus;
+    surface: string;
+};
+export type VoiceMediaPipelineRoutesOptions = VoiceMediaPipelineReportOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    markdownPath?: false | string;
+    name?: string;
+    path?: string;
+    render?: (report: VoiceMediaPipelineReport) => Promise<string> | string;
+    source?: (() => Promise<VoiceMediaPipelineReportOptions> | VoiceMediaPipelineReportOptions) | VoiceMediaPipelineReportOptions;
+    title?: string;
+};
+export declare const buildVoiceMediaPipelineReport: (options?: VoiceMediaPipelineReportOptions) => VoiceMediaPipelineReport;
+export declare const evaluateVoiceMediaPipelineEvidence: (report: VoiceMediaPipelineReport, input?: VoiceMediaPipelineAssertionInput) => VoiceMediaPipelineAssertionReport;
+export declare const assertVoiceMediaPipelineEvidence: (report: VoiceMediaPipelineReport, input?: VoiceMediaPipelineAssertionInput) => VoiceMediaPipelineAssertionReport;
+export declare const renderVoiceMediaPipelineMarkdown: (report: VoiceMediaPipelineReport) => string;
+export declare const renderVoiceMediaPipelineHTML: (report: VoiceMediaPipelineReport, title?: string) => string;
+export declare const createVoiceMediaPipelineRoutes: (options?: VoiceMediaPipelineRoutesOptions) => 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: {};
+}>;
+export type VoiceMediaPipelineCalibrationSummary = {
+    assistantAudioFrames: number;
+    backpressureFrames: number;
+    firstAudioLatencyMs?: number;
+    inputAudioFrames: number;
+    interruptionFrames: number;
+    issueCodes: readonly string[];
+    jitterMs?: number;
+    resamplingRequired: boolean;
+    status: MediaPipelineStatus;
+    surface: string;
+    traceLinkedFrames: number;
+    turnCommitFrames: number;
+};
+export type VoiceMediaPipelineProofArtifactLinks = {
+    processorGraph?: string;
+    quality?: string;
+    transport?: string;
+};
+export type VoiceMediaPipelineProofSummary = {
+    artifacts?: VoiceMediaPipelineProofArtifactLinks;
+    calibration: VoiceMediaPipelineCalibrationSummary;
+    checkedAt: number;
+    frames: number;
+    interruption: {
+        interruptionFrames: number;
+        issueCodes: readonly string[];
+        latenciesMs: readonly number[];
+        status: MediaPipelineStatus;
+    };
+    issueCodes: readonly string[];
+    issues: readonly MediaPipelineCalibrationIssue[];
+    ok: boolean;
+    processorGraph?: MediaProcessorGraphSummary;
+    quality: MediaQualitySummary;
+    resampling?: {
+        ratio: number;
+        required: boolean;
+        status: MediaPipelineStatus;
+    };
+    sessionIds: readonly string[];
+    status: MediaPipelineStatus;
+    surface: string;
+    transport?: MediaTransportSummary;
+    vad: {
+        inputAudioFrames: number;
+        segmentCount: number;
+        status: MediaPipelineStatus;
+    };
+};
+export type VoiceMediaPipelineProofSummaryOptions = {
+    artifacts?: VoiceMediaPipelineProofArtifactLinks;
+};
+export declare const summarizeVoiceMediaPipelineReport: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineProofSummaryOptions) => VoiceMediaPipelineProofSummary;

package/dist/mediaPipelineSurfaces.d.ts

@@ -0,0 +1,48 @@
+import { type MediaProcessorGraphSummary, type MediaQualitySummary, type MediaTransportSummary } from "@absolutejs/media";
+import type { VoiceIncidentTimelineEvent } from "./incidentTimeline";
+import type { VoiceMediaPipelineReport } from "./mediaPipelineRoutes";
+import type { VoiceProductionReadinessCheck } from "./productionReadiness";
+export type VoiceMediaPipelineIssueSource = "calibration" | "interruption" | "processor-graph" | "quality" | "transport";
+export type VoiceMediaPipelineIssueEntry = {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+    source: VoiceMediaPipelineIssueSource;
+    surface: string;
+};
+export declare const extractVoiceMediaPipelineIssueEntries: (report: VoiceMediaPipelineReport) => readonly VoiceMediaPipelineIssueEntry[];
+export type VoiceMediaPipelineReadinessOptions = {
+    baseHref?: string;
+    label?: string;
+};
+export declare const buildVoiceMediaPipelineReadinessChecks: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineReadinessOptions) => readonly VoiceProductionReadinessCheck[];
+export type VoiceMediaPipelineIncidentOptions = {
+    baseHref?: string;
+    category?: VoiceIncidentTimelineEvent["category"];
+    now?: () => number;
+    source?: string;
+};
+export declare const buildVoiceMediaPipelineIncidentEvents: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineIncidentOptions) => readonly VoiceIncidentTimelineEvent[];
+export type VoiceMediaPipelineArtifactKind = "processor-graph" | "quality" | "transport";
+export type VoiceMediaPipelineArtifactRecord = {
+    href?: string;
+    jsonPath: string;
+    kind: VoiceMediaPipelineArtifactKind;
+    markdownPath: string;
+    summary: MediaProcessorGraphSummary | MediaQualitySummary | MediaTransportSummary;
+};
+export type VoiceMediaPipelineArtifactWriteOptions = {
+    dir: string;
+    hrefBase?: string;
+    report: VoiceMediaPipelineReport;
+    slugPrefix?: string;
+};
+export type VoiceMediaPipelineArtifactWriteResult = {
+    artifacts: VoiceMediaPipelineArtifactRecord[];
+    hrefs: {
+        processorGraph?: string;
+        quality?: string;
+        transport?: string;
+    };
+};
+export declare const writeVoiceMediaPipelineArtifacts: (options: VoiceMediaPipelineArtifactWriteOptions) => Promise<VoiceMediaPipelineArtifactWriteResult>;

package/dist/memoryStore.d.ts

@@ -1,2 +1,2 @@
-import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+import type { VoiceSessionRecord, VoiceSessionStore } from "./types";
 export declare const createVoiceMemoryStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>() => VoiceSessionStore<TSession>;

package/dist/midCallSummary.d.ts

@@ -0,0 +1,27 @@
+import type { Transcript, VoiceSessionRecord, VoiceTurnRecord } from "./types";
+import type { VoiceLLMJudgeCompletion } from "./llmJudge";
+export type MidCallSummary = {
+    generatedAt: number;
+    summary: string;
+    topicalShift?: boolean;
+    turnCount: number;
+};
+export type CreateMidCallSummarizerOptions = {
+    completion: VoiceLLMJudgeCompletion;
+    /** Force a summary every N turns. Default 6. */
+    everyTurns?: number;
+    /** Force a summary at most every M ms. Default 60_000. */
+    minIntervalMs?: number;
+    /** Maximum chars to include in the system prompt. Default 600. */
+    summaryMaxChars?: number;
+    systemPrompt?: string;
+};
+export type MidCallSummarizer = {
+    evaluate: (input: {
+        session: VoiceSessionRecord;
+        turn?: VoiceTurnRecord;
+    }) => Promise<MidCallSummary | undefined>;
+    latest: () => MidCallSummary | undefined;
+};
+export declare const createMidCallSummarizer: (options: CreateMidCallSummarizerOptions) => MidCallSummarizer;
+export declare const extractTranscriptText: (transcripts: Transcript[]) => string;

package/dist/modelAdapters.d.ts

@@ -1,5 +1,5 @@
-import type { VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput } from './agent';
-import type { VoiceSessionRecord } from './types';
+import type { VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput } from "./agent";
+import type { VoiceSessionRecord } from "./types";
 export type VoiceJSONAssistantModelHandler<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: VoiceAgentModelInput<TContext, TSession>) => Promise<Record<string, unknown> | VoiceAgentModelOutput<TResult>> | Record<string, unknown> | VoiceAgentModelOutput<TResult>;
 export type VoiceJSONAssistantModelOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     generate: VoiceJSONAssistantModelHandler<TContext, TSession, TResult>;
@@ -48,21 +48,36 @@ export type VoiceProviderRouterEvent<TProvider extends string = string> = {
     selectedProvider: TProvider;
     suppressionRemainingMs?: number;
     suppressedUntil?: number;
-    status: 'error' | 'fallback' | 'success';
+    status: "error" | "fallback" | "success";
     timedOut?: boolean;
 };
-export type VoiceProviderRouterFallbackMode = 'never' | 'provider-error' | 'rate-limit';
-export type VoiceProviderRouterPolicy<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected' | {
+export type VoiceProviderRouterFallbackMode = "never" | "provider-error" | "rate-limit";
+export type VoiceProviderRouterStrategy = "balanced" | "ordered" | "prefer-cheapest" | "prefer-fastest" | "prefer-selected" | "quality-first";
+export type VoiceProviderRouterPolicyPreset = "balanced" | "cost-cap" | "cost-first" | "latency-first" | "quality-first";
+export type VoiceProviderRouterPolicyWeights = {
+    cost?: number;
+    latencyMs?: number;
+    priority?: number;
+    quality?: number;
+};
+export type VoiceProviderRouterPolicy<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = VoiceProviderRouterStrategy | VoiceProviderRouterPolicyPreset | {
     allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
     fallbackMode?: VoiceProviderRouterFallbackMode;
-    strategy?: 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected';
+    maxCost?: number;
+    maxLatencyMs?: number;
+    minQuality?: number;
+    scoreProvider?: (provider: TProvider, profile: VoiceProviderRouterProviderProfile | undefined) => number;
+    strategy?: VoiceProviderRouterStrategy;
+    weights?: VoiceProviderRouterPolicyWeights;
 };
 export type VoiceProviderRouterProviderProfile = {
     cost?: number;
     latencyMs?: number;
     priority?: number;
+    quality?: number;
     timeoutMs?: number;
 };
+export declare const resolveVoiceProviderRoutingPolicyPreset: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string>(preset: VoiceProviderRouterPolicyPreset, options?: Omit<Extract<VoiceProviderRouterPolicy<TContext, TSession, TProvider>, Record<string, unknown>>, "strategy">) => Extract<VoiceProviderRouterPolicy<TContext, TSession, TProvider>, Record<string, unknown>>;
 export type VoiceProviderRouterHealthOptions = {
     cooldownMs?: number;
     failureThreshold?: number;
@@ -74,9 +89,44 @@ export type VoiceProviderRouterProviderHealth<TProvider extends string = string>
     lastFailureAt?: number;
     lastRateLimitedAt?: number;
     provider: TProvider;
-    status: 'healthy' | 'suppressed';
+    status: "healthy" | "suppressed";
     suppressedUntil?: number;
 };
+export type VoiceProviderOrchestrationSurface<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = {
+    allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    fallback?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    fallbackMode?: VoiceProviderRouterFallbackMode;
+    maxCost?: number;
+    maxLatencyMs?: number;
+    minQuality?: number;
+    policy?: VoiceProviderRouterPolicy<TContext, TSession, TProvider>;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
+    strategy?: VoiceProviderRouterStrategy;
+    timeoutMs?: number;
+    weights?: VoiceProviderRouterPolicyWeights;
+};
+export type VoiceProviderOrchestrationProfile<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string, TSurface extends string = string> = {
+    defaultSurface?: TSurface;
+    id: string;
+    resolve: (surface?: TSurface) => VoiceProviderOrchestrationResolvedSurface<TContext, TSession, TProvider>;
+    surfaces: Record<TSurface, VoiceProviderOrchestrationSurface<TContext, TSession, TProvider>>;
+};
+export type VoiceProviderOrchestrationProfileOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string, TSurface extends string = string> = {
+    defaultSurface?: TSurface;
+    id: string;
+    surfaces: Record<TSurface, VoiceProviderOrchestrationSurface<TContext, TSession, TProvider>>;
+};
+export type VoiceProviderOrchestrationResolvedSurface<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = {
+    allowProviders?: VoiceProviderOrchestrationSurface<TContext, TSession, TProvider>["allowProviders"];
+    fallback?: VoiceProviderOrchestrationSurface<TContext, TSession, TProvider>["fallback"];
+    fallbackMode?: VoiceProviderRouterFallbackMode;
+    policy?: VoiceProviderRouterPolicy<TContext, TSession, TProvider>;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
+    timeoutMs?: number;
+};
+export declare const createVoiceProviderOrchestrationProfile: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string, TSurface extends string = string>(options: VoiceProviderOrchestrationProfileOptions<TContext, TSession, TProvider, TSurface>) => VoiceProviderOrchestrationProfile<TContext, TSession, TProvider, TSurface>;
 export type VoiceProviderRouterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TProvider extends string = string> = {
     allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
     fallback?: TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
@@ -85,6 +135,8 @@ export type VoiceProviderRouterOptions<TContext = unknown, TSession extends Voic
     isRateLimitError?: (error: unknown, provider: TProvider) => boolean;
     isTimeoutError?: (error: unknown, provider: TProvider) => boolean;
     onProviderEvent?: (event: VoiceProviderRouterEvent<TProvider>, input: VoiceAgentModelInput<TContext, TSession>) => Promise<void> | void;
+    orchestrationProfile?: VoiceProviderOrchestrationProfile<TContext, TSession, TProvider>;
+    orchestrationSurface?: string;
     policy?: VoiceProviderRouterPolicy<TContext, TSession, TProvider>;
     providerHealth?: boolean | VoiceProviderRouterHealthOptions;
     providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;

package/dist/monitor.d.ts

@@ -0,0 +1,148 @@
+import { Elysia } from "elysia";
+import type { AudioFormat, VoiceMonitorRuntimeBinding, VoiceSessionHandle, VoiceSessionRecord } from "./types";
+export type VoiceMonitorAudioSource = "assistant" | "caller" | (string & {});
+export type VoiceMonitorAudioEvent = {
+    at: number;
+    chunk: Uint8Array;
+    format: AudioFormat;
+    source: VoiceMonitorAudioSource;
+};
+export type VoiceMonitorSessionRecord = {
+    handle: VoiceSessionHandle<unknown, VoiceSessionRecord, unknown>;
+    metadata?: Record<string, unknown>;
+    onAudio: (handler: (event: VoiceMonitorAudioEvent) => void) => () => void;
+    onClose: (handler: (reason?: string) => void) => () => void;
+    sessionId: string;
+};
+export type VoiceMonitorRegistry = {
+    get: (sessionId: string) => VoiceMonitorSessionRecord | undefined;
+    list: () => readonly {
+        sessionId: string;
+    }[];
+};
+export type VoiceMonitorMutableRegistry = VoiceMonitorRegistry & {
+    emit: (sessionId: string, event: VoiceMonitorAudioEvent) => void;
+    emitClose: (sessionId: string, reason?: string) => void;
+    /**
+     * Deregister a session by id. No-op if the id isn't registered. The
+     * `reason` flows into the close fan-out exactly once.
+     */
+    deregister: (sessionId: string, reason?: string) => void;
+    register: (record: VoiceMonitorSessionRecord) => (reason?: string) => void;
+};
+export type VoiceMonitorRegistryRegisterInput = {
+    handle: VoiceSessionHandle<unknown, VoiceSessionRecord, unknown>;
+    metadata?: Record<string, unknown>;
+    sessionId: string;
+};
+export declare const createVoiceMonitorSession: (input: VoiceMonitorRegistryRegisterInput) => VoiceMonitorSessionRecord & {
+    emit: (event: VoiceMonitorAudioEvent) => void;
+    emitClose: (reason?: string) => void;
+};
+export declare const createVoiceInMemoryMonitorRegistry: () => VoiceMonitorMutableRegistry;
+export type VoiceMonitorControlMessage = {
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    target: string;
+    type: "transfer";
+} | {
+    reason?: string;
+    type: "hangup";
+} | {
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    type: "escalate";
+} | {
+    metadata?: Record<string, unknown>;
+    type: "voicemail";
+} | {
+    metadata?: Record<string, unknown>;
+    type: "no-answer";
+} | {
+    muted: boolean;
+    target: "assistant" | "caller";
+    type: "mute";
+} | {
+    interrupt?: boolean;
+    text: string;
+    type: "say";
+} | {
+    role: "assistant" | "system" | "user";
+    text: string;
+    type: "inject";
+};
+export type VoiceMonitorControlAck = {
+    detail?: string;
+    ok: true;
+    type: VoiceMonitorControlMessage["type"];
+} | {
+    error: string;
+    ok: false;
+    type: VoiceMonitorControlMessage["type"];
+};
+export type VoiceMonitorControlHandlerInput = {
+    message: VoiceMonitorControlMessage;
+    raw: unknown;
+    session: VoiceMonitorSessionRecord;
+};
+export type VoiceMonitorControlHandler = (input: VoiceMonitorControlHandlerInput) => Promise<VoiceMonitorControlAck> | VoiceMonitorControlAck;
+export type VoiceMonitorAuthenticateInput = {
+    request: unknown;
+    route: "control" | "listen";
+    sessionId: string;
+};
+export type VoiceMonitorAuthenticate = (input: VoiceMonitorAuthenticateInput) => boolean | Promise<boolean>;
+export type VoiceLiveMonitorRoutesOptions = {
+    authenticate?: VoiceMonitorAuthenticate;
+    basePath?: string;
+    controlHandlers?: Partial<Record<VoiceMonitorControlMessage["type"], VoiceMonitorControlHandler>>;
+    controlPath?: false | string;
+    htmlPath?: false | string;
+    listenPath?: false | string;
+    registry: VoiceMonitorRegistry;
+};
+export type VoiceMonitorPlanInput = {
+    basePath?: string;
+    baseUrl: string;
+    controlPath?: string;
+    listenPath?: string;
+    sessionId: string;
+};
+export type VoiceMonitorPlan = {
+    controlUrl: string;
+    listenUrl: string;
+};
+export declare const buildVoiceMonitorPlan: (input: VoiceMonitorPlanInput) => VoiceMonitorPlan;
+export type VoiceMonitorRuntimeBindingOptions = {
+    audioFormat?: AudioFormat;
+    defaultSource?: VoiceMonitorAudioSource;
+};
+export declare const createVoiceMonitorRuntimeBinding: (registry: VoiceMonitorMutableRegistry, options?: VoiceMonitorRuntimeBindingOptions) => VoiceMonitorRuntimeBinding;
+export declare const createVoiceLiveMonitorRoutes: (options: VoiceLiveMonitorRoutesOptions) => 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/multilingualProof.d.ts

@@ -0,0 +1,77 @@
+import type { STTAdapter } from "./types";
+import { type VoiceTestFixture } from "./testing/fixtures";
+import { type VoiceSTTBenchmarkOptions, type VoiceSTTBenchmarkReport } from "./testing/benchmark";
+export type VoiceMultilingualLanguageCode = string;
+export type VoiceMultilingualProofLanguageThresholds = {
+    label?: string;
+    language: VoiceMultilingualLanguageCode;
+    maxAverageWordErrorRate?: number;
+    minAverageWordAccuracyRate?: number;
+    minPassRate?: number;
+    minTermRecall?: number;
+};
+export type VoiceMultilingualProofDefaultThresholds = Omit<VoiceMultilingualProofLanguageThresholds, "label" | "language">;
+export type VoiceMultilingualProofAdapterEntry = {
+    adapter: STTAdapter;
+    adapterId: string;
+    benchmarkOptions?: VoiceSTTBenchmarkOptions;
+};
+export type VoiceMultilingualProofOptions = {
+    adapters: readonly VoiceMultilingualProofAdapterEntry[];
+    defaultThresholds?: VoiceMultilingualProofDefaultThresholds;
+    filter?: (fixture: VoiceTestFixture) => boolean;
+    fixtureDirectories?: string | readonly string[];
+    fixtures?: readonly VoiceTestFixture[];
+    perLanguage?: readonly VoiceMultilingualProofLanguageThresholds[];
+};
+export type VoiceMultilingualProofLanguageMetrics = {
+    averageTermRecall: number;
+    averageWordAccuracyRate: number;
+    averageWordErrorRate: number;
+    fixtureCount: number;
+    passCount: number;
+    passRate: number;
+};
+export type VoiceMultilingualProofLanguageReport = {
+    applied: VoiceMultilingualProofLanguageThresholds;
+    failures: readonly string[];
+    fixtureIds: readonly string[];
+    label?: string;
+    language: VoiceMultilingualLanguageCode;
+    metrics: VoiceMultilingualProofLanguageMetrics;
+    passes: boolean;
+};
+export type VoiceMultilingualProofAdapterReport = {
+    adapterId: string;
+    benchmark: VoiceSTTBenchmarkReport;
+    failures: readonly string[];
+    fixtureCount: number;
+    languageReports: readonly VoiceMultilingualProofLanguageReport[];
+    overall: VoiceMultilingualProofLanguageMetrics;
+    passes: boolean;
+};
+export type VoiceMultilingualProofReport = {
+    adapters: readonly VoiceMultilingualProofAdapterReport[];
+    generatedAt: number;
+    passes: boolean;
+    summary: {
+        adapterCount: number;
+        failedAdapters: readonly string[];
+        fixtureCount: number;
+        languageCount: number;
+    };
+};
+export declare const runVoiceMultilingualProof: (options: VoiceMultilingualProofOptions) => Promise<VoiceMultilingualProofReport>;
+export declare const renderVoiceMultilingualProofMarkdown: (report: VoiceMultilingualProofReport) => string;
+export type VoiceMultilingualProofReadinessOptions = {
+    baseHref?: string;
+    label?: string;
+};
+export type VoiceMultilingualProofReadinessCheck = {
+    detail: string;
+    href?: string;
+    label: string;
+    status: "fail" | "pass" | "warn";
+    value?: number | string;
+};
+export declare const buildVoiceMultilingualProofReadinessCheck: (report: VoiceMultilingualProofReport, options?: VoiceMultilingualProofReadinessOptions) => VoiceMultilingualProofReadinessCheck;

package/dist/noShowPredictor.d.ts

@@ -0,0 +1,46 @@
+export type VoiceNoShowHistoricalRecord = {
+    appointmentId: string;
+    scheduledStartMs: number;
+    outcome: "kept" | "no-show" | "cancelled" | "rescheduled";
+};
+export type VoiceNoShowSignal = {
+    kind: "lead-time-hours";
+    value: number;
+} | {
+    kind: "weekday";
+    value: number;
+} | {
+    kind: "hour-of-day";
+    value: number;
+} | {
+    kind: "prior-no-show-count";
+    value: number;
+} | {
+    kind: "prior-kept-count";
+    value: number;
+} | {
+    kind: "reminder-confirmed";
+    value: boolean;
+} | {
+    kind: "callback-distance-hours";
+    value: number;
+} | {
+    kind: "weather-disruption";
+    value: boolean;
+};
+export type VoiceNoShowScoreInput = {
+    appointmentStartMs: number;
+    bookedAtMs: number;
+    history?: VoiceNoShowHistoricalRecord[];
+    reminderConfirmed?: boolean;
+    weatherDisruption?: boolean;
+    callbackDistanceHours?: number;
+    now?: () => number;
+};
+export type VoiceNoShowVerdict = {
+    score: number;
+    band: "low" | "moderate" | "high";
+    drivers: VoiceNoShowSignal[];
+};
+export declare const scoreVoiceNoShowRisk: (input: VoiceNoShowScoreInput) => VoiceNoShowVerdict;
+export declare const summarizeVoiceNoShowVerdict: (verdict: VoiceNoShowVerdict) => string;

package/dist/oauth2TokenSource.d.ts

@@ -0,0 +1,21 @@
+export type VoiceOAuth2TokenResponse = {
+    access_token: string;
+    expires_in?: number;
+    token_type?: string;
+};
+export type VoiceOAuth2TokenSource = {
+    invalidate: () => void;
+    token: () => Promise<string>;
+};
+export type CreateVoiceOAuth2TokenSourceOptions = {
+    audience?: string;
+    clientId: string;
+    clientSecret: string;
+    fetch?: typeof fetch;
+    grantType?: "client_credentials";
+    /** seconds remaining before expiry to refresh proactively, default 60 */
+    refreshSkewSeconds?: number;
+    scope?: string;
+    tokenUrl: string;
+};
+export declare const createVoiceOAuth2TokenSource: (options: CreateVoiceOAuth2TokenSourceOptions) => VoiceOAuth2TokenSource;