@absolutejs/voice 0.0.22-beta.57 → 0.0.22-beta.571

package/dist/{types.d.ts → core/types.d.ts}

@@ -1,24 +1,48 @@
-import type { SessionStore } from '@absolutejs/absolute';
-import type { VoiceOpsDispositionTaskPolicies, VoiceOpsTaskAssignmentRule, VoiceOpsTaskAssignmentRules, VoiceIntegrationWebhookConfig, StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTaskPolicy, VoiceOpsTask, VoiceOpsTaskStore } from './ops';
-import type { VoiceIntegrationSink } from './opsSinks';
-import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
-import type { VoiceTraceEventStore } from './trace';
+import type { MediaWebRTCStatsCollector, MediaWebRTCStatsReport, MediaWebRTCStatsReportInput, MediaWebRTCStreamContinuityInput, MediaWebRTCStreamContinuityReport } from "@absolutejs/media";
+import type { VoiceOpsDispositionTaskPolicies, VoiceOpsTaskAssignmentRule, VoiceOpsTaskAssignmentRules, VoiceIntegrationWebhookConfig, StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTaskPolicy, VoiceOpsTask, VoiceOpsTaskStore } from "./ops";
+import type { VoiceIntegrationSink } from "./opsSinks";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from "../testing/review";
+import type { VoiceTraceEventStore } from "./trace";
+import type { VoiceLiveOpsControlState } from "./liveOps";
+import type { VoiceAuditActor, VoiceAuditEventStore } from "./audit";
+import type { VoiceProfileSwitchGuardDecision, VoiceProfileSwitchGuardMode, VoiceProfileSwitchObservedSignals } from "./profileSwitchRecommendation";
+import type { VoiceRealCallProfileDefaultsReport, VoiceRealCallProfileHistoryReport } from "./proofTrends";
 export type AudioFormat = {
-    container: 'raw';
-    encoding: 'alaw' | 'mulaw' | 'pcm_s16le';
+    container: "raw";
+    encoding: "alaw" | "mulaw" | "pcm_s16le";
     sampleRateHz: number;
     channels: 1 | 2;
 };
 export type AudioChunk = ArrayBuffer | ArrayBufferView;
+/**
+ * Structural contract for an inbound noise suppressor applied before STT.
+ * Matches `@absolutejs/media`'s `NoiseSuppressor`, so any media suppressor
+ * (`createFFmpegNoiseSuppressor`, `createEnergyGateNoiseSuppressor`, a Krisp
+ * adapter, etc.) satisfies it without a hard import.
+ */
+export type VoiceNoiseSuppressor = {
+    readonly kind: string;
+    process: (input: {
+        format: AudioFormat;
+        pcm: ArrayBuffer | ArrayBufferView;
+    }) => Promise<{
+        bytes: Uint8Array;
+        format: AudioFormat;
+    }> | {
+        bytes: Uint8Array;
+        format: AudioFormat;
+    };
+    close?: () => Promise<void> | void;
+};
 export type VoiceLanguageStrategy = {
-    mode: 'auto-detect';
+    mode: "auto-detect";
     allowedLanguages?: string[];
 } | {
-    mode: 'fixed';
+    mode: "fixed";
     primaryLanguage: string;
     secondaryLanguages?: string[];
 } | {
-    mode: 'allow-switching';
+    mode: "allow-switching";
     primaryLanguage?: string;
     secondaryLanguages: string[];
 };
@@ -28,7 +52,7 @@ export type VoicePhraseHint = {
     boost?: number;
     metadata?: Record<string, unknown>;
 };
-export type VoiceCorrectionRiskTier = 'safe' | 'balanced' | 'risky';
+export type VoiceCorrectionRiskTier = "safe" | "balanced" | "risky";
 export type VoiceDomainTerm = {
     text: string;
     aliases?: string[];
@@ -44,12 +68,18 @@ export type VoiceLexiconEntry = {
     metadata?: Record<string, unknown>;
     pronunciation?: string;
 };
+export type VoiceTranscriptSentiment = {
+    label: "negative" | "neutral" | "positive" | (string & {});
+    metadata?: Record<string, unknown>;
+    score?: number;
+};
 export type Transcript = {
     id: string;
     text: string;
     isFinal: boolean;
     confidence?: number;
     language?: string;
+    sentiment?: VoiceTranscriptSentiment;
     speaker?: string | number;
     startedAtMs?: number;
     endedAtMs?: number;
@@ -65,7 +95,7 @@ export type VoiceTranscriptQuality = {
     fallback?: VoiceFallbackDiagnostics;
     partialTranscriptCount: number;
     selectedTranscriptCount: number;
-    source: 'fallback' | 'primary';
+    source: "fallback" | "primary";
 };
 export type VoiceTurnCorrectionDiagnostics = {
     attempted: boolean;
@@ -83,7 +113,7 @@ export type VoiceTurnCostEstimate = {
     primaryAudioMs: number;
     totalBillableAudioMs: number;
 };
-export type VoiceFallbackSelectionReason = 'fallback-empty' | 'primary-empty' | 'word-count-margin' | 'confidence-margin' | 'word-count-tiebreak' | 'kept-primary';
+export type VoiceFallbackSelectionReason = "fallback-empty" | "primary-empty" | "word-count-margin" | "confidence-margin" | "word-count-tiebreak" | "kept-primary";
 export type VoiceFallbackDiagnostics = {
     attempted: boolean;
     fallbackConfidence?: number;
@@ -94,31 +124,31 @@ export type VoiceFallbackDiagnostics = {
     primaryWordCount: number;
     selected: boolean;
     selectionReason: VoiceFallbackSelectionReason;
-    trigger: 'empty-turn' | 'low-confidence' | 'empty-or-low-confidence' | 'always';
+    trigger: "empty-turn" | "low-confidence" | "empty-or-low-confidence" | "always";
 };
 export type VoicePartialEvent = {
-    type: 'partial';
+    type: "partial";
     transcript: Transcript;
     receivedAt: number;
 };
 export type VoiceFinalEvent = {
-    type: 'final';
+    type: "final";
     transcript: Transcript;
     receivedAt: number;
 };
 export type VoiceEndOfTurnEvent = {
-    type: 'endOfTurn';
-    reason: 'vendor' | 'silence' | 'manual';
+    type: "endOfTurn";
+    reason: "vendor" | "silence" | "manual";
     receivedAt: number;
 };
 export type VoiceErrorEvent = {
-    type: 'error';
+    type: "error";
     error: Error;
     recoverable: boolean;
     code?: string;
 };
 export type VoiceCloseEvent = {
-    type: 'close';
+    type: "close";
     code?: number;
     reason?: string;
     recoverable?: boolean;
@@ -144,11 +174,11 @@ export type STTAdapterOpenOptions = {
     signal?: AbortSignal;
 };
 export type STTAdapter<TOptions extends STTAdapterOpenOptions = STTAdapterOpenOptions> = {
-    kind: 'stt';
+    kind: "stt";
     open: (options: TOptions) => Promise<STTAdapterSession> | STTAdapterSession;
 };
 export type TTSAudioEvent = {
-    type: 'audio';
+    type: "audio";
     chunk: AudioChunk;
     format: AudioFormat;
     receivedAt: number;
@@ -161,15 +191,26 @@ export type TTSSessionEventMap = {
 export type TTSAdapterSession = {
     on: <K extends keyof TTSSessionEventMap>(event: K, handler: (payload: TTSSessionEventMap[K]) => void | Promise<void>) => () => void;
     send: (text: string) => Promise<void>;
+    cancel?: (reason?: string) => Promise<void>;
     close: (reason?: string) => Promise<void>;
 };
+export declare const ttsAdapterSessionCanCancel: (session: TTSAdapterSession) => session is TTSAdapterSession & {
+    cancel: (reason?: string) => Promise<void>;
+};
+export type VoiceTTSProsody = {
+    emphasis?: number;
+    pitch?: number;
+    speed?: number;
+    style?: string;
+};
 export type TTSAdapterOpenOptions = {
     sessionId: string;
     lexicon?: VoiceLexiconEntry[];
+    prosody?: VoiceTTSProsody;
     signal?: AbortSignal;
 };
 export type TTSAdapter<TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions> = {
-    kind: 'tts';
+    kind: "tts";
     open: (options: TOptions) => Promise<TTSAdapterSession> | TTSAdapterSession;
 };
 export type RealtimeSessionEventMap = STTSessionEventMap & {
@@ -185,20 +226,40 @@ export type RealtimeAdapterOpenOptions = {
     format: AudioFormat;
     languageStrategy?: VoiceLanguageStrategy;
     lexicon?: VoiceLexiconEntry[];
+    modalities?: ReadonlyArray<"audio" | "text">;
     phraseHints?: VoicePhraseHint[];
+    promptCacheKey?: string;
+    semanticVAD?: import("./assistantMode").VoiceSemanticVADConfig;
     signal?: AbortSignal;
 };
 export type RealtimeAdapter<TOptions extends RealtimeAdapterOpenOptions = RealtimeAdapterOpenOptions> = {
-    kind: 'realtime';
+    kind: "realtime";
     open: (options: TOptions) => Promise<RealtimeAdapterSession> | RealtimeAdapterSession;
 };
-export type VoiceSessionStatus = 'active' | 'reconnecting' | 'completed' | 'failed';
+export type VoiceSessionStatus = "active" | "reconnecting" | "completed" | "failed";
+export type VoiceReconnectClientStatus = "idle" | "reconnecting" | "resumed" | "exhausted";
+export type VoiceReconnectClientState = {
+    attempts: number;
+    lastDisconnectAt?: number;
+    lastResumedAt?: number;
+    maxAttempts: number;
+    nextAttemptAt?: number;
+    status: VoiceReconnectClientStatus;
+};
+export type VoiceTurnCitation = {
+    chunkId: string;
+    score: number;
+    source?: string;
+    title?: string;
+};
 export type VoiceTurnRecord<TResult = unknown> = {
     id: string;
     text: string;
     quality?: VoiceTranscriptQuality;
     transcripts: Transcript[];
     assistantText?: string;
+    attachments?: import("./agent").VoiceAgentMessageAttachment[];
+    citations?: VoiceTurnCitation[];
     committedAt: number;
     result?: TResult;
 };
@@ -253,10 +314,10 @@ export type VoiceSessionSummary = {
     status: VoiceSessionStatus;
     turnCount: number;
 };
-export type VoiceCallDisposition = 'completed' | 'transferred' | 'escalated' | 'voicemail' | 'no-answer' | 'failed' | 'closed';
+export type VoiceCallDisposition = "completed" | "transferred" | "escalated" | "voicemail" | "no-answer" | "failed" | "silence-timeout" | "closed";
 export type VoiceCallLifecycleEvent = {
     at: number;
-    type: 'start' | 'end' | 'transfer' | 'escalation' | 'voicemail' | 'no-answer';
+    type: "start" | "end" | "transfer" | "escalation" | "voicemail" | "no-answer";
     disposition?: VoiceCallDisposition;
     metadata?: Record<string, unknown>;
     reason?: string;
@@ -269,8 +330,8 @@ export type VoiceCallLifecycleState = {
     lastEventAt: number;
     startedAt: number;
 };
-export type VoiceHandoffAction = 'escalate' | 'no-answer' | 'transfer' | 'voicemail';
-export type VoiceHandoffStatus = 'delivered' | 'failed' | 'skipped';
+export type VoiceHandoffAction = "escalate" | "no-answer" | "transfer" | "voicemail";
+export type VoiceHandoffStatus = "delivered" | "failed" | "skipped";
 export type VoiceHandoffResult = {
     deliveredAt?: number;
     deliveredTo?: string;
@@ -278,7 +339,7 @@ export type VoiceHandoffResult = {
     metadata?: Record<string, unknown>;
     status: VoiceHandoffStatus;
 };
-export type VoiceHandoffDeliveryQueueStatus = VoiceHandoffStatus | 'pending';
+export type VoiceHandoffDeliveryQueueStatus = VoiceHandoffStatus | "pending";
 export type StoredVoiceHandoffDelivery<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     action: VoiceHandoffAction;
     context: TContext;
@@ -326,9 +387,15 @@ export type VoiceHandoffConfig<TContext = unknown, TSession extends VoiceSession
     adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
     deliveryQueue?: VoiceHandoffDeliveryStore<StoredVoiceHandoffDelivery<TContext, TSession, TResult>>;
     enqueueOnly?: boolean;
-    failMode?: 'record' | 'throw';
+    failMode?: "record" | "throw";
+};
+export type VoiceSessionStore<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    get: (id: string) => Promise<TSession | undefined>;
+    getOrCreate: (id: string) => Promise<TSession>;
+    set: (id: string, value: TSession) => Promise<void>;
+    list: () => Promise<VoiceSessionSummary[]>;
+    remove: (id: string) => Promise<void>;
 };
-export type VoiceSessionStore<TSession extends VoiceSessionRecord = VoiceSessionRecord> = SessionStore<TSession, VoiceSessionSummary>;
 export type VoiceLogger = {
     debug?: (message: string, meta?: Record<string, unknown>) => void;
     info?: (message: string, meta?: Record<string, unknown>) => void;
@@ -336,15 +403,15 @@ export type VoiceLogger = {
     error?: (message: string, meta?: Record<string, unknown>) => void;
 };
 export type VoiceReconnectConfig = {
-    strategy?: 'resume-last-turn' | 'restart' | 'fail';
+    strategy?: "resume-last-turn" | "restart" | "fail";
     timeout?: number;
     maxAttempts?: number;
 };
-export type VoiceRuntimePreset = 'default' | 'chat' | 'guided-intake' | 'dictation' | 'noisy-room' | 'pstn-balanced' | 'pstn-fast' | 'reliability';
-export type VoiceSTTLifecycle = 'continuous' | 'turn-scoped';
-export type VoiceTurnProfile = 'fast' | 'balanced' | 'long-form';
-export type VoiceTurnQualityProfile = 'general' | 'accent-heavy' | 'noisy-room' | 'short-command';
-export type VoiceTurnFallbackTrigger = 'empty-turn' | 'low-confidence' | 'empty-or-low-confidence' | 'always';
+export type VoiceRuntimePreset = "default" | "chat" | "guided-intake" | "dictation" | "noisy-room" | "pstn-balanced" | "pstn-fast" | "reliability";
+export type VoiceSTTLifecycle = "continuous" | "turn-scoped";
+export type VoiceTurnProfile = "fast" | "balanced" | "long-form";
+export type VoiceTurnQualityProfile = "general" | "accent-heavy" | "noisy-room" | "short-command";
+export type VoiceTurnFallbackTrigger = "empty-turn" | "low-confidence" | "empty-or-low-confidence" | "always";
 export type VoiceSTTFallbackConfig = {
     adapter: STTAdapter;
     trigger?: VoiceTurnFallbackTrigger;
@@ -396,12 +463,34 @@ export type VoiceResolvedAudioConditioningConfig = {
 export type VoiceSocket = {
     send: (data: string | Uint8Array | ArrayBuffer) => void | Promise<void>;
     close: (code?: number, reason?: string) => void | Promise<void>;
+    /**
+     * Discard any audio already buffered downstream (e.g. a telephony carrier's
+     * outbound media buffer). Called on barge-in so the caller stops hearing the
+     * assistant immediately, even when frames have already been flushed to the
+     * transport. Optional: transports without a flush concept omit it.
+     */
+    clear?: () => void | Promise<void>;
+};
+export type VoiceMonitorRuntimeSessionBinding = {
+    deregister: (reason?: string) => void;
+    emitAudio: (chunk: Uint8Array | ArrayBuffer, options?: {
+        source?: "assistant" | "caller" | (string & {});
+    }) => void;
+};
+export type VoiceMonitorRuntimeRegisterInput = {
+    handle: VoiceSessionHandle<unknown, VoiceSessionRecord, unknown>;
+    metadata?: Record<string, unknown>;
+    sessionId: string;
+};
+export type VoiceMonitorRuntimeBinding = {
+    registerSession: (input: VoiceMonitorRuntimeRegisterInput) => VoiceMonitorRuntimeSessionBinding;
 };
 export type VoiceSessionHandle<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     id: string;
     connect: (socket: VoiceSocket) => Promise<void>;
     receiveAudio: (audio: AudioChunk) => Promise<void>;
-    commitTurn: (reason?: VoiceEndOfTurnEvent['reason']) => Promise<void>;
+    attachUserMedia: (attachment: import("./agent").VoiceAgentMessageAttachment) => Promise<void>;
+    commitTurn: (reason?: VoiceEndOfTurnEvent["reason"]) => Promise<void>;
     disconnect: (event?: VoiceCloseEvent) => Promise<void>;
     complete: (result?: TResult) => Promise<void>;
     escalate: (input: {
@@ -423,18 +512,33 @@ export type VoiceSessionHandle<TContext = unknown, TSession extends VoiceSession
         reason?: string;
         result?: TResult;
         target: string;
+        transferMode?: "cold" | "warm";
     }) => Promise<void>;
     close: (reason?: string) => Promise<void>;
     snapshot: () => Promise<TSession>;
+    /**
+     * Mutate the live turn-detection config for this session — useful when a
+     * tool call wants to dial silenceMs up ("the caller asked for more time")
+     * or down. The change takes effect on the NEXT silence-timer schedule, so
+     * an in-flight commit isn't cancelled. Returns the merged config so the
+     * caller can confirm.
+     */
+    setTurnDetection: (patch: Partial<VoiceTurnDetectionConfig>) => Promise<{
+        silenceMs: number;
+        speechThreshold: number;
+        transcriptStabilityMs: number;
+    }>;
 };
 export type VoiceRouteResult<TResult = unknown> = {
     complete?: boolean;
     result?: TResult;
     assistantText?: string;
+    citations?: ReadonlyArray<VoiceTurnCitation>;
     transfer?: {
         metadata?: Record<string, unknown>;
         reason?: string;
         target: string;
+        transferMode?: "cold" | "warm";
     };
     escalate?: {
         metadata?: Record<string, unknown>;
@@ -475,6 +579,11 @@ export type VoiceLexiconResolver<TContext = unknown> = (input: {
 }) => Promise<VoiceLexiconEntry[] | void> | VoiceLexiconEntry[] | void;
 export type VoiceOnTurnObjectHandler<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: {
     context: TContext;
+    liveOps?: {
+        control: VoiceLiveOpsControlState;
+        injectedInstruction?: string;
+    };
+    onTextDelta?: (delta: string) => void;
     session: TSession;
     turn: VoiceTurnRecord;
     api: VoiceSessionHandle<TContext, TSession, TResult>;
@@ -559,7 +668,7 @@ export type VoiceRuntimeOpsConfig<TContext = unknown, TSession extends VoiceSess
         disposition: VoiceCallDisposition;
         review: StoredVoiceCallReviewArtifact;
         session: TSession;
-    }) => Promise<Omit<VoiceOpsTask, 'id'> | VoiceOpsTask | StoredVoiceOpsTask | null | void> | Omit<VoiceOpsTask, 'id'> | VoiceOpsTask | StoredVoiceOpsTask | null | void;
+    }) => Promise<Omit<VoiceOpsTask, "id"> | VoiceOpsTask | StoredVoiceOpsTask | null | void> | Omit<VoiceOpsTask, "id"> | VoiceOpsTask | StoredVoiceOpsTask | null | void;
     resolveTaskPolicy?: (input: {
         api: VoiceSessionHandle<TContext, TSession, TResult>;
         context: TContext;
@@ -596,7 +705,37 @@ export type VoiceRuntimeOpsConfig<TContext = unknown, TSession extends VoiceSess
     tasks?: VoiceOpsTaskStore;
     webhook?: VoiceIntegrationWebhookConfig;
 };
-export type VoiceNormalizedRouteConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceRouteConfig<TContext, TSession, TResult>, 'onTurn'> & {
+export type VoiceLiveOpsRuntimeConfig = {
+    getControl: (sessionId: string) => Promise<VoiceLiveOpsControlState | null | undefined> | VoiceLiveOpsControlState | null | undefined;
+};
+export type VoiceProfileSwitchGuardResolverInput<TContext = unknown> = {
+    context: TContext;
+    scenarioId?: string;
+    sessionId: string;
+};
+export type VoicePluginProfileSwitchGuardConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    actor?: VoiceAuditActor;
+    allowedProfileIds?: string[] | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<string[] | undefined> | string[] | undefined);
+    audit?: VoiceAuditEventStore;
+    blockedProfileIds?: string[] | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<string[] | undefined> | string[] | undefined);
+    currentProfileId?: string | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<string | undefined> | string | undefined);
+    defaultProfileId?: string;
+    defaults: VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport> | VoiceRealCallProfileDefaultsReport | VoiceRealCallProfileHistoryReport);
+    metadata?: Record<string, unknown> | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<Record<string, unknown> | undefined> | Record<string, unknown> | undefined);
+    minConfidence?: number | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<number | undefined> | number | undefined);
+    maxAutoSwitchesPerSession?: number | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<number | undefined> | number | undefined);
+    mode?: VoiceProfileSwitchGuardMode | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<VoiceProfileSwitchGuardMode | undefined> | VoiceProfileSwitchGuardMode | undefined);
+    observed?: VoiceProfileSwitchObservedSignals | ((input: VoiceProfileSwitchGuardResolverInput<TContext>) => Promise<VoiceProfileSwitchObservedSignals | undefined> | VoiceProfileSwitchObservedSignals | undefined);
+    onDecision?: (input: {
+        context: TContext;
+        decision: VoiceProfileSwitchGuardDecision;
+        scenarioId?: string;
+        sessionId: string;
+    }) => Promise<void> | void;
+    sessionMetadataKey?: string | false;
+    trace?: false | VoiceTraceEventStore;
+};
+export type VoiceNormalizedRouteConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceRouteConfig<TContext, TSession, TResult>, "onTurn"> & {
     onTurn: VoiceOnTurnObjectHandler<TContext, TSession, TResult>;
 };
 export type VoiceScenario = {
@@ -609,131 +748,383 @@ export type VoiceExpectedSpeakerTurn = {
     speaker: string;
     text: string;
 };
+/**
+ * Configures one of the plugin's optional route surfaces. Pass that surface's
+ * options object to mount it, `false` (or omit) to leave it off. Surfaces whose
+ * options are entirely optional may also be enabled with `true` for defaults.
+ */
+export type VoiceSurfaceConfig<O> = false | O | (Record<string, never> extends O ? true : never);
 export type VoicePluginConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     costTelemetry?: VoiceCostTelemetryConfig<TContext, TSession, TResult>;
     path: string;
+    greeting?: string | ((input: {
+        session: TSession;
+    }) => string | Promise<string>);
     languageStrategy?: VoiceLanguageStrategy;
     lexicon?: VoiceLexiconEntry[] | VoiceLexiconResolver<TContext>;
     phraseHints?: VoicePhraseHint[] | VoicePhraseHintResolver<TContext>;
     preset?: VoiceRuntimePreset;
-    stt: STTAdapter;
+    stt?: STTAdapter;
     sttFallback?: VoiceSTTFallbackConfig;
     sttLifecycle?: VoiceSTTLifecycle;
+    realtime?: RealtimeAdapter;
+    realtimeInputFormat?: AudioFormat;
     tts?: TTSAdapter;
     session: VoiceSessionStore<NoInfer<TSession>>;
     reconnect?: VoiceReconnectConfig;
     turnDetection?: VoiceTurnDetectionConfig;
+    semanticTurnDetector?: import("./semanticTurn").VoiceSemanticTurnDetector;
+    bargeInMinPartialWords?: number;
+    fillerPhrases?: ReadonlyArray<string>;
+    fillerDelayMs?: number;
+    fillerFor?: (input: {
+        sessionId: string;
+        turnId: string;
+        userText: string;
+    }) => Promise<string | null>;
+    fillerForTimeoutMs?: number;
+    defaultSilentTurnAck?: string;
+    routeOnTurnTimeoutMs?: number;
     audioConditioning?: VoiceAudioConditioningConfig;
+    noiseSuppressor?: VoiceNoiseSuppressor;
+    noiseSuppressorFormat?: AudioFormat;
     logger?: VoiceLogger;
     htmx?: boolean | VoiceHTMXConfig<TSession, NoInfer<TResult>>;
     handoff?: VoiceHandoffConfig<TContext, TSession, TResult>;
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
+    liveOps?: VoiceLiveOpsRuntimeConfig;
+    monitor?: VoiceMonitorRuntimeBinding;
+    profileSwitchGuard?: VoicePluginProfileSwitchGuardConfig<TContext, TSession, TResult>;
     trace?: VoiceTraceEventStore;
+    assistantHealth?: VoiceSurfaceConfig<import("./assistantHealth").VoiceAssistantHealthRoutesOptions>;
+    auditDelivery?: VoiceSurfaceConfig<import("./auditDeliveryRoutes").VoiceAuditDeliveryRoutesOptions>;
+    auditTrail?: VoiceSurfaceConfig<import("./auditRoutes").VoiceAuditTrailRoutesOptions>;
+    bargeIn?: VoiceSurfaceConfig<import("./bargeInRoutes").VoiceBargeInRoutesOptions>;
+    browserCallProfile?: VoiceSurfaceConfig<import("./browserCallProfiles").VoiceBrowserCallProfileRoutesOptions>;
+    browserMedia?: VoiceSurfaceConfig<import("./browserMediaRoutes").VoiceBrowserMediaRoutesOptions>;
+    callDebugger?: VoiceSurfaceConfig<import("./callDebugger").VoiceCallDebuggerRoutesOptions>;
+    campaign?: VoiceSurfaceConfig<import("./campaign").VoiceCampaignRoutesOptions>;
+    competitiveCoverage?: VoiceSurfaceConfig<import("./competitiveCoverage").VoiceCompetitiveCoverageRoutesOptions>;
+    dataControl?: VoiceSurfaceConfig<import("./dataControl").VoiceDataControlRoutesOptions>;
+    deliveryRuntime?: VoiceSurfaceConfig<import("./deliveryRuntime").VoiceDeliveryRuntimeRoutesOptions>;
+    deliverySink?: VoiceSurfaceConfig<import("./deliverySinkRoutes").VoiceDeliverySinkRoutesOptions>;
+    demoReady?: VoiceSurfaceConfig<import("./demoReadyRoutes").VoiceDemoReadyRoutesOptions>;
+    diagnostics?: VoiceSurfaceConfig<import("./diagnosticsRoutes").VoiceDiagnosticsRoutesOptions>;
+    eval?: VoiceSurfaceConfig<import("./evalRoutes").VoiceEvalRoutesOptions>;
+    guardrail?: VoiceSurfaceConfig<import("./guardrails").VoiceGuardrailRoutesOptions>;
+    handoffHealth?: VoiceSurfaceConfig<import("./handoffHealth").VoiceHandoffHealthRoutesOptions>;
+    htmxDashboard?: VoiceSurfaceConfig<import("./htmxDashboardRoutes").VoiceHTMXDashboardRoutesOptions>;
+    incidentBundle?: VoiceSurfaceConfig<import("./incidentBundle").VoiceIncidentBundleRoutesOptions>;
+    incidentTimeline?: VoiceSurfaceConfig<import("./incidentTimeline").VoiceIncidentTimelineRoutesOptions>;
+    liveLatency?: VoiceSurfaceConfig<import("./liveLatency").VoiceLiveLatencyRoutesOptions>;
+    liveMonitor?: VoiceSurfaceConfig<import("./monitor").VoiceLiveMonitorRoutesOptions>;
+    liveOpsConsole?: VoiceSurfaceConfig<import("./liveOps").VoiceLiveOpsRoutesOptions>;
+    mediaPipeline?: VoiceSurfaceConfig<import("./mediaPipelineRoutes").VoiceMediaPipelineRoutesOptions>;
+    monitorReport?: VoiceSurfaceConfig<import("./voiceMonitoring").VoiceMonitorRoutesOptions>;
+    monitorRunner?: VoiceSurfaceConfig<import("./voiceMonitoring").VoiceMonitorRunnerRoutesOptions>;
+    observabilityExport?: VoiceSurfaceConfig<import("./observabilityExport").VoiceObservabilityExportRoutesOptions>;
+    observabilityExportReplay?: VoiceSurfaceConfig<import("./observabilityExport").VoiceObservabilityExportReplayRoutesOptions>;
+    operationalStatus?: VoiceSurfaceConfig<import("./operationalStatus").VoiceOperationalStatusRoutesOptions>;
+    operationsRecord?: VoiceSurfaceConfig<import("./operationsRecord").VoiceOperationsRecordRoutesOptions>;
+    opsActionAudit?: VoiceSurfaceConfig<import("./opsActionAuditRoutes").VoiceOpsActionAuditRoutesOptions>;
+    opsConsole?: VoiceSurfaceConfig<import("./opsConsoleRoutes").VoiceOpsConsoleRoutesOptions>;
+    opsRecovery?: VoiceSurfaceConfig<import("./opsRecovery").VoiceOpsRecoveryRoutesOptions>;
+    opsStatus?: VoiceSurfaceConfig<import("./opsStatus").VoiceOpsStatusRoutesOptions>;
+    opsWebhookReceiver?: VoiceSurfaceConfig<import("./opsWebhook").VoiceOpsWebhookReceiverRoutesOptions>;
+    outcomeContract?: VoiceSurfaceConfig<import("./outcomeContract").VoiceOutcomeContractRoutesOptions>;
+    phoneAgentProductionSmoke?: VoiceSurfaceConfig<import("./phoneAgentProductionSmoke").VoicePhoneAgentProductionSmokeRoutesOptions>;
+    platformCoverage?: VoiceSurfaceConfig<import("./platformCoverage").VoicePlatformCoverageRoutesOptions>;
+    postCallAnalysis?: VoiceSurfaceConfig<import("./postCallAnalysis").VoicePostCallAnalysisRoutesOptions>;
+    productionReadiness?: VoiceSurfaceConfig<import("./productionReadiness").VoiceProductionReadinessRoutesOptions>;
+    profileSwitchLiveDecision?: VoiceSurfaceConfig<import("./profileSwitchRecommendation").VoiceProfileSwitchLiveDecisionRoutesOptions>;
+    profileSwitchPolicyProof?: VoiceSurfaceConfig<import("./profileSwitchRecommendation").VoiceProfileSwitchPolicyProofRoutesOptions>;
+    profileSwitchReadiness?: VoiceSurfaceConfig<import("./profileSwitchRecommendation").VoiceProfileSwitchReadinessRoutesOptions>;
+    proofPack?: VoiceSurfaceConfig<import("./proofPack").VoiceProofPackRoutesOptions>;
+    proofTrend?: VoiceSurfaceConfig<import("./proofTrends").VoiceProofTrendRoutesOptions>;
+    proofTrendRecommendation?: VoiceSurfaceConfig<import("./proofTrends").VoiceProofTrendRecommendationRoutesOptions>;
+    providerCapability?: VoiceSurfaceConfig<import("./providerCapabilities").VoiceProviderCapabilityRoutesOptions>;
+    providerContractMatrix?: VoiceSurfaceConfig<import("./providerStackRecommendations").VoiceProviderContractMatrixRoutesOptions>;
+    providerDecisionTrace?: VoiceSurfaceConfig<import("./providerDecisionTraces").VoiceProviderDecisionTraceRoutesOptions>;
+    providerHealth?: VoiceSurfaceConfig<import("./providerHealth").VoiceProviderHealthRoutesOptions>;
+    providerOrchestration?: VoiceSurfaceConfig<import("./providerOrchestration").VoiceProviderOrchestrationRoutesOptions>;
+    providerSlo?: VoiceSurfaceConfig<import("./providerSlo").VoiceProviderSloRoutesOptions>;
+    quality?: VoiceSurfaceConfig<import("./qualityRoutes").VoiceQualityRoutesOptions>;
+    realCallEvidenceRuntime?: VoiceSurfaceConfig<import("./proofTrends").VoiceRealCallEvidenceRuntimeRoutesOptions>;
+    realCallProfileHistory?: VoiceSurfaceConfig<import("./proofTrends").VoiceRealCallProfileHistoryRoutesOptions>;
+    realCallProfileRecoveryAction?: VoiceSurfaceConfig<import("./proofTrends").VoiceRealCallProfileRecoveryActionRoutesOptions>;
+    realtimeChannel?: VoiceSurfaceConfig<import("./realtimeChannel").VoiceRealtimeChannelRoutesOptions>;
+    realtimeProviderContract?: VoiceSurfaceConfig<import("./realtimeProviderContracts").VoiceRealtimeProviderContractRoutesOptions>;
+    reconnectContract?: VoiceSurfaceConfig<import("./reconnectContract").VoiceReconnectContractRoutesOptions>;
+    reconnectProof?: VoiceSurfaceConfig<import("./reconnectContract").VoiceReconnectProofRoutesOptions>;
+    resilience?: VoiceSurfaceConfig<import("./resilienceRoutes").VoiceResilienceRoutesOptions>;
+    sessionList?: VoiceSurfaceConfig<import("./sessionReplay").VoiceSessionListRoutesOptions>;
+    sessionObservability?: VoiceSurfaceConfig<import("./sessionObservability").VoiceSessionObservabilityRoutesOptions>;
+    sessionReplay?: VoiceSurfaceConfig<import("./sessionReplay").VoiceSessionReplayRoutesOptions>;
+    sessionSnapshot?: VoiceSurfaceConfig<import("./sessionSnapshot").VoiceSessionSnapshotRoutesOptions>;
+    simulationSuite?: VoiceSurfaceConfig<import("./simulationSuite").VoiceSimulationSuiteRoutesOptions>;
+    sloCalibration?: VoiceSurfaceConfig<import("./sloCalibration").VoiceSloCalibrationRoutesOptions>;
+    sloReadinessThreshold?: VoiceSurfaceConfig<import("./sloCalibration").VoiceSloReadinessThresholdRoutesOptions>;
+    telephonyCarrierMatrix?: VoiceSurfaceConfig<import("../telephony/matrix").VoiceTelephonyCarrierMatrixRoutesOptions>;
+    telephonyMedia?: VoiceSurfaceConfig<import("./telephonyMediaRoutes").VoiceTelephonyMediaRoutesOptions>;
+    telephonyWebhook?: VoiceSurfaceConfig<import("./telephonyOutcome").VoiceTelephonyWebhookRoutesOptions>;
+    telephonyWebhookSecurity?: VoiceSurfaceConfig<import("../telephony/security").VoiceTelephonyWebhookSecurityRoutesOptions>;
+    toolContract?: VoiceSurfaceConfig<import("./toolContract").VoiceToolContractRoutesOptions>;
+    traceDelivery?: VoiceSurfaceConfig<import("./traceDeliveryRoutes").VoiceTraceDeliveryRoutesOptions>;
+    traceTimeline?: VoiceSurfaceConfig<import("./traceTimeline").VoiceTraceTimelineRoutesOptions>;
+    turnLatency?: VoiceSurfaceConfig<import("./turnLatency").VoiceTurnLatencyRoutesOptions>;
+    turnQuality?: VoiceSurfaceConfig<import("./turnQuality").VoiceTurnQualityRoutesOptions>;
 } & VoiceRouteConfig<TContext, TSession, TResult>;
+export type VoiceSessionRecordingConfig = {
+    channels?: ReadonlyArray<"assistant" | "user">;
+    maxBytesPerChannel?: number;
+    store: import("./recordingStore").VoiceRecordingStore;
+    userInputFormat?: AudioFormat;
+};
 export type CreateVoiceSessionOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
     costTelemetry?: VoiceCostTelemetryConfig<TContext, TSession, TResult>;
     id: string;
     context: TContext;
     socket: VoiceSocket;
-    stt: STTAdapter;
+    greeting?: string | ((input: {
+        session: TSession;
+    }) => string | Promise<string>);
+    stt?: STTAdapter;
+    realtime?: RealtimeAdapter;
+    realtimeInputFormat?: AudioFormat;
     tts?: TTSAdapter;
     languageStrategy?: VoiceLanguageStrategy;
     lexicon?: VoiceLexiconEntry[];
     sttFallback?: VoiceResolvedSTTFallbackConfig;
     store: VoiceSessionStore<TSession>;
     trace?: VoiceTraceEventStore;
+    recording?: VoiceSessionRecordingConfig;
+    callSilenceTimeoutMs?: number;
+    amd?: import("./amdDetector").VoiceAMDDetector<TContext, TSession, TResult>;
+    costAccountant?: import("./costAccounting").VoiceCostAccountant;
+    costTelephony?: {
+        provider?: string;
+    };
+    redact?: import("./redaction").VoiceTranscriptRedactor;
+    semanticTurnDetector?: import("./semanticTurn").VoiceSemanticTurnDetector;
+    /**
+     * Pre-rendered filler phrases the runtime plays in the gap between
+     * user-turn-commit and real assistant audio (typically 800-1500ms). The
+     * caller hears something within ~150-300ms of stopping speaking, so the
+     * LLM/TTS latency feels like the bot thinking instead of dead air. Boardy's
+     * killer UX feature.
+     *
+     * Behavior:
+     *  - After a turn commits, a timer fires at `fillerDelayMs` (default
+     *    250ms). At that point, if the real assistant audio for this turn
+     *    hasn't started flowing yet, a random phrase is rendered via the
+     *    configured `tts` adapter and pushed to the socket.
+     *  - When the real assistant audio's first chunk arrives, any in-flight
+     *    filler is cancelled (`cancelActiveTTS` clears the carrier buffer).
+     *  - Cooldown protects against double-fillers per turn.
+     *
+     * Set `fillerPhrases: []` (or omit) to disable. Reasonable defaults if
+     * you enable: `["Hmm.", "Got it.", "Right.", "Mm-hm.", "Let me think.", "Okay."]`.
+     */
+    /**
+     * Minimum word count in an STT partial transcript before speech-gated
+     * barge-in cancels the in-flight assistant TTS. Default 1 (any non-empty
+     * partial triggers barge-in — backwards-compatible).
+     *
+     * Set to 2 (or higher) on phone routes where the caller's brief
+     * acknowledgements ("yeah", "uh-huh", "you", "am i") would otherwise
+     * cut the bot off mid-question. Each extra word added typically delays
+     * barge-in by ~100-200ms (one extra STT partial cycle) — cheap compared
+     * to losing the bot's response.
+     *
+     * Word splitting is whitespace-based. Punctuation is left attached.
+     */
+    bargeInMinPartialWords?: number;
+    fillerPhrases?: ReadonlyArray<string>;
+    /** Milliseconds after turn-commit before the filler fires. Default 250ms — short enough to feel instant, long enough to skip if the LLM is very fast. */
+    fillerDelayMs?: number;
+    /**
+     * Latency Theater — content-aware filler (Boardy parity move). When
+     * defined, the runtime calls `fillerFor({ userText, ... })` in parallel
+     * with the main LLM call to generate a brief acknowledgement of what the
+     * caller just said ("Freelance CFOs — interesting.", "Yeah, I hear you.").
+     * The runtime races the promise against `fillerForTimeoutMs` (default
+     * 600ms). If `fillerFor` returns a non-empty string in time, it's spoken
+     * INSTEAD of a random `fillerPhrases` entry. On timeout or null return,
+     * the runtime falls back to a static random phrase, so a slow / failed
+     * acknowledgement call never costs you the filler entirely.
+     *
+     * Return `null` (or an empty string) to explicitly skip filler for this
+     * turn — useful when `userText` is so short ("yes", "no", "okay") that
+     * acknowledging it back sounds robotic. Return throws are caught and
+     * treated as null.
+     *
+     * Cost-aware: callers typically wire this to a cheap nano/haiku model
+     * (gpt-4.1-nano, claude-haiku-4-5) that returns 2–5 words.
+     */
+    fillerFor?: (input: {
+        sessionId: string;
+        turnId: string;
+        userText: string;
+    }) => Promise<string | null>;
+    /** Ceiling for the `fillerFor` call before we fall back to a static phrase. Default 600ms. */
+    fillerForTimeoutMs?: number;
+    /**
+     * Default spoken ack if the model returns ONLY tool calls (no text) and the
+     * turn isn't ending. Without this, the caller hears total silence after
+     * their turn and assumes the line dropped. Default is "Sorry, one moment."
+     * Set to "" to opt out entirely.
+     */
+    defaultSilentTurnAck?: string;
+    /**
+     * Hard timeout on a single `route.onTurn` call. If onTurn hasn't resolved
+     * in this many ms, it's rejected with a hard-timeout error which falls
+     * through to defaultSilentTurnAck. Default 45s — generous for normal
+     * conversational LLM calls (1-3s typical), but catches hangs where the
+     * model adapter's own timeout doesn't fire. Set to 0 to disable.
+     */
+    routeOnTurnTimeoutMs?: number;
+    assistantMode?: import("./assistantMode").VoiceAssistantMode;
+    modalities?: ReadonlyArray<"audio" | "text">;
+    prosody?: VoiceTTSProsody;
     reconnect: Required<VoiceReconnectConfig>;
     phraseHints?: VoicePhraseHint[];
+    sessionMetadata?: Record<string, unknown>;
     scenarioId?: string;
     sttLifecycle: VoiceSTTLifecycle;
     turnDetection: VoiceResolvedTurnDetectionConfig;
     audioConditioning?: VoiceResolvedAudioConditioningConfig;
+    noiseSuppressor?: VoiceNoiseSuppressor;
+    noiseSuppressorFormat?: AudioFormat;
     handoff?: VoiceHandoffConfig<TContext, TSession, TResult>;
+    liveOps?: VoiceLiveOpsRuntimeConfig;
     route: VoiceNormalizedRouteConfig<TContext, TSession, TResult>;
     logger?: VoiceLogger;
 };
 export type CreateVoiceSession = <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: CreateVoiceSessionOptions<TContext, TSession, TResult>) => VoiceSessionHandle<TContext, TSession, TResult>;
 export type VoiceClientStartMessage = {
-    type: 'start';
+    type: "start";
     sessionId?: string;
     scenarioId?: string;
 };
 export type VoiceClientEndTurnMessage = {
-    type: 'end_turn';
+    type: "end_turn";
 };
 export type VoiceClientCloseMessage = {
-    type: 'close';
+    type: "close";
     reason?: string;
 };
 export type VoiceClientCallControlMessage = {
-    type: 'call_control';
-    action: 'complete' | 'escalate' | 'no-answer' | 'transfer' | 'voicemail';
+    type: "call_control";
+    action: "complete" | "escalate" | "no-answer" | "transfer" | "voicemail";
     metadata?: Record<string, unknown>;
     reason?: string;
     target?: string;
 };
 export type VoiceClientPingMessage = {
-    type: 'ping';
+    type: "ping";
 };
 export type VoiceClientMessage = VoiceClientStartMessage | VoiceClientEndTurnMessage | VoiceClientCloseMessage | VoiceClientCallControlMessage | VoiceClientPingMessage;
 export type VoiceServerSessionMessage = {
-    type: 'session';
+    type: "session";
     sessionId: string;
     status: VoiceSessionStatus;
     scenarioId?: string;
+    sessionMetadata?: Record<string, unknown>;
+};
+export type VoiceServerReplayMessage<TResult = unknown> = {
+    type: "replay";
+    assistantTexts: string[];
+    call?: VoiceCallLifecycleState;
+    partial: string;
+    scenarioId?: string;
+    sessionId: string;
+    sessionMetadata?: Record<string, unknown>;
+    status: VoiceSessionStatus;
+    turns: VoiceTurnRecord<TResult>[];
 };
 export type VoiceServerPartialMessage = {
-    type: 'partial';
+    type: "partial";
     transcript: Transcript;
 };
 export type VoiceServerFinalMessage = {
-    type: 'final';
+    type: "final";
     transcript: Transcript;
 };
 export type VoiceServerTurnMessage<TResult = unknown> = {
-    type: 'turn';
+    type: "turn";
     turn: VoiceTurnRecord<TResult>;
 };
 export type VoiceServerAssistantMessage = {
-    type: 'assistant';
+    type: "assistant";
     text: string;
     turnId?: string;
 };
+export type VoiceServerAssistantDeltaMessage = {
+    type: "assistant_delta";
+    delta: string;
+    turnId?: string;
+};
 export type VoiceServerAudioMessage = {
-    type: 'audio';
+    type: "audio";
     chunkBase64: string;
     format: AudioFormat;
     receivedAt: number;
     turnId?: string;
 };
 export type VoiceServerCompleteMessage = {
-    type: 'complete';
+    type: "complete";
     sessionId: string;
 };
 export type VoiceServerCallLifecycleMessage = {
-    type: 'call_lifecycle';
+    type: "call_lifecycle";
     event: VoiceCallLifecycleEvent;
     sessionId: string;
 };
 export type VoiceServerErrorMessage = {
-    type: 'error';
+    type: "error";
     message: string;
     recoverable?: boolean;
 };
 export type VoiceServerPongMessage = {
-    type: 'pong';
+    type: "pong";
+};
+export type VoiceServerConnectionMessage = {
+    type: "connection";
+    reconnect: VoiceReconnectClientState;
 };
-export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerAudioMessage | VoiceServerCallLifecycleMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage;
+export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerReplayMessage<TResult> | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerAssistantDeltaMessage | VoiceServerAudioMessage | VoiceServerCallLifecycleMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage | VoiceServerConnectionMessage;
 export type VoiceConnectionOptions = {
+    browserMedia?: false | VoiceBrowserMediaReporterOptions;
     protocols?: string[];
     scenarioId?: string;
     reconnect?: boolean;
+    reconnectReportPath?: string;
     maxReconnectAttempts?: number;
     pingInterval?: number;
     sessionId?: string;
 };
+export type VoiceBrowserMediaReportPayload = {
+    at: number;
+    continuity?: MediaWebRTCStreamContinuityReport;
+    report: MediaWebRTCStatsReport;
+    scenarioId?: string | null;
+    sessionId?: string | null;
+};
+export type VoiceBrowserMediaReporterOptions = Omit<MediaWebRTCStatsReportInput, "peerConnection"> & {
+    fetch?: typeof fetch;
+    getPeerConnection?: (() => MediaWebRTCStatsCollector | null | undefined) | (() => Promise<MediaWebRTCStatsCollector | null | undefined>);
+    getScenarioId?: () => string | null | undefined;
+    getSessionId?: () => string | null | undefined;
+    intervalMs?: number;
+    continuity?: false | Omit<MediaWebRTCStreamContinuityInput, "previousStats" | "stats">;
+    onError?: (error: unknown) => void;
+    onReport?: (payload: VoiceBrowserMediaReportPayload) => void;
+    path?: string;
+    peerConnection?: MediaWebRTCStatsCollector;
+};
 export type VoiceCaptureOptions = {
     channelCount?: 1 | 2;
+    onAudio?: (audio: Uint8Array | ArrayBuffer, sendAudio: (audio: Uint8Array | ArrayBuffer) => void) => void;
     onLevel?: (level: number) => void;
     sampleRateHz?: number;
 };
@@ -747,20 +1138,61 @@ export type VoiceBargeInOptions = {
     enabled?: boolean;
     interruptOnPartial?: boolean;
     interruptThreshold?: number;
+    monitor?: VoiceBargeInMonitor;
+};
+export type VoiceBargeInTriggerReason = "input-level" | "manual-audio" | "manual-interrupt" | "partial-transcript";
+export type VoiceBargeInMonitorEvent = {
+    at: number;
+    id: string;
+    latencyMs?: number;
+    playbackStopLatencyMs?: number;
+    reason: VoiceBargeInTriggerReason;
+    sessionId?: string | null;
+    status: "requested" | "stopped" | "skipped";
+    thresholdMs?: number;
+};
+export type VoiceBargeInMonitorSnapshot = {
+    averageLatencyMs?: number;
+    events: VoiceBargeInMonitorEvent[];
+    failed: number;
+    lastEvent?: VoiceBargeInMonitorEvent;
+    passed: number;
+    status: "empty" | "fail" | "pass" | "warn";
+    thresholdMs: number;
+    total: number;
+};
+export type VoiceBargeInMonitor = {
+    getSnapshot: () => VoiceBargeInMonitorSnapshot;
+    recordRequested: (input: {
+        reason: VoiceBargeInTriggerReason;
+        sessionId?: string | null;
+    }) => VoiceBargeInMonitorEvent;
+    recordSkipped: (input: {
+        reason: VoiceBargeInTriggerReason;
+        sessionId?: string | null;
+    }) => VoiceBargeInMonitorEvent;
+    recordStopped: (input: {
+        latencyMs?: number;
+        playbackStopLatencyMs?: number;
+        reason: VoiceBargeInTriggerReason;
+        sessionId?: string | null;
+    }) => VoiceBargeInMonitorEvent;
+    subscribe: (subscriber: () => void) => () => void;
 };
 export type VoiceAudioPlayerOptions = {
     autoStart?: boolean;
     createAudioContext?: () => AudioContext;
     lookaheadMs?: number;
+    volume?: number;
 };
 export type VoiceDuplexControllerOptions = VoiceControllerOptions & {
     audioPlayer?: VoiceAudioPlayerOptions;
     bargeIn?: VoiceBargeInOptions;
 };
-export type VoiceSTTRoutingGoal = 'best' | 'low-cost';
-export type VoiceSTTRoutingCorrectionMode = 'generic' | 'none' | 'risky-turn';
+export type VoiceSTTRoutingGoal = "best" | "low-cost";
+export type VoiceSTTRoutingCorrectionMode = "generic" | "none" | "risky-turn";
 export type VoiceSTTRoutingStrategy = {
-    benchmarkSessionTarget: 'deepgram-corrected' | 'deepgram-flux';
+    benchmarkSessionTarget: "deepgram-corrected" | "deepgram-flux";
     correctionMode: VoiceSTTRoutingCorrectionMode;
     goal: VoiceSTTRoutingGoal;
     notes: string[];
@@ -774,7 +1206,7 @@ export type VoiceHTMXRenderInput<TResult = unknown, TSession extends VoiceSessio
     result?: TResult;
     session?: TSession;
     sessionId?: string;
-    status: VoiceSessionStatus | 'idle';
+    status: VoiceSessionStatus | "idle";
     turnCount: number;
     turns: VoiceTurnRecord<TResult>[];
 };
@@ -802,12 +1234,15 @@ export type VoiceHTMXOptions<TSession extends VoiceSessionRecord = VoiceSessionR
 export type VoiceHTMXConfig<TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceHTMXRenderer<TSession, TResult> | VoiceHTMXOptions<TSession, TResult>;
 export type VoiceStreamState<TResult = unknown> = {
     call: VoiceCallLifecycleState | null;
+    sessionMetadata: Record<string, unknown> | null;
     sessionId: string | null;
     scenarioId: string | null;
-    status: VoiceSessionStatus | 'idle';
+    status: VoiceSessionStatus | "idle";
+    reconnect: VoiceReconnectClientState;
     partial: string;
     turns: VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantStreamingText: string;
     assistantAudio: Array<{
         chunk: Uint8Array;
         format: AudioFormat;
@@ -819,7 +1254,7 @@ export type VoiceStreamState<TResult = unknown> = {
 };
 export type VoiceStream<TResult = unknown> = {
     call: VoiceCallLifecycleState | null;
-    callControl: (message: Omit<VoiceClientCallControlMessage, 'type'>) => void;
+    callControl: (message: Omit<VoiceClientCallControlMessage, "type">) => void;
     close: () => void;
     start: (input?: {
         scenarioId?: string;
@@ -831,13 +1266,17 @@ export type VoiceStream<TResult = unknown> = {
     getSnapshot: () => VoiceStreamState<TResult>;
     isConnected: boolean;
     partial: string;
+    reconnect: VoiceReconnectClientState;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
     sessionId: string | null;
+    sessionMetadata: Record<string, unknown> | null;
     scenarioId: string | null;
-    status: VoiceSessionStatus | 'idle';
+    status: VoiceSessionStatus | "idle";
     subscribe: (subscriber: () => void) => () => void;
     turns: VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantStreamingText: string;
     assistantAudio: Array<{
         chunk: Uint8Array;
         format: AudioFormat;
@@ -860,7 +1299,7 @@ export type VoiceAudioPlayerState = {
     queuedChunkCount: number;
 };
 export type VoiceAudioPlayerSource = {
-    assistantAudio: VoiceStreamState['assistantAudio'];
+    assistantAudio: VoiceStreamState["assistantAudio"];
     subscribe: (subscriber: () => void) => () => void;
 };
 export type VoiceAudioPlayer = {
@@ -876,8 +1315,10 @@ export type VoiceAudioPlayer = {
     pause: () => Promise<void>;
     processedChunkCount: number;
     queuedChunkCount: number;
+    setVolume: (volume: number) => void;
     start: () => Promise<void>;
     subscribe: (subscriber: () => void) => () => void;
+    volume: number;
 };
 export type VoiceBargeInBinding = {
     close: () => void;
@@ -887,7 +1328,7 @@ export type VoiceBargeInBinding = {
 export type VoiceController<TResult = unknown> = {
     bindHTMX: (options: VoiceHTMXBindingOptions) => () => void;
     call: VoiceCallLifecycleState | null;
-    callControl: (message: Omit<VoiceClientCallControlMessage, 'type'>) => void;
+    callControl: (message: Omit<VoiceClientCallControlMessage, "type">) => void;
     close: () => void;
     endTurn: () => void;
     start: (input?: {
@@ -900,17 +1341,21 @@ export type VoiceController<TResult = unknown> = {
     isConnected: boolean;
     isRecording: boolean;
     partial: string;
+    reconnect: VoiceReconnectClientState;
     recordingError: string | null;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+    simulateDisconnect: () => void;
     sessionId: string | null;
+    sessionMetadata: Record<string, unknown> | null;
     scenarioId: string | null;
     startRecording: () => Promise<void>;
-    status: VoiceSessionStatus | 'idle';
+    status: VoiceSessionStatus | "idle";
     stopRecording: () => void;
     subscribe: (subscriber: () => void) => () => void;
     toggleRecording: () => Promise<void>;
     turns: VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantStreamingText: string;
     assistantAudio: Array<{
         chunk: Uint8Array;
         format: AudioFormat;
@@ -929,40 +1374,59 @@ export type VoiceHTMXBindingOptions = {
     sessionQueryParam?: string;
 };
 export type VoiceStoreAction<TResult = unknown> = {
-    type: 'session';
+    type: "session";
     sessionId: string;
+    sessionMetadata?: Record<string, unknown>;
     scenarioId?: string;
     status: VoiceSessionStatus;
 } | {
-    type: 'call_lifecycle';
+    type: "replay";
+    assistantTexts: string[];
+    call?: VoiceCallLifecycleState;
+    partial: string;
+    scenarioId?: string;
+    sessionId: string;
+    sessionMetadata?: Record<string, unknown>;
+    status: VoiceSessionStatus;
+    turns: VoiceTurnRecord<TResult>[];
+} | {
+    type: "call_lifecycle";
     event: VoiceCallLifecycleEvent;
     sessionId: string;
 } | {
-    type: 'partial';
+    type: "partial";
     transcript: Transcript;
 } | {
-    type: 'final';
+    type: "final";
     transcript: Transcript;
 } | {
-    type: 'turn';
+    type: "turn";
     turn: VoiceTurnRecord<TResult>;
 } | {
-    type: 'assistant';
+    type: "assistant";
     text: string;
+    turnId?: string;
 } | {
-    type: 'audio';
+    type: "assistant_delta";
+    delta: string;
+    turnId?: string;
+} | {
+    type: "audio";
     chunk: Uint8Array;
     format: AudioFormat;
     receivedAt: number;
     turnId?: string;
 } | {
-    type: 'complete';
+    type: "complete";
     sessionId: string;
 } | {
-    type: 'error';
+    type: "error";
     message: string;
 } | {
-    type: 'connected';
+    type: "connected";
+} | {
+    type: "connection";
+    reconnect: VoiceReconnectClientState;
 } | {
-    type: 'disconnected';
+    type: "disconnected";
 };