@absolutejs/voice 0.0.21 → 0.0.22-beta.0

package/dist/client/index.js

@@ -107,6 +107,7 @@ var isVoiceServerMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "audio":
     case "assistant":
     case "complete":
     case "error":
@@ -276,6 +277,352 @@ var createVoiceConnection = (path, options = {}) => {
     subscribe
   };
 };
+// src/client/audioPlayer.ts
+var DEFAULT_LOOKAHEAD_MS = 15;
+var createInitialState = () => ({
+  activeSourceCount: 0,
+  error: null,
+  isActive: false,
+  isPlaying: false,
+  lastInterruptLatencyMs: undefined,
+  lastPlaybackStopLatencyMs: undefined,
+  processedChunkCount: 0,
+  queuedChunkCount: 0
+});
+var getAudioContextCtor = () => {
+  if (typeof window === "undefined") {
+    return typeof AudioContext === "undefined" ? undefined : AudioContext;
+  }
+  return window.AudioContext ?? window.webkitAudioContext;
+};
+var decodePCM16LEChunk = (audioContext, chunk) => {
+  const format = chunk.format;
+  if (format.container !== "raw" || format.encoding !== "pcm_s16le") {
+    throw new Error(`Unsupported assistant audio format: ${format.container}/${format.encoding}`);
+  }
+  const bytes = chunk.chunk;
+  const channels = Math.max(1, format.channels);
+  const sampleCount = Math.floor(bytes.byteLength / 2);
+  const frameCount = Math.max(1, Math.floor(sampleCount / channels));
+  const audioBuffer = audioContext.createBuffer(channels, frameCount, format.sampleRateHz);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (let channelIndex = 0;channelIndex < channels; channelIndex += 1) {
+    const channelData = audioBuffer.getChannelData(channelIndex);
+    for (let frameIndex = 0;frameIndex < frameCount; frameIndex += 1) {
+      const sampleIndex = frameIndex * channels + channelIndex;
+      const sampleOffset = sampleIndex * 2;
+      if (sampleOffset + 1 >= bytes.byteLength) {
+        channelData[frameIndex] = 0;
+        continue;
+      }
+      channelData[frameIndex] = view.getInt16(sampleOffset, true) / 32768;
+    }
+  }
+  return audioBuffer;
+};
+var createVoiceAudioPlayer = (source, options = {}) => {
+  const subscribers = new Set;
+  const sourceNodes = new Set;
+  const lookaheadSeconds = (options.lookaheadMs ?? DEFAULT_LOOKAHEAD_MS) / 1000;
+  let state = createInitialState();
+  let audioContext = null;
+  let outputNode = null;
+  let queueEndTime = 0;
+  let syncPromise = Promise.resolve();
+  let interruptStartedAt = null;
+  let interruptPromise = null;
+  let resolveInterruptPromise = null;
+  let interruptFallbackTimer = null;
+  const notify = () => {
+    for (const subscriber of subscribers) {
+      subscriber();
+    }
+  };
+  const setState = (next) => {
+    state = {
+      ...state,
+      ...next
+    };
+    notify();
+  };
+  const clearError = () => {
+    if (state.error !== null) {
+      setState({ error: null });
+    }
+  };
+  const clearInterruptTimer = () => {
+    if (interruptFallbackTimer !== null) {
+      clearTimeout(interruptFallbackTimer);
+      interruptFallbackTimer = null;
+    }
+  };
+  const resolveInterrupt = (latencyMs) => {
+    clearInterruptTimer();
+    interruptStartedAt = null;
+    setState({
+      activeSourceCount: sourceNodes.size,
+      isPlaying: false,
+      lastInterruptLatencyMs: latencyMs,
+      lastPlaybackStopLatencyMs: state.lastPlaybackStopLatencyMs ?? latencyMs
+    });
+    resolveInterruptPromise?.();
+    resolveInterruptPromise = null;
+    interruptPromise = null;
+  };
+  const estimateOutputStopLatencyMs = (context) => {
+    if (!context) {
+      return 0;
+    }
+    return Math.max(0, ((context.baseLatency ?? 0) + (context.outputLatency ?? 0)) * 1000);
+  };
+  const restoreOutputGain = (context) => {
+    if (!outputNode) {
+      return;
+    }
+    const gainValue = 1;
+    if (outputNode.gain.setValueAtTime) {
+      outputNode.gain.setValueAtTime(gainValue, context?.currentTime ?? 0);
+      return;
+    }
+    outputNode.gain.value = gainValue;
+  };
+  const muteOutputGain = (context) => {
+    if (!outputNode) {
+      return;
+    }
+    const gainValue = 0;
+    if (outputNode.gain.setValueAtTime) {
+      outputNode.gain.setValueAtTime(gainValue, context?.currentTime ?? 0);
+      return;
+    }
+    outputNode.gain.value = gainValue;
+  };
+  const maybeResolveInterrupt = () => {
+    if (interruptStartedAt === null || sourceNodes.size > 0) {
+      return;
+    }
+    resolveInterrupt(Date.now() - interruptStartedAt);
+  };
+  const ensureAudioContext = async () => {
+    if (audioContext) {
+      return audioContext;
+    }
+    if (options.createAudioContext) {
+      audioContext = options.createAudioContext();
+    } else {
+      const AudioContextCtor = getAudioContextCtor();
+      if (!AudioContextCtor) {
+        throw new Error("Assistant audio playback requires AudioContext support.");
+      }
+      audioContext = new AudioContextCtor;
+    }
+    if (audioContext.createGain) {
+      outputNode = audioContext.createGain();
+      outputNode.connect?.(audioContext.destination);
+    }
+    queueEndTime = audioContext.currentTime;
+    return audioContext;
+  };
+  const scheduleChunk = async (chunk) => {
+    const context = await ensureAudioContext();
+    const buffer = decodePCM16LEChunk(context, chunk);
+    const node = context.createBufferSource();
+    node.buffer = buffer;
+    node.connect(outputNode ?? context.destination);
+    node.onended = () => {
+      sourceNodes.delete(node);
+      node.disconnect?.();
+      setState({
+        activeSourceCount: sourceNodes.size,
+        isPlaying: sourceNodes.size > 0 && state.isActive
+      });
+      maybeResolveInterrupt();
+    };
+    const startAt = Math.max(context.currentTime + lookaheadSeconds, queueEndTime);
+    queueEndTime = startAt + buffer.duration;
+    sourceNodes.add(node);
+    setState({
+      activeSourceCount: sourceNodes.size,
+      isPlaying: true
+    });
+    node.start(startAt);
+  };
+  const stopQueuedPlayback = (options2) => {
+    for (const node of [...sourceNodes]) {
+      node.stop?.();
+    }
+    queueEndTime = audioContext ? audioContext.currentTime : 0;
+    if (options2?.forceClear) {
+      for (const node of sourceNodes) {
+        node.disconnect?.();
+      }
+      sourceNodes.clear();
+      maybeResolveInterrupt();
+    }
+  };
+  const sync = async () => {
+    if (!state.isActive) {
+      return;
+    }
+    const nextChunks = source.assistantAudio.slice(state.processedChunkCount);
+    if (nextChunks.length === 0) {
+      return;
+    }
+    try {
+      clearError();
+      for (const chunk of nextChunks) {
+        await scheduleChunk(chunk);
+      }
+      setState({
+        processedChunkCount: source.assistantAudio.length,
+        queuedChunkCount: state.queuedChunkCount + nextChunks.length
+      });
+    } catch (error) {
+      setState({
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const queueSync = () => {
+    syncPromise = syncPromise.then(() => sync(), () => sync());
+    return syncPromise;
+  };
+  const unsubscribeSource = source.subscribe(() => {
+    if (options.autoStart && !state.isActive && source.assistantAudio.length > 0) {
+      player.start();
+      return;
+    }
+    if (state.isActive) {
+      queueSync();
+    }
+  });
+  const player = {
+    close: async () => {
+      unsubscribeSource();
+      stopQueuedPlayback({ forceClear: true });
+      clearInterruptTimer();
+      resolveInterruptPromise?.();
+      resolveInterruptPromise = null;
+      interruptPromise = null;
+      interruptStartedAt = null;
+      if (audioContext && audioContext.state !== "closed") {
+        await audioContext.close();
+      }
+      audioContext = null;
+      outputNode?.disconnect?.();
+      outputNode = null;
+      queueEndTime = 0;
+      setState({
+        activeSourceCount: 0,
+        isActive: false,
+        isPlaying: false
+      });
+    },
+    get activeSourceCount() {
+      return state.activeSourceCount;
+    },
+    get error() {
+      return state.error;
+    },
+    getSnapshot: () => state,
+    get isActive() {
+      return state.isActive;
+    },
+    get isPlaying() {
+      return state.isPlaying;
+    },
+    interrupt: async () => {
+      const startedAt = Date.now();
+      const context = await ensureAudioContext();
+      interruptStartedAt = startedAt;
+      muteOutputGain(context);
+      const playbackStopLatencyMs = Date.now() - startedAt + estimateOutputStopLatencyMs(context);
+      setState({
+        isActive: false,
+        isPlaying: sourceNodes.size > 0,
+        lastPlaybackStopLatencyMs: playbackStopLatencyMs
+      });
+      if (sourceNodes.size === 0) {
+        resolveInterrupt(playbackStopLatencyMs);
+        return;
+      }
+      if (!interruptPromise) {
+        interruptPromise = new Promise((resolve) => {
+          resolveInterruptPromise = resolve;
+        });
+      }
+      clearInterruptTimer();
+      interruptFallbackTimer = setTimeout(() => {
+        for (const node of sourceNodes) {
+          node.disconnect?.();
+        }
+        sourceNodes.clear();
+        resolveInterrupt(Date.now() - startedAt);
+      }, 250);
+      stopQueuedPlayback();
+      await interruptPromise;
+    },
+    get lastInterruptLatencyMs() {
+      return state.lastInterruptLatencyMs;
+    },
+    get lastPlaybackStopLatencyMs() {
+      return state.lastPlaybackStopLatencyMs;
+    },
+    pause: async () => {
+      if (!audioContext) {
+        setState({
+          activeSourceCount: 0,
+          isActive: false,
+          isPlaying: false
+        });
+        return;
+      }
+      await audioContext.suspend();
+      setState({
+        activeSourceCount: sourceNodes.size,
+        isActive: false,
+        isPlaying: false
+      });
+    },
+    get processedChunkCount() {
+      return state.processedChunkCount;
+    },
+    get queuedChunkCount() {
+      return state.queuedChunkCount;
+    },
+    start: async () => {
+      try {
+        clearError();
+        const context = await ensureAudioContext();
+        restoreOutputGain(context);
+        if (context.state === "suspended") {
+          await context.resume();
+        }
+        setState({
+          activeSourceCount: sourceNodes.size,
+          isActive: true,
+          isPlaying: context.state === "running"
+        });
+        await queueSync();
+      } catch (error) {
+        setState({
+          error: error instanceof Error ? error.message : String(error),
+          isActive: false,
+          isPlaying: false
+        });
+        throw error;
+      }
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+  return player;
+};
+var decodeVoiceAudioChunk = (audioContext, chunk) => decodePCM16LEChunk(audioContext, chunk);
 // src/client/actions.ts
 var normalizeErrorMessage = (value) => {
   if (typeof value === "string" && value.trim()) {
@@ -306,6 +653,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,
@@ -349,7 +704,8 @@ var serverMessageToAction = (message) => {
 };
 
 // src/client/store.ts
-var createInitialState = () => ({
+var createInitialState2 = () => ({
+  assistantAudio: [],
   assistantTexts: [],
   error: null,
   isConnected: false,
@@ -360,13 +716,27 @@ var createInitialState = () => ({
   turns: []
 });
 var createVoiceStreamStore = () => {
-  let state = createInitialState();
+  let state = createInitialState2();
   const subscribers = new Set;
   const notify = () => {
     subscribers.forEach((subscriber) => subscriber());
   };
   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,
@@ -506,6 +876,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantTexts() {
       return store.getSnapshot().assistantTexts;
     },
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -882,6 +1255,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,
@@ -924,7 +1349,8 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 };
 
 // src/client/controller.ts
-var createInitialState2 = (stream) => ({
+var createInitialState3 = (stream) => ({
+  assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
   error: stream.error,
   isConnected: stream.isConnected,
@@ -943,7 +1369,7 @@ var createVoiceController = (path, options = {}) => {
     ...options.connection
   });
   let capture = null;
-  let state = createInitialState2(stream);
+  let state = createInitialState3(stream);
   const subscribers = new Set;
   const notify = () => {
     for (const subscriber of subscribers) {
@@ -953,6 +1379,7 @@ var createVoiceController = (path, options = {}) => {
   const sync = () => {
     state = {
       ...state,
+      assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
       error: stream.error,
       isConnected: stream.isConnected,
@@ -1080,13 +1507,88 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantTexts() {
       return state.assistantTexts;
+    },
+    get assistantAudio() {
+      return state.assistantAudio;
+    }
+  };
+};
+// src/client/duplex.ts
+var DEFAULT_INTERRUPT_THRESHOLD = 0.08;
+var shouldInterruptForLevel = (level, options = {}) => (options.enabled ?? true) && level >= (options.interruptThreshold ?? DEFAULT_INTERRUPT_THRESHOLD);
+var bindVoiceBargeIn = (controller, player, options = {}) => {
+  let lastPartial = controller.partial;
+  const interruptIfPlaying = () => {
+    if (!player.isPlaying || options.enabled === false) {
+      return;
+    }
+    player.interrupt();
+  };
+  const unsubscribe = controller.subscribe(() => {
+    if (options.interruptOnPartial === false) {
+      lastPartial = controller.partial;
+      return;
+    }
+    if (!lastPartial && controller.partial) {
+      interruptIfPlaying();
+    }
+    lastPartial = controller.partial;
+  });
+  return {
+    close: () => {
+      unsubscribe();
+    },
+    handleLevel: (level) => {
+      if (shouldInterruptForLevel(level, options)) {
+        interruptIfPlaying();
+      }
+    },
+    sendAudio: (audio) => {
+      interruptIfPlaying();
+      controller.sendAudio(audio);
+    }
+  };
+};
+var createVoiceDuplexController = (path, options = {}) => {
+  let bargeInBinding = null;
+  const controller = createVoiceController(path, {
+    ...options,
+    capture: {
+      ...options.capture,
+      onLevel: (level) => {
+        bargeInBinding?.handleLevel(level);
+        options.capture?.onLevel?.(level);
+      }
+    }
+  });
+  const audioPlayer = createVoiceAudioPlayer(controller, options.audioPlayer);
+  bargeInBinding = bindVoiceBargeIn(controller, audioPlayer, options.bargeIn);
+  const close = () => {
+    bargeInBinding?.close();
+    bargeInBinding = null;
+    audioPlayer.close();
+    controller.close();
+  };
+  return {
+    ...controller,
+    audioPlayer,
+    close,
+    interruptAssistant: async () => {
+      await audioPlayer.interrupt();
+    },
+    sendAudio: (audio) => {
+      bargeInBinding?.sendAudio(audio);
     }
   };
 };
 export {
+  decodeVoiceAudioChunk,
   createVoiceStream,
+  createVoiceDuplexController,
   createVoiceController,
   createVoiceConnection,
+  createVoiceAudioPlayer,
   createMicrophoneCapture,
-  bindVoiceHTMX
+  bindVoiceHTMX,
+  bindVoiceBargeIn
 };

package/dist/correction.d.ts

@@ -1,4 +1,4 @@
-import type { VoicePhraseHint, VoiceTurnCorrectionHandler } from './types';
+import type { VoiceCorrectionRiskTier, VoiceDomainTerm, VoiceLexiconEntry, VoicePhraseHint, VoiceTurnCorrectionHandler } from './types';
 export type VoicePhraseHintCorrectionMatch = {
     alias: string;
     hint: VoicePhraseHint;
@@ -12,5 +12,22 @@ export type VoicePhraseHintCorrectionOptions = {
     provider?: string;
     reason?: string;
 };
+export type VoiceLexiconCorrectionOptions = VoicePhraseHintCorrectionOptions;
+export type VoiceDomainHintGenerationOptions = {
+    riskTier?: VoiceCorrectionRiskTier;
+};
+export type VoiceRiskyTurnCorrectionHandlerOptions = VoicePhraseHintCorrectionOptions & {
+    maxAverageConfidence?: number;
+    riskTier?: Exclude<VoiceCorrectionRiskTier, 'safe'>;
+};
+export type VoicePhraseHintCorrectionRunOptions = {
+    riskTier?: VoiceCorrectionRiskTier;
+};
 export declare const applyPhraseHintCorrections: (text: string, phraseHints: VoicePhraseHint[]) => VoicePhraseHintCorrectionResult;
+export declare const applyRiskTieredPhraseHintCorrections: (text: string, phraseHints: VoicePhraseHint[], options?: VoicePhraseHintCorrectionRunOptions) => VoicePhraseHintCorrectionResult;
+export declare const createDomainPhraseHints: (terms: VoiceDomainTerm[], options?: VoiceDomainHintGenerationOptions) => VoicePhraseHint[];
+export declare const createDomainLexicon: (terms: VoiceDomainTerm[]) => VoiceLexiconEntry[];
 export declare const createPhraseHintCorrectionHandler: (options?: VoicePhraseHintCorrectionOptions) => VoiceTurnCorrectionHandler;
+export declare const applyLexiconCorrections: (text: string, lexicon: VoiceLexiconEntry[]) => VoicePhraseHintCorrectionResult;
+export declare const createLexiconCorrectionHandler: (options?: VoiceLexiconCorrectionOptions) => VoiceTurnCorrectionHandler;
+export declare const createRiskyTurnCorrectionHandler: (options?: VoiceRiskyTurnCorrectionHandlerOptions) => VoiceTurnCorrectionHandler;

package/dist/fileStore.d.ts

@@ -0,0 +1,27 @@
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceOpsTask, VoiceOpsTaskStore } from './ops';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+import type { VoiceSessionRecord, VoiceSessionStore } from './types';
+export type VoiceFileStoreOptions = {
+    directory: string;
+    pretty?: boolean;
+};
+export type VoiceFileRuntimeStorage<TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent> = {
+    events: VoiceIntegrationEventStore<TEvent>;
+    reviews: VoiceCallReviewStore<TReview>;
+    session: VoiceSessionStore<TSession>;
+    tasks: VoiceOpsTaskStore<TTask>;
+};
+export declare const createVoiceFileSessionStore: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceFileStoreOptions) => VoiceSessionStore<TSession>;
+export declare const createVoiceFileReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceFileStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export declare const createVoiceFileTaskStore: <TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask>(options: VoiceFileStoreOptions) => VoiceOpsTaskStore<TTask>;
+export declare const createVoiceFileIntegrationEventStore: <TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceFileStoreOptions) => VoiceIntegrationEventStore<TEvent>;
+export declare const createVoiceFileRuntimeStorage: <TSession extends VoiceSessionRecord = VoiceSessionRecord, TReview extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact, TTask extends StoredVoiceOpsTask = StoredVoiceOpsTask, TEvent extends StoredVoiceIntegrationEvent = StoredVoiceIntegrationEvent>(options: VoiceFileStoreOptions) => VoiceFileRuntimeStorage<TSession, TReview, TTask, TEvent>;
+export declare const createStoredVoiceCallReviewArtifact: <TArtifact extends VoiceCallReviewArtifact = VoiceCallReviewArtifact>(id: string, artifact: TArtifact) => TArtifact & {
+    id: string;
+};
+export declare const createStoredVoiceOpsTask: <TTask extends Omit<VoiceOpsTask, "id"> = Omit<VoiceOpsTask, "id">>(id: string, task: TTask) => TTask & {
+    id: string;
+};
+export declare const createStoredVoiceIntegrationEvent: <TEvent extends Omit<VoiceIntegrationEvent, "id"> = Omit<VoiceIntegrationEvent, "id">>(id: string, event: TEvent) => TEvent & {
+    id: string;
+};

package/dist/index.d.ts

@@ -1,9 +1,20 @@
 export { voice } from './plugin';
+export { createStoredVoiceCallReviewArtifact, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore } from './fileStore';
 export { createVoiceMemoryStore } from './memoryStore';
+export { assignVoiceOpsTask, buildVoiceOpsTaskFromReview, completeVoiceOpsTask, createVoiceCallCompletedEvent, createVoiceIntegrationEvent, createVoiceReviewSavedEvent, createVoiceTaskCreatedEvent, createVoiceTaskUpdatedEvent, listVoiceOpsTasks, reopenVoiceOpsTask, startVoiceOpsTask, summarizeVoiceOpsTasks, withVoiceIntegrationEventId, withVoiceOpsTaskId } from './ops';
 export { createVoiceSession } from './session';
+export { createVoiceCallReviewFromSession, recordVoiceRuntimeOps } from './runtimeOps';
 export { createId, createVoiceSessionRecord } from './store';
-export { applyPhraseHintCorrections, createPhraseHintCorrectionHandler } from './correction';
+export { createVoiceSTTRoutingCorrectionHandler, resolveVoiceSTTRoutingStrategy } from './routing';
+export { applyRiskTieredPhraseHintCorrections, applyPhraseHintCorrections, createDomainLexicon, createDomainPhraseHints, createPhraseHintCorrectionHandler, createRiskyTurnCorrectionHandler } from './correction';
 export { conditionAudioChunk, resolveAudioConditioningConfig } from './audioConditioning';
 export { resolveVoiceRuntimePreset } from './presets';
 export { resolveTurnDetectionConfig, TURN_PROFILE_DEFAULTS } from './turnProfiles';
+export { createVoiceCallReviewFromLiveTelephonyReport, createVoiceCallReviewRecorder, renderVoiceCallReviewHTML, renderVoiceCallReviewMarkdown } from './testing/review';
+export type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewConfig, VoiceCallReviewPostCallSummary, VoiceCallReviewRecorder, VoiceCallReviewRecorderOptions, VoiceCallReviewStore, VoiceCallReviewSummary, VoiceCallReviewTimelineEvent } from './testing/review';
+export type { VoiceFileRuntimeStorage, VoiceFileStoreOptions } from './fileStore';
+export type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceIntegrationEventType, VoiceOpsTask, VoiceOpsTaskHistoryEntry, VoiceOpsTaskKind, VoiceOpsTaskStatus, VoiceOpsTaskStore, VoiceOpsTaskSummary } from './ops';
+export { createTwilioMediaStreamBridge, createTwilioVoiceResponse, decodeTwilioMulawBase64, encodeTwilioMulawBase64, transcodePCMToTwilioOutboundPayload, transcodeTwilioInboundPayloadToPCM16 } from './telephony/twilio';
+export { shapeTelephonyAssistantText } from './telephony/response';
+export type { TelephonyResponseShapeMode, TelephonyResponseShapeOptions } from './telephony/response';
 export * from './types';