@absolutejs/voice 0.0.22-beta.31 → 0.0.22-beta.310

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

@@ -0,0 +1,125 @@
+import type { AudioFormat } from './types';
+export type VoiceMediaFrameKind = 'assistant-audio' | 'input-audio' | 'interruption' | 'metadata' | 'transcript' | 'turn-commit';
+export type VoiceMediaFrameSource = 'browser' | 'provider' | 'telephony' | 'voice-runtime';
+export type VoiceMediaPipelineStatus = 'fail' | 'pass' | 'warn';
+export type VoiceMediaResamplingPlan = {
+    inputFormat: AudioFormat;
+    outputFormat: AudioFormat;
+    ratio: number;
+    required: boolean;
+    status: VoiceMediaPipelineStatus;
+};
+export type VoiceMediaFrame = {
+    at?: number;
+    audio?: ArrayBuffer | ArrayBufferView;
+    durationMs?: number;
+    format?: AudioFormat;
+    id: string;
+    kind: VoiceMediaFrameKind;
+    latencyMs?: number;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    source: VoiceMediaFrameSource | (string & {});
+    traceEventId?: string;
+    turnId?: string;
+};
+export type VoiceMediaFrameTransform = {
+    inputFormat?: AudioFormat;
+    name: string;
+    outputFormat?: AudioFormat;
+    transform: (frame: VoiceMediaFrame) => VoiceMediaFrame | readonly VoiceMediaFrame[] | undefined | Promise<VoiceMediaFrame | readonly VoiceMediaFrame[] | undefined>;
+};
+export type VoiceMediaFrameTransformPipeline = {
+    push: (frame: VoiceMediaFrame) => Promise<readonly VoiceMediaFrame[]>;
+    pushMany: (frames: readonly VoiceMediaFrame[]) => Promise<readonly VoiceMediaFrame[]>;
+    transforms: readonly VoiceMediaFrameTransform[];
+};
+export type VoiceMediaTransportAdapter = {
+    close?: () => Promise<void> | void;
+    connect?: () => Promise<void> | void;
+    inputFormat?: AudioFormat;
+    name: string;
+    onFrame?: (handler: (frame: VoiceMediaFrame) => Promise<void> | void) => () => void;
+    outputFormat?: AudioFormat;
+    send: (frame: VoiceMediaFrame) => Promise<void> | void;
+};
+export type VoiceMediaPipelineCalibrationInput = {
+    expectedInputFormat?: AudioFormat;
+    expectedOutputFormat?: AudioFormat;
+    frames?: readonly VoiceMediaFrame[];
+    inputFormat?: AudioFormat;
+    maxBackpressureFrames?: number;
+    maxFirstAudioLatencyMs?: number;
+    maxJitterMs?: number;
+    outputFormat?: AudioFormat;
+    requireInterruptionFrame?: boolean;
+    requireTraceEvidence?: boolean;
+    surface?: string;
+};
+export type VoiceMediaPipelineCalibrationIssue = {
+    code: string;
+    message: string;
+    severity: 'error' | 'warning';
+};
+export type VoiceMediaPipelineCalibrationReport = {
+    assistantAudioFrames: number;
+    backpressureFrames: number;
+    checkedAt: number;
+    firstAudioLatencyMs?: number;
+    inputAudioFrames: number;
+    inputFormat?: AudioFormat;
+    interruptionFrames: number;
+    issues: VoiceMediaPipelineCalibrationIssue[];
+    jitterMs?: number;
+    outputFormat?: AudioFormat;
+    resamplingRequired: boolean;
+    resamplingTargetHz?: number;
+    status: VoiceMediaPipelineStatus;
+    surface: string;
+    traceLinkedFrames: number;
+    turnCommitFrames: number;
+};
+export type VoiceMediaVadInput = {
+    frames?: readonly VoiceMediaFrame[];
+    maxSilenceFrames?: number;
+    minSpeechFrames?: number;
+    speechEndThreshold?: number;
+    speechStartThreshold?: number;
+};
+export type VoiceMediaVadSegment = {
+    durationMs?: number;
+    endAt?: number;
+    frameCount: number;
+    segmentId: string;
+    sessionId?: string;
+    startAt?: number;
+    turnId?: string;
+};
+export type VoiceMediaVadReport = {
+    checkedAt: number;
+    inputAudioFrames: number;
+    segments: VoiceMediaVadSegment[];
+    status: VoiceMediaPipelineStatus;
+};
+export type VoiceMediaInterruptionInput = {
+    frames?: readonly VoiceMediaFrame[];
+    maxInterruptionLatencyMs?: number;
+};
+export type VoiceMediaInterruptionReport = {
+    checkedAt: number;
+    interruptionFrames: number;
+    issues: VoiceMediaPipelineCalibrationIssue[];
+    latenciesMs: number[];
+    status: VoiceMediaPipelineStatus;
+};
+export declare const createVoiceMediaFrame: (frame: VoiceMediaFrame) => VoiceMediaFrame;
+export declare const buildVoiceMediaResamplingPlan: (input: {
+    inputFormat: AudioFormat;
+    outputFormat: AudioFormat;
+}) => VoiceMediaResamplingPlan;
+export declare const createVoiceMediaFrameTransformPipeline: (input?: {
+    transforms?: readonly VoiceMediaFrameTransform[];
+}) => VoiceMediaFrameTransformPipeline;
+export declare const buildVoiceMediaVadReport: (input?: VoiceMediaVadInput) => VoiceMediaVadReport;
+export declare const buildVoiceMediaInterruptionReport: (input?: VoiceMediaInterruptionInput) => VoiceMediaInterruptionReport;
+export declare const buildVoiceMediaPipelineCalibrationReport: (input?: VoiceMediaPipelineCalibrationInput) => VoiceMediaPipelineCalibrationReport;

package/dist/modelAdapters.d.ts

@@ -36,9 +36,11 @@ export type GeminiVoiceAssistantModelOptions = {
 };
 export type VoiceProviderRouterEvent<TProvider extends string = string> = {
     at: number;
+    attempt: number;
     elapsedMs: number;
     error?: string;
     fallbackProvider?: TProvider;
+    latencyBudgetMs?: number;
     provider: TProvider;
     providerHealth?: VoiceProviderRouterProviderHealth<TProvider>;
     rateLimited?: boolean;
@@ -47,18 +49,35 @@ export type VoiceProviderRouterEvent<TProvider extends string = string> = {
     suppressionRemainingMs?: number;
     suppressedUntil?: number;
     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 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;
@@ -73,16 +92,55 @@ export type VoiceProviderRouterProviderHealth<TProvider extends string = string>
     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[]>);
     fallbackMode?: VoiceProviderRouterFallbackMode;
     isProviderError?: (error: unknown, provider: TProvider) => boolean;
     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>>;
+    timeoutMs?: number;
     providers: Partial<Record<TProvider, VoiceAgentModel<TContext, TSession, TResult>>>;
     selectProvider?: (input: VoiceAgentModelInput<TContext, TSession>) => TProvider | undefined | Promise<TProvider | undefined>;
 };