@absolutejs/voice 0.0.22-beta.48 → 0.0.22-beta.480

package/dist/latencySlo.d.ts

@@ -0,0 +1,56 @@
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+export type VoiceLatencySLOStatus = "empty" | "fail" | "pass" | "warn";
+export type VoiceLatencySLOStage = "assistant_text_to_tts_send" | "barge_in_stop" | "commit_to_assistant_text" | "final_to_commit" | "live_latency" | "provider_llm" | "provider_stt" | "provider_tts" | "speech_to_commit" | "tts_send_duration" | "tts_to_first_audio";
+export type VoiceLatencySLOBudget = {
+    failAfterMs: number;
+    warnAfterMs?: number;
+};
+export type VoiceLatencySLOMeasurement = {
+    at: number;
+    latencyMs: number;
+    label: string;
+    provider?: string;
+    sessionId: string;
+    stage: VoiceLatencySLOStage;
+    status: Exclude<VoiceLatencySLOStatus, "empty">;
+    turnId?: string;
+};
+export type VoiceLatencySLOStageSummary = {
+    averageMs?: number;
+    budget: VoiceLatencySLOBudget;
+    failed: number;
+    label: string;
+    maxMs?: number;
+    measurements: VoiceLatencySLOMeasurement[];
+    p50Ms?: number;
+    p95Ms?: number;
+    stage: VoiceLatencySLOStage;
+    status: VoiceLatencySLOStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLatencySLOGateReport = {
+    checkedAt: number;
+    failed: number;
+    measurements: VoiceLatencySLOMeasurement[];
+    stages: VoiceLatencySLOStageSummary[];
+    status: VoiceLatencySLOStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLatencySLOGateOptions = {
+    budgets?: Partial<Record<VoiceLatencySLOStage, VoiceLatencySLOBudget>>;
+    events?: StoredVoiceTraceEvent[];
+    failAfterMs?: number;
+    limit?: number;
+    store?: VoiceTraceEventStore;
+    warnAfterMs?: number;
+};
+export type VoiceLatencySLOGateError = Error & {
+    report: VoiceLatencySLOGateReport;
+};
+export declare const buildVoiceLatencySLOGate: (options: VoiceLatencySLOGateOptions) => Promise<VoiceLatencySLOGateReport>;
+export declare const assertVoiceLatencySLOGate: (options: VoiceLatencySLOGateOptions) => Promise<VoiceLatencySLOGateReport>;
+export declare const renderVoiceLatencySLOMarkdown: (report: VoiceLatencySLOGateReport, options?: {
+    title?: string;
+}) => string;

package/dist/liveLatency.d.ts

@@ -0,0 +1,78 @@
+import { Elysia } from "elysia";
+import type { VoiceTraceEventStore } from "./trace";
+export type VoiceLiveLatencyStatus = "empty" | "fail" | "pass" | "warn";
+export type VoiceLiveLatencySample = {
+    at: number;
+    latencyMs: number;
+    sessionId: string;
+    status?: string;
+    traceId?: string;
+};
+export type VoiceLiveLatencyReport = {
+    averageLatencyMs?: number;
+    checkedAt: number;
+    failed: number;
+    p50LatencyMs?: number;
+    p95LatencyMs?: number;
+    recent: VoiceLiveLatencySample[];
+    status: VoiceLiveLatencyStatus;
+    total: number;
+    warnings: number;
+};
+export type VoiceLiveLatencyOptions = {
+    failAfterMs?: number;
+    limit?: number;
+    store: VoiceTraceEventStore;
+    warnAfterMs?: number;
+};
+export type VoiceLiveLatencyRoutesOptions = VoiceLiveLatencyOptions & {
+    headers?: HeadersInit;
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+    title?: string;
+};
+export declare const summarizeVoiceLiveLatency: (options: VoiceLiveLatencyOptions) => Promise<VoiceLiveLatencyReport>;
+export declare const renderVoiceLiveLatencyHTML: (report: VoiceLiveLatencyReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceLiveLatencyRoutes: (options: VoiceLiveLatencyRoutesOptions) => 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: VoiceLiveLatencyReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/liveOps.d.ts

@@ -0,0 +1,190 @@
+import { Elysia } from "elysia";
+import { type VoiceAuditEventStore } from "./audit";
+import { type VoiceTraceEventStore } from "./trace";
+import type { VoiceOperationsRecord } from "./operationsRecord";
+import type { VoiceOpsActionHistoryReport } from "./opsActionAuditRoutes";
+import type { VoiceOpsRecoveryReport, VoiceOpsRecoveryStatus } from "./opsRecovery";
+import type { VoiceOpsStatusReport } from "./opsStatus";
+export declare const VOICE_LIVE_OPS_ACTIONS: readonly ["assign", "create-task", "escalate", "force-handoff", "inject-instruction", "operator-takeover", "pause-assistant", "resume-assistant", "tag"];
+export type VoiceLiveOpsAction = (typeof VOICE_LIVE_OPS_ACTIONS)[number];
+export type VoiceLiveOpsControlStatus = "assistant-paused" | "assistant-resumed" | "handoff-forced" | "instruction-injected" | "operator-takeover" | "recorded";
+export type VoiceLiveOpsControlState = {
+    assistantPaused: boolean;
+    handoffTarget?: string;
+    injectedInstruction?: string;
+    lastAction: VoiceLiveOpsAction;
+    lastUpdatedAt: number;
+    operator?: string;
+    operatorTakeover: boolean;
+    status: VoiceLiveOpsControlStatus;
+    tag?: string;
+};
+export type VoiceLiveOpsActionInput = {
+    action: VoiceLiveOpsAction;
+    assignee?: string;
+    detail?: string;
+    sessionId: string;
+    tag?: string;
+};
+export type VoiceLiveOpsActionResult = {
+    action: VoiceLiveOpsAction;
+    control: VoiceLiveOpsControlState;
+    ok: true;
+    sessionId: string;
+};
+export type VoiceLiveOpsEvidenceInput = {
+    actionHistory?: VoiceOpsActionHistoryReport;
+    maxActionHistoryFailures?: number;
+    maxOpsRecoveryIssues?: number;
+    minActionHistoryEntries?: number;
+    minInterventions?: number;
+    minOperationsRecordHandoffs?: number;
+    minOperationsRecordTasks?: number;
+    operationsRecord?: VoiceOperationsRecord;
+    opsRecovery?: VoiceOpsRecoveryReport;
+    opsStatus?: VoiceOpsStatusReport;
+    requireActionHistory?: boolean;
+    requireOperationsRecord?: boolean;
+    requireOperationsRecordAudit?: boolean;
+    requireOperationsRecordHealthy?: boolean;
+    requireOpsRecovery?: boolean;
+    requireOpsRecoveryStatus?: VoiceOpsRecoveryStatus;
+    requireOpsStatus?: boolean;
+    requireOpsStatusPass?: boolean;
+    requiredHistoryActions?: string[];
+    requiredInterventionActions?: string[];
+};
+export type VoiceLiveOpsEvidenceReport = {
+    actionHistoryFailed?: number;
+    actionHistoryTotal?: number;
+    historyActions: string[];
+    interventionActions: string[];
+    interventions?: number;
+    issues: string[];
+    ok: boolean;
+    operationsRecordHandoffs?: number;
+    operationsRecordStatus?: VoiceOperationsRecord["status"];
+    operationsRecordTasks?: number;
+    opsRecoveryIssues?: number;
+    opsRecoveryStatus?: VoiceOpsRecoveryStatus;
+    opsStatus?: VoiceOpsStatusReport["status"];
+};
+export type VoiceLiveOpsControlEvidenceInput = {
+    finalControl?: VoiceLiveOpsControlState | null;
+    maxFailedActions?: number;
+    minSnapshots?: number;
+    requireFinalAssistantPaused?: boolean;
+    requireFinalOperatorTakeover?: boolean;
+    requiredActions?: VoiceLiveOpsAction[];
+    requiredStatuses?: VoiceLiveOpsControlStatus[];
+    results?: Array<(Partial<Omit<VoiceLiveOpsActionResult, "ok">> & {
+        ok?: boolean;
+    }) | null | undefined>;
+};
+export type VoiceLiveOpsControlEvidenceReport = {
+    actionCount: number;
+    actions: VoiceLiveOpsAction[];
+    failedActions: number;
+    finalControl?: VoiceLiveOpsControlState;
+    finalStatus?: VoiceLiveOpsControlStatus;
+    issues: string[];
+    ok: boolean;
+    snapshots: number;
+    statuses: VoiceLiveOpsControlStatus[];
+};
+export type VoiceLiveOpsControlStore = {
+    get: (sessionId: string) => Promise<VoiceLiveOpsControlState | undefined> | VoiceLiveOpsControlState | undefined;
+    set: (sessionId: string, state: VoiceLiveOpsControlState) => Promise<void> | void;
+};
+export type VoiceLiveOpsControllerOptions = {
+    audit?: VoiceAuditEventStore;
+    defaultAssignee?: string;
+    defaultDetail?: string;
+    defaultTag?: string;
+    onAction?: (result: VoiceLiveOpsActionResult & {
+        assignee: string;
+        detail: string;
+        tag: string;
+    }) => Promise<void> | void;
+    store?: VoiceLiveOpsControlStore;
+    trace?: VoiceTraceEventStore;
+};
+export type VoiceLiveOpsRoutesOptions = VoiceLiveOpsControllerOptions & {
+    controlPath?: string;
+    name?: string;
+    path?: string;
+};
+export declare const evaluateVoiceLiveOpsEvidence: (input?: VoiceLiveOpsEvidenceInput) => VoiceLiveOpsEvidenceReport;
+export declare const assertVoiceLiveOpsEvidence: (input?: VoiceLiveOpsEvidenceInput) => VoiceLiveOpsEvidenceReport;
+export declare const evaluateVoiceLiveOpsControlEvidence: (input?: VoiceLiveOpsControlEvidenceInput) => VoiceLiveOpsControlEvidenceReport;
+export declare const assertVoiceLiveOpsControlEvidence: (input?: VoiceLiveOpsControlEvidenceInput) => VoiceLiveOpsControlEvidenceReport;
+export declare const createVoiceMemoryLiveOpsControlStore: () => VoiceLiveOpsControlStore;
+export declare const getVoiceLiveOpsControlStatus: (action: VoiceLiveOpsAction) => VoiceLiveOpsControlStatus;
+export declare const buildVoiceLiveOpsControlState: (input: VoiceLiveOpsActionInput & {
+    at?: number;
+    previous?: VoiceLiveOpsControlState;
+}) => VoiceLiveOpsControlState;
+export declare const createVoiceLiveOpsController: (options?: VoiceLiveOpsControllerOptions) => {
+    get: (sessionId: string) => VoiceLiveOpsControlState | Promise<VoiceLiveOpsControlState | undefined> | undefined;
+    perform: (input: VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult>;
+    store: VoiceLiveOpsControlStore;
+};
+export declare const createVoiceLiveOpsRoutes: (options?: VoiceLiveOpsRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceLiveOpsActionResult | {
+                    error: string;
+                    ok: boolean;
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    control: VoiceLiveOpsControlState | undefined;
+                    ok: boolean;
+                    sessionId: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/logger.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceLogger } from './types';
+import type { VoiceLogger } from "./types";
 export declare const createNoopLogger: () => Required<VoiceLogger>;
 export declare const resolveLogger: (logger?: VoiceLogger) => {
     debug: (message: string, meta?: Record<string, unknown>) => void;

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/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>>;