@absolutejs/voice 0.0.21 → 0.0.22-beta.0

package/dist/types.d.ts

@@ -1,23 +1,54 @@
 import type { SessionStore } from '@absolutejs/absolute';
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from './ops';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
 export type AudioFormat = {
     container: 'raw';
-    encoding: 'pcm_s16le';
+    encoding: 'alaw' | 'mulaw' | 'pcm_s16le';
     sampleRateHz: number;
     channels: 1 | 2;
 };
 export type AudioChunk = ArrayBuffer | ArrayBufferView;
+export type VoiceLanguageStrategy = {
+    mode: 'auto-detect';
+    allowedLanguages?: string[];
+} | {
+    mode: 'fixed';
+    primaryLanguage: string;
+    secondaryLanguages?: string[];
+} | {
+    mode: 'allow-switching';
+    primaryLanguage?: string;
+    secondaryLanguages: string[];
+};
 export type VoicePhraseHint = {
     text: string;
     aliases?: string[];
     boost?: number;
     metadata?: Record<string, unknown>;
 };
+export type VoiceCorrectionRiskTier = 'safe' | 'balanced' | 'risky';
+export type VoiceDomainTerm = {
+    text: string;
+    aliases?: string[];
+    boost?: number;
+    language?: string;
+    metadata?: Record<string, unknown>;
+    pronunciation?: string;
+};
+export type VoiceLexiconEntry = {
+    text: string;
+    aliases?: string[];
+    language?: string;
+    metadata?: Record<string, unknown>;
+    pronunciation?: string;
+};
 export type Transcript = {
     id: string;
     text: string;
     isFinal: boolean;
     confidence?: number;
     language?: string;
+    speaker?: string | number;
     startedAtMs?: number;
     endedAtMs?: number;
     vendor?: string;
@@ -26,6 +57,7 @@ export type VoiceTranscriptQuality = {
     averageConfidence?: number;
     confidenceSampleCount: number;
     correction?: VoiceTurnCorrectionDiagnostics;
+    cost?: VoiceTurnCostEstimate;
     fallbackUsed: boolean;
     finalTranscriptCount: number;
     fallback?: VoiceFallbackDiagnostics;
@@ -42,6 +74,13 @@ export type VoiceTurnCorrectionDiagnostics = {
     provider?: string;
     reason?: string;
 };
+export type VoiceTurnCostEstimate = {
+    estimatedRelativeCostUnits: number;
+    fallbackAttemptCount: number;
+    fallbackReplayAudioMs: number;
+    primaryAudioMs: number;
+    totalBillableAudioMs: number;
+};
 export type VoiceFallbackSelectionReason = 'fallback-empty' | 'primary-empty' | 'word-count-margin' | 'confidence-margin' | 'word-count-tiebreak' | 'kept-primary';
 export type VoiceFallbackDiagnostics = {
     attempted: boolean;
@@ -97,6 +136,8 @@ export type STTAdapterSession = {
 export type STTAdapterOpenOptions = {
     sessionId: string;
     format: AudioFormat;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
     phraseHints?: VoicePhraseHint[];
     signal?: AbortSignal;
 };
@@ -122,6 +163,7 @@ export type TTSAdapterSession = {
 };
 export type TTSAdapterOpenOptions = {
     sessionId: string;
+    lexicon?: VoiceLexiconEntry[];
     signal?: AbortSignal;
 };
 export type TTSAdapter<TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions> = {
@@ -139,6 +181,8 @@ export type RealtimeAdapterSession = {
 export type RealtimeAdapterOpenOptions = {
     sessionId: string;
     format: AudioFormat;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
     phraseHints?: VoicePhraseHint[];
     signal?: AbortSignal;
 };
@@ -156,6 +200,17 @@ export type VoiceTurnRecord<TResult = unknown> = {
     committedAt: number;
     result?: TResult;
 };
+export type VoiceCostTelemetryConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    fallbackPassCostUnit?: number;
+    onTurnCost?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        estimate: VoiceTurnCostEstimate;
+        session: TSession;
+        turn: VoiceTurnRecord<TResult>;
+    }) => Promise<void> | void;
+    primaryPassCostUnit?: number;
+};
 export type VoiceSessionRecord<TMeta = Record<string, never>, TResult = unknown> = {
     id: string;
     createdAt: number;
@@ -185,6 +240,7 @@ export type VoiceSessionRecord<TMeta = Record<string, never>, TResult = unknown>
         transcriptIds: string[];
         committedAt: number;
     };
+    call?: VoiceCallLifecycleState;
     metadata?: TMeta;
     scenarioId?: string;
 };
@@ -195,6 +251,22 @@ export type VoiceSessionSummary = {
     status: VoiceSessionStatus;
     turnCount: number;
 };
+export type VoiceCallDisposition = 'completed' | 'transferred' | 'escalated' | 'voicemail' | 'no-answer' | 'failed' | 'closed';
+export type VoiceCallLifecycleEvent = {
+    at: number;
+    type: 'start' | 'end' | 'transfer' | 'escalation' | 'voicemail' | 'no-answer';
+    disposition?: VoiceCallDisposition;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    target?: string;
+};
+export type VoiceCallLifecycleState = {
+    disposition?: VoiceCallDisposition;
+    endedAt?: number;
+    events: VoiceCallLifecycleEvent[];
+    lastEventAt: number;
+    startedAt: number;
+};
 export type VoiceSessionStore<TSession extends VoiceSessionRecord = VoiceSessionRecord> = SessionStore<TSession, VoiceSessionSummary>;
 export type VoiceLogger = {
     debug?: (message: string, meta?: Record<string, unknown>) => void;
@@ -207,7 +279,7 @@ export type VoiceReconnectConfig = {
     timeout?: number;
     maxAttempts?: number;
 };
-export type VoiceRuntimePreset = 'default' | 'chat' | 'guided-intake' | 'dictation' | 'noisy-room' | 'reliability';
+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';
@@ -271,7 +343,26 @@ export type VoiceSessionHandle<TContext = unknown, TSession extends VoiceSession
     commitTurn: (reason?: VoiceEndOfTurnEvent['reason']) => Promise<void>;
     disconnect: (event?: VoiceCloseEvent) => Promise<void>;
     complete: (result?: TResult) => Promise<void>;
+    escalate: (input: {
+        metadata?: Record<string, unknown>;
+        reason: string;
+        result?: TResult;
+    }) => Promise<void>;
     fail: (error: unknown) => Promise<void>;
+    markNoAnswer: (input?: {
+        metadata?: Record<string, unknown>;
+        result?: TResult;
+    }) => Promise<void>;
+    markVoicemail: (input?: {
+        metadata?: Record<string, unknown>;
+        result?: TResult;
+    }) => Promise<void>;
+    transfer: (input: {
+        metadata?: Record<string, unknown>;
+        reason?: string;
+        result?: TResult;
+        target: string;
+    }) => Promise<void>;
     close: (reason?: string) => Promise<void>;
     snapshot: () => Promise<TSession>;
 };
@@ -279,6 +370,21 @@ export type VoiceRouteResult<TResult = unknown> = {
     complete?: boolean;
     result?: TResult;
     assistantText?: string;
+    transfer?: {
+        metadata?: Record<string, unknown>;
+        reason?: string;
+        target: string;
+    };
+    escalate?: {
+        metadata?: Record<string, unknown>;
+        reason: string;
+    };
+    voicemail?: {
+        metadata?: Record<string, unknown>;
+    };
+    noAnswer?: {
+        metadata?: Record<string, unknown>;
+    };
 };
 export type VoiceTurnCorrectionResult = string | {
     text: string;
@@ -290,6 +396,7 @@ export type VoiceTurnCorrectionHandler<TContext = unknown, TSession extends Voic
     api: VoiceSessionHandle<TContext, TSession, TResult>;
     context: TContext;
     fallback?: VoiceFallbackDiagnostics;
+    lexicon: VoiceLexiconEntry[];
     phraseHints: VoicePhraseHint[];
     session: TSession;
     text: string;
@@ -300,6 +407,11 @@ export type VoicePhraseHintResolver<TContext = unknown> = (input: {
     scenarioId?: string;
     sessionId: string;
 }) => Promise<VoicePhraseHint[] | void> | VoicePhraseHint[] | void;
+export type VoiceLexiconResolver<TContext = unknown> = (input: {
+    context: TContext;
+    scenarioId?: string;
+    sessionId: string;
+}) => Promise<VoiceLexiconEntry[] | void> | VoiceLexiconEntry[] | void;
 export type VoiceOnTurnObjectHandler<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: {
     context: TContext;
     session: TSession;
@@ -308,6 +420,20 @@ export type VoiceOnTurnObjectHandler<TContext = unknown, TSession extends VoiceS
 }) => Promise<VoiceRouteResult<TResult> | void> | VoiceRouteResult<TResult> | void;
 export type VoiceOnTurnHandler<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceOnTurnObjectHandler<TContext, TSession, TResult> | ((session: TSession, turn: VoiceTurnRecord, api: VoiceSessionHandle<TContext, TSession, TResult>, context: TContext) => Promise<VoiceRouteResult<TResult> | void> | VoiceRouteResult<TResult> | void);
 export type VoiceRouteConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    onCallStart?: (input: {
+        context: TContext;
+        session: TSession;
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+    }) => Promise<void> | void;
+    onCallEnd?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        disposition: VoiceCallDisposition;
+        metadata?: Record<string, unknown>;
+        reason?: string;
+        session: TSession;
+        target?: string;
+    }) => Promise<void> | void;
     onSession?: (input: {
         context: TContext;
         session: TSession;
@@ -327,6 +453,61 @@ export type VoiceRouteConfig<TContext = unknown, TSession extends VoiceSessionRe
         error: unknown;
         api?: VoiceSessionHandle<TContext, TSession, TResult>;
     }) => Promise<void> | void;
+    onEscalation?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        metadata?: Record<string, unknown>;
+        reason: string;
+        session: TSession;
+    }) => Promise<void> | void;
+    onNoAnswer?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        metadata?: Record<string, unknown>;
+        session: TSession;
+    }) => Promise<void> | void;
+    onTransfer?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        metadata?: Record<string, unknown>;
+        reason?: string;
+        session: TSession;
+        target: string;
+    }) => Promise<void> | void;
+    onVoicemail?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        metadata?: Record<string, unknown>;
+        session: TSession;
+    }) => Promise<void> | void;
+};
+export type VoiceRuntimeOpsConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    buildReview?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        disposition: VoiceCallDisposition;
+        metadata?: Record<string, unknown>;
+        reason?: string;
+        result?: TResult;
+        session: TSession;
+        target?: string;
+    }) => Promise<VoiceCallReviewArtifact | StoredVoiceCallReviewArtifact | void> | VoiceCallReviewArtifact | StoredVoiceCallReviewArtifact | void;
+    createTaskFromReview?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        disposition: VoiceCallDisposition;
+        review: StoredVoiceCallReviewArtifact;
+        session: TSession;
+    }) => Promise<Omit<VoiceOpsTask, 'id'> | VoiceOpsTask | StoredVoiceOpsTask | null | void> | Omit<VoiceOpsTask, 'id'> | VoiceOpsTask | StoredVoiceOpsTask | null | void;
+    events?: VoiceIntegrationEventStore;
+    onEvent?: (input: {
+        api: VoiceSessionHandle<TContext, TSession, TResult>;
+        context: TContext;
+        event: StoredVoiceIntegrationEvent;
+        session: TSession;
+    }) => Promise<void> | void;
+    reviews?: VoiceCallReviewStore;
+    tasks?: VoiceOpsTaskStore;
 };
 export type VoiceNormalizedRouteConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Omit<VoiceRouteConfig<TContext, TSession, TResult>, 'onTurn'> & {
     onTurn: VoiceOnTurnObjectHandler<TContext, TSession, TResult>;
@@ -337,8 +518,15 @@ export type VoiceScenario = {
     description?: string;
     metadata?: Record<string, unknown>;
 };
+export type VoiceExpectedSpeakerTurn = {
+    speaker: string;
+    text: string;
+};
 export type VoicePluginConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    costTelemetry?: VoiceCostTelemetryConfig<TContext, TSession, TResult>;
     path: string;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[] | VoiceLexiconResolver<TContext>;
     phraseHints?: VoicePhraseHint[] | VoicePhraseHintResolver<TContext>;
     preset?: VoiceRuntimePreset;
     stt: STTAdapter;
@@ -351,12 +539,17 @@ export type VoicePluginConfig<TContext = unknown, TSession extends VoiceSessionR
     audioConditioning?: VoiceAudioConditioningConfig;
     logger?: VoiceLogger;
     htmx?: boolean | VoiceHTMXConfig<TSession, NoInfer<TResult>>;
+    ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
 } & VoiceRouteConfig<TContext, TSession, TResult>;
 export type CreateVoiceSessionOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    costTelemetry?: VoiceCostTelemetryConfig<TContext, TSession, TResult>;
     id: string;
     context: TContext;
     socket: VoiceSocket;
     stt: STTAdapter;
+    tts?: TTSAdapter;
+    languageStrategy?: VoiceLanguageStrategy;
+    lexicon?: VoiceLexiconEntry[];
     sttFallback?: VoiceResolvedSTTFallbackConfig;
     store: VoiceSessionStore<TSession>;
     reconnect: Required<VoiceReconnectConfig>;
@@ -408,6 +601,13 @@ export type VoiceServerAssistantMessage = {
     text: string;
     turnId?: string;
 };
+export type VoiceServerAudioMessage = {
+    type: 'audio';
+    chunkBase64: string;
+    format: AudioFormat;
+    receivedAt: number;
+    turnId?: string;
+};
 export type VoiceServerCompleteMessage = {
     type: 'complete';
     sessionId: string;
@@ -420,7 +620,7 @@ export type VoiceServerErrorMessage = {
 export type VoiceServerPongMessage = {
     type: 'pong';
 };
-export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage;
+export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerAudioMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage;
 export type VoiceConnectionOptions = {
     protocols?: string[];
     scenarioId?: string;
@@ -440,6 +640,30 @@ export type VoiceControllerOptions = {
     capture?: VoiceCaptureOptions;
     autoStopOnComplete?: boolean;
 };
+export type VoiceBargeInOptions = {
+    enabled?: boolean;
+    interruptOnPartial?: boolean;
+    interruptThreshold?: number;
+};
+export type VoiceAudioPlayerOptions = {
+    autoStart?: boolean;
+    createAudioContext?: () => AudioContext;
+    lookaheadMs?: number;
+};
+export type VoiceDuplexControllerOptions = VoiceControllerOptions & {
+    audioPlayer?: VoiceAudioPlayerOptions;
+    bargeIn?: VoiceBargeInOptions;
+};
+export type VoiceSTTRoutingGoal = 'best' | 'low-cost';
+export type VoiceSTTRoutingCorrectionMode = 'generic' | 'none' | 'risky-turn';
+export type VoiceSTTRoutingStrategy = {
+    benchmarkSessionTarget: 'deepgram-corrected' | 'deepgram-flux';
+    correctionMode: VoiceSTTRoutingCorrectionMode;
+    goal: VoiceSTTRoutingGoal;
+    notes: string[];
+    preset: VoiceRuntimePreset;
+    sttLifecycle: VoiceSTTLifecycle;
+};
 export type VoiceHTMXRenderInput<TResult = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
     assistantTexts: string[];
     partial: string;
@@ -480,6 +704,12 @@ export type VoiceStreamState<TResult = unknown> = {
     partial: string;
     turns: VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantAudio: Array<{
+        chunk: Uint8Array;
+        format: AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }>;
     error: string | null;
     isConnected: boolean;
 };
@@ -502,11 +732,52 @@ export type VoiceStream<TResult = unknown> = {
     subscribe: (subscriber: () => void) => () => void;
     turns: VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantAudio: Array<{
+        chunk: Uint8Array;
+        format: AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }>;
 };
 export type VoiceControllerState<TResult = unknown> = VoiceStreamState<TResult> & {
     isRecording: boolean;
     recordingError: string | null;
 };
+export type VoiceAudioPlayerState = {
+    activeSourceCount: number;
+    error: string | null;
+    isActive: boolean;
+    isPlaying: boolean;
+    lastInterruptLatencyMs?: number;
+    lastPlaybackStopLatencyMs?: number;
+    processedChunkCount: number;
+    queuedChunkCount: number;
+};
+export type VoiceAudioPlayerSource = {
+    assistantAudio: VoiceStreamState['assistantAudio'];
+    subscribe: (subscriber: () => void) => () => void;
+};
+export type VoiceAudioPlayer = {
+    close: () => Promise<void>;
+    error: string | null;
+    getSnapshot: () => VoiceAudioPlayerState;
+    activeSourceCount: number;
+    isActive: boolean;
+    isPlaying: boolean;
+    interrupt: () => Promise<void>;
+    lastInterruptLatencyMs?: number;
+    lastPlaybackStopLatencyMs?: number;
+    pause: () => Promise<void>;
+    processedChunkCount: number;
+    queuedChunkCount: number;
+    start: () => Promise<void>;
+    subscribe: (subscriber: () => void) => () => void;
+};
+export type VoiceBargeInBinding = {
+    close: () => void;
+    handleLevel: (level: number) => void;
+    sendAudio: (audio: Uint8Array | ArrayBuffer) => void;
+};
 export type VoiceController<TResult = unknown> = {
     bindHTMX: (options: VoiceHTMXBindingOptions) => () => void;
     close: () => void;
@@ -532,6 +803,16 @@ export type VoiceController<TResult = unknown> = {
     toggleRecording: () => Promise<void>;
     turns: VoiceTurnRecord<TResult>[];
     assistantTexts: string[];
+    assistantAudio: Array<{
+        chunk: Uint8Array;
+        format: AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }>;
+};
+export type VoiceDuplexController<TResult = unknown> = VoiceController<TResult> & {
+    audioPlayer: VoiceAudioPlayer;
+    interruptAssistant: () => Promise<void>;
 };
 export type VoiceHTMXBindingOptions = {
     element: Element | string;
@@ -556,6 +837,12 @@ export type VoiceStoreAction<TResult = unknown> = {
 } | {
     type: 'assistant';
     text: string;
+} | {
+    type: 'audio';
+    chunk: Uint8Array;
+    format: AudioFormat;
+    receivedAt: number;
+    turnId?: string;
 } | {
     type: 'complete';
     sessionId: string;

package/dist/vue/index.js

@@ -102,6 +102,14 @@ var normalizeErrorMessage = (value) => {
 };
 var serverMessageToAction = (message) => {
   switch (message.type) {
+    case "audio":
+      return {
+        chunk: Uint8Array.from(atob(message.chunkBase64), (char) => char.charCodeAt(0)),
+        format: message.format,
+        receivedAt: message.receivedAt,
+        turnId: message.turnId,
+        type: "audio"
+      };
     case "assistant":
       return {
         text: message.text,
@@ -182,6 +190,7 @@ var isVoiceServerMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "audio":
     case "assistant":
     case "complete":
     case "error":
@@ -354,6 +363,7 @@ var createVoiceConnection = (path, options = {}) => {
 
 // src/client/store.ts
 var createInitialState = () => ({
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -371,6 +381,20 @@ var createVoiceStreamStore = () => {
   };
   const dispatch = (action) => {
     switch (action.type) {
+      case "audio":
+        state = {
+          ...state,
+          assistantAudio: [
+            ...state.assistantAudio,
+            {
+              chunk: action.chunk,
+              format: action.format,
+              receivedAt: action.receivedAt,
+              turnId: action.turnId
+            }
+          ]
+        };
+        break;
       case "assistant":
         state = {
           ...state,
@@ -510,6 +534,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantTexts() {
       return store.getSnapshot().assistantTexts;
     },
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -525,6 +552,7 @@ var createVoiceStream = (path, options = {}) => {
 // src/vue/useVoiceStream.ts
 var useVoiceStream = (path, options = {}) => {
   const stream = createVoiceStream(path, options);
+  const assistantAudio = shallowRef([]);
   const assistantTexts = shallowRef([]);
   const error = ref(null);
   const isConnected = ref(false);
@@ -533,6 +561,7 @@ var useVoiceStream = (path, options = {}) => {
   const status = ref(stream.status);
   const turns = shallowRef([]);
   const sync = () => {
+    assistantAudio.value = [...stream.assistantAudio];
     assistantTexts.value = [...stream.assistantTexts];
     error.value = stream.error;
     isConnected.value = stream.isConnected;
@@ -549,6 +578,7 @@ var useVoiceStream = (path, options = {}) => {
   };
   onUnmounted(destroy);
   return {
+    assistantAudio,
     assistantTexts,
     close: () => destroy(),
     endTurn: () => stream.endTurn(),
@@ -929,6 +959,58 @@ var PRESET_INPUTS = {
       transcriptStabilityMs: 1650
     }
   },
+  "pstn-balanced": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.8,
+      noiseGateAttenuation: 0.07,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 660,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 300
+    }
+  },
+  "pstn-fast": {
+    audioConditioning: {
+      enabled: true,
+      maxGain: 2.75,
+      noiseGateAttenuation: 0.06,
+      noiseGateThreshold: 0.005,
+      targetLevel: 0.08
+    },
+    capture: {
+      channelCount: 1,
+      sampleRateHz: 16000
+    },
+    connection: {
+      maxReconnectAttempts: 14,
+      pingInterval: 45000,
+      reconnect: true
+    },
+    sttLifecycle: "continuous",
+    turnDetection: {
+      qualityProfile: "noisy-room",
+      profile: "long-form",
+      silenceMs: 620,
+      speechThreshold: 0.012,
+      transcriptStabilityMs: 280
+    }
+  },
   reliability: {
     audioConditioning: {
       enabled: true,
@@ -972,6 +1054,7 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 
 // src/client/controller.ts
 var createInitialState2 = (stream) => ({
+  assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
   error: stream.error,
   isConnected: stream.isConnected,
@@ -1000,6 +1083,7 @@ var createVoiceController = (path, options = {}) => {
   const sync = () => {
     state = {
       ...state,
+      assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
       error: stream.error,
       isConnected: stream.isConnected,
@@ -1127,6 +1211,9 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantTexts() {
       return state.assistantTexts;
+    },
+    get assistantAudio() {
+      return state.assistantAudio;
     }
   };
 };
@@ -1134,6 +1221,7 @@ var createVoiceController = (path, options = {}) => {
 // src/vue/useVoiceController.ts
 var useVoiceController = (path, options = {}) => {
   const controller = createVoiceController(path, options);
+  const assistantAudio = shallowRef2([]);
   const assistantTexts = shallowRef2([]);
   const error = ref2(null);
   const isConnected = ref2(false);
@@ -1144,6 +1232,7 @@ var useVoiceController = (path, options = {}) => {
   const status = ref2(controller.status);
   const turns = shallowRef2([]);
   const sync = () => {
+    assistantAudio.value = [...controller.assistantAudio];
     assistantTexts.value = [...controller.assistantTexts];
     error.value = controller.error;
     isConnected.value = controller.isConnected;
@@ -1162,6 +1251,7 @@ var useVoiceController = (path, options = {}) => {
   };
   onUnmounted2(destroy);
   return {
+    assistantAudio,
     assistantTexts,
     bindHTMX: controller.bindHTMX,
     close: () => destroy(),

package/dist/vue/useVoiceController.d.ts

@@ -1,5 +1,16 @@
 import type { VoiceControllerOptions, VoiceTurnRecord } from '../types';
 export declare const useVoiceController: <TResult = unknown>(path: string, options?: VoiceControllerOptions) => {
+    assistantAudio: import("vue").ShallowRef<{
+        chunk: Uint8Array;
+        format: import("..").AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }[], {
+        chunk: Uint8Array;
+        format: import("..").AudioFormat;
+        receivedAt: number;
+        turnId?: string;
+    }[]>;
     assistantTexts: import("vue").ShallowRef<string[], string[]>;
     bindHTMX: (options: import("..").VoiceHTMXBindingOptions) => () => void;
     close: () => void;