voice-router-dev 0.2.7 → 0.3.0

package/dist/index.mjs

@@ -220,6 +220,312 @@ var ListenV1EncodingParameter = {
   g729: "g729"
 };
 
+// src/generated/deepgram/schema/listenV1RedactParameterOneOfItem.ts
+var ListenV1RedactParameterOneOfItem = {
+  pci: "pci",
+  pii: "pii",
+  numbers: "numbers"
+};
+
+// src/generated/deepgram/schema/sharedCustomTopicModeParameter.ts
+var SharedCustomTopicModeParameter = {
+  extended: "extended",
+  strict: "strict"
+};
+
+// src/generated/gladia/schema/streamingSupportedEncodingEnum.ts
+var StreamingSupportedEncodingEnum = {
+  "wav/pcm": "wav/pcm",
+  "wav/alaw": "wav/alaw",
+  "wav/ulaw": "wav/ulaw"
+};
+
+// src/generated/gladia/schema/streamingSupportedSampleRateEnum.ts
+var StreamingSupportedSampleRateEnum = {
+  NUMBER_8000: 8e3,
+  NUMBER_16000: 16e3,
+  NUMBER_32000: 32e3,
+  NUMBER_44100: 44100,
+  NUMBER_48000: 48e3
+};
+
+// src/generated/gladia/schema/streamingSupportedBitDepthEnum.ts
+var StreamingSupportedBitDepthEnum = {
+  NUMBER_8: 8,
+  NUMBER_16: 16,
+  NUMBER_24: 24,
+  NUMBER_32: 32
+};
+
+// src/generated/gladia/schema/streamingSupportedModels.ts
+var StreamingSupportedModels = {
+  "solaria-1": "solaria-1"
+};
+
+// src/generated/gladia/schema/transcriptionLanguageCodeEnum.ts
+var TranscriptionLanguageCodeEnum = {
+  af: "af",
+  am: "am",
+  ar: "ar",
+  as: "as",
+  az: "az",
+  ba: "ba",
+  be: "be",
+  bg: "bg",
+  bn: "bn",
+  bo: "bo",
+  br: "br",
+  bs: "bs",
+  ca: "ca",
+  cs: "cs",
+  cy: "cy",
+  da: "da",
+  de: "de",
+  el: "el",
+  en: "en",
+  es: "es",
+  et: "et",
+  eu: "eu",
+  fa: "fa",
+  fi: "fi",
+  fo: "fo",
+  fr: "fr",
+  gl: "gl",
+  gu: "gu",
+  ha: "ha",
+  haw: "haw",
+  he: "he",
+  hi: "hi",
+  hr: "hr",
+  ht: "ht",
+  hu: "hu",
+  hy: "hy",
+  id: "id",
+  is: "is",
+  it: "it",
+  ja: "ja",
+  jw: "jw",
+  ka: "ka",
+  kk: "kk",
+  km: "km",
+  kn: "kn",
+  ko: "ko",
+  la: "la",
+  lb: "lb",
+  ln: "ln",
+  lo: "lo",
+  lt: "lt",
+  lv: "lv",
+  mg: "mg",
+  mi: "mi",
+  mk: "mk",
+  ml: "ml",
+  mn: "mn",
+  mr: "mr",
+  ms: "ms",
+  mt: "mt",
+  my: "my",
+  ne: "ne",
+  nl: "nl",
+  nn: "nn",
+  no: "no",
+  oc: "oc",
+  pa: "pa",
+  pl: "pl",
+  ps: "ps",
+  pt: "pt",
+  ro: "ro",
+  ru: "ru",
+  sa: "sa",
+  sd: "sd",
+  si: "si",
+  sk: "sk",
+  sl: "sl",
+  sn: "sn",
+  so: "so",
+  sq: "sq",
+  sr: "sr",
+  su: "su",
+  sv: "sv",
+  sw: "sw",
+  ta: "ta",
+  te: "te",
+  tg: "tg",
+  th: "th",
+  tk: "tk",
+  tl: "tl",
+  tr: "tr",
+  tt: "tt",
+  uk: "uk",
+  ur: "ur",
+  uz: "uz",
+  vi: "vi",
+  yi: "yi",
+  yo: "yo",
+  zh: "zh"
+};
+
+// src/generated/gladia/schema/translationLanguageCodeEnum.ts
+var TranslationLanguageCodeEnum = {
+  af: "af",
+  am: "am",
+  ar: "ar",
+  as: "as",
+  az: "az",
+  ba: "ba",
+  be: "be",
+  bg: "bg",
+  bn: "bn",
+  bo: "bo",
+  br: "br",
+  bs: "bs",
+  ca: "ca",
+  cs: "cs",
+  cy: "cy",
+  da: "da",
+  de: "de",
+  el: "el",
+  en: "en",
+  es: "es",
+  et: "et",
+  eu: "eu",
+  fa: "fa",
+  fi: "fi",
+  fo: "fo",
+  fr: "fr",
+  gl: "gl",
+  gu: "gu",
+  ha: "ha",
+  haw: "haw",
+  he: "he",
+  hi: "hi",
+  hr: "hr",
+  ht: "ht",
+  hu: "hu",
+  hy: "hy",
+  id: "id",
+  is: "is",
+  it: "it",
+  ja: "ja",
+  jw: "jw",
+  ka: "ka",
+  kk: "kk",
+  km: "km",
+  kn: "kn",
+  ko: "ko",
+  la: "la",
+  lb: "lb",
+  ln: "ln",
+  lo: "lo",
+  lt: "lt",
+  lv: "lv",
+  mg: "mg",
+  mi: "mi",
+  mk: "mk",
+  ml: "ml",
+  mn: "mn",
+  mr: "mr",
+  ms: "ms",
+  mt: "mt",
+  my: "my",
+  ne: "ne",
+  nl: "nl",
+  nn: "nn",
+  no: "no",
+  oc: "oc",
+  pa: "pa",
+  pl: "pl",
+  ps: "ps",
+  pt: "pt",
+  ro: "ro",
+  ru: "ru",
+  sa: "sa",
+  sd: "sd",
+  si: "si",
+  sk: "sk",
+  sl: "sl",
+  sn: "sn",
+  so: "so",
+  sq: "sq",
+  sr: "sr",
+  su: "su",
+  sv: "sv",
+  sw: "sw",
+  ta: "ta",
+  te: "te",
+  tg: "tg",
+  th: "th",
+  tk: "tk",
+  tl: "tl",
+  tr: "tr",
+  tt: "tt",
+  uk: "uk",
+  ur: "ur",
+  uz: "uz",
+  vi: "vi",
+  wo: "wo",
+  yi: "yi",
+  yo: "yo",
+  zh: "zh"
+};
+
+// src/router/streaming-enums.ts
+var DeepgramModel = {
+  // Nova 3 models (latest)
+  "nova-3": "nova-3",
+  "nova-3-general": "nova-3-general",
+  "nova-3-medical": "nova-3-medical",
+  // Nova 2 models
+  "nova-2": "nova-2",
+  "nova-2-general": "nova-2-general",
+  "nova-2-meeting": "nova-2-meeting",
+  "nova-2-finance": "nova-2-finance",
+  "nova-2-conversationalai": "nova-2-conversationalai",
+  "nova-2-voicemail": "nova-2-voicemail",
+  "nova-2-video": "nova-2-video",
+  "nova-2-medical": "nova-2-medical",
+  "nova-2-drivethru": "nova-2-drivethru",
+  "nova-2-automotive": "nova-2-automotive",
+  // Nova 1 models
+  nova: "nova",
+  "nova-general": "nova-general",
+  "nova-phonecall": "nova-phonecall",
+  "nova-medical": "nova-medical",
+  // Enhanced models
+  enhanced: "enhanced",
+  "enhanced-general": "enhanced-general",
+  "enhanced-meeting": "enhanced-meeting",
+  "enhanced-phonecall": "enhanced-phonecall",
+  "enhanced-finance": "enhanced-finance",
+  // Base models
+  base: "base",
+  meeting: "meeting",
+  phonecall: "phonecall",
+  finance: "finance",
+  conversationalai: "conversationalai",
+  voicemail: "voicemail",
+  video: "video"
+};
+var AssemblyAIEncoding = {
+  /** PCM signed 16-bit little-endian (recommended) */
+  pcmS16le: "pcm_s16le",
+  /** μ-law (telephony) */
+  pcmMulaw: "pcm_mulaw"
+};
+var AssemblyAISpeechModel = {
+  /** Optimized for English */
+  english: "universal-streaming-english",
+  /** Supports 20+ languages */
+  multilingual: "universal-streaming-multilingual"
+};
+var AssemblyAISampleRate = {
+  rate8000: 8e3,
+  rate16000: 16e3,
+  rate22050: 22050,
+  rate44100: 44100,
+  rate48000: 48e3
+};
+
 // src/generated/deepgram/schema/speakV1EncodingParameter.ts
 var SpeakV1EncodingParameter = {
   linear16: "linear16",
@@ -249,30 +555,6 @@ var SpeakV1SampleRateParameter = {
   NUMBER_22050: 22050
 };
 
-// src/generated/gladia/schema/streamingSupportedEncodingEnum.ts
-var StreamingSupportedEncodingEnum = {
-  "wav/pcm": "wav/pcm",
-  "wav/alaw": "wav/alaw",
-  "wav/ulaw": "wav/ulaw"
-};
-
-// src/generated/gladia/schema/streamingSupportedSampleRateEnum.ts
-var StreamingSupportedSampleRateEnum = {
-  NUMBER_8000: 8e3,
-  NUMBER_16000: 16e3,
-  NUMBER_32000: 32e3,
-  NUMBER_44100: 44100,
-  NUMBER_48000: 48e3
-};
-
-// src/generated/gladia/schema/streamingSupportedBitDepthEnum.ts
-var StreamingSupportedBitDepthEnum = {
-  NUMBER_8: 8,
-  NUMBER_16: 16,
-  NUMBER_24: 24,
-  NUMBER_32: 32
-};
-
 // src/constants/defaults.ts
 var DEFAULT_TIMEOUTS = {
   /** Standard HTTP request timeout for API calls (60 seconds) */
@@ -1160,11 +1442,6 @@ var StreamingResponseStatus = {
   error: "error"
 };
 
-// src/generated/gladia/schema/streamingSupportedModels.ts
-var StreamingSupportedModels = {
-  "solaria-1": "solaria-1"
-};
-
 // src/generated/gladia/schema/streamingSupportedRegions.ts
 var StreamingSupportedRegions = {
   "us-west": "us-west",
@@ -1190,232 +1467,25 @@ var SummaryTypesEnum = {
   concise: "concise"
 };
 
-// src/generated/gladia/schema/transcriptionControllerListV2KindItem.ts
-var TranscriptionControllerListV2KindItem = {
-  "pre-recorded": "pre-recorded",
-  live: "live"
-};
-
-// src/generated/gladia/schema/transcriptionControllerListV2StatusItem.ts
-var TranscriptionControllerListV2StatusItem = {
-  queued: "queued",
-  processing: "processing",
-  done: "done",
-  error: "error"
-};
-
-// src/generated/gladia/schema/transcriptionLanguageCodeEnum.ts
-var TranscriptionLanguageCodeEnum = {
-  af: "af",
-  am: "am",
-  ar: "ar",
-  as: "as",
-  az: "az",
-  ba: "ba",
-  be: "be",
-  bg: "bg",
-  bn: "bn",
-  bo: "bo",
-  br: "br",
-  bs: "bs",
-  ca: "ca",
-  cs: "cs",
-  cy: "cy",
-  da: "da",
-  de: "de",
-  el: "el",
-  en: "en",
-  es: "es",
-  et: "et",
-  eu: "eu",
-  fa: "fa",
-  fi: "fi",
-  fo: "fo",
-  fr: "fr",
-  gl: "gl",
-  gu: "gu",
-  ha: "ha",
-  haw: "haw",
-  he: "he",
-  hi: "hi",
-  hr: "hr",
-  ht: "ht",
-  hu: "hu",
-  hy: "hy",
-  id: "id",
-  is: "is",
-  it: "it",
-  ja: "ja",
-  jw: "jw",
-  ka: "ka",
-  kk: "kk",
-  km: "km",
-  kn: "kn",
-  ko: "ko",
-  la: "la",
-  lb: "lb",
-  ln: "ln",
-  lo: "lo",
-  lt: "lt",
-  lv: "lv",
-  mg: "mg",
-  mi: "mi",
-  mk: "mk",
-  ml: "ml",
-  mn: "mn",
-  mr: "mr",
-  ms: "ms",
-  mt: "mt",
-  my: "my",
-  ne: "ne",
-  nl: "nl",
-  nn: "nn",
-  no: "no",
-  oc: "oc",
-  pa: "pa",
-  pl: "pl",
-  ps: "ps",
-  pt: "pt",
-  ro: "ro",
-  ru: "ru",
-  sa: "sa",
-  sd: "sd",
-  si: "si",
-  sk: "sk",
-  sl: "sl",
-  sn: "sn",
-  so: "so",
-  sq: "sq",
-  sr: "sr",
-  su: "su",
-  sv: "sv",
-  sw: "sw",
-  ta: "ta",
-  te: "te",
-  tg: "tg",
-  th: "th",
-  tk: "tk",
-  tl: "tl",
-  tr: "tr",
-  tt: "tt",
-  uk: "uk",
-  ur: "ur",
-  uz: "uz",
-  vi: "vi",
-  yi: "yi",
-  yo: "yo",
-  zh: "zh"
-};
-
+// src/generated/gladia/schema/transcriptionControllerListV2KindItem.ts
+var TranscriptionControllerListV2KindItem = {
+  "pre-recorded": "pre-recorded",
+  live: "live"
+};
+
+// src/generated/gladia/schema/transcriptionControllerListV2StatusItem.ts
+var TranscriptionControllerListV2StatusItem = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
 // src/generated/gladia/schema/transcriptMessageType.ts
 var TranscriptMessageType = {
   transcript: "transcript"
 };
 
-// src/generated/gladia/schema/translationLanguageCodeEnum.ts
-var TranslationLanguageCodeEnum = {
-  af: "af",
-  am: "am",
-  ar: "ar",
-  as: "as",
-  az: "az",
-  ba: "ba",
-  be: "be",
-  bg: "bg",
-  bn: "bn",
-  bo: "bo",
-  br: "br",
-  bs: "bs",
-  ca: "ca",
-  cs: "cs",
-  cy: "cy",
-  da: "da",
-  de: "de",
-  el: "el",
-  en: "en",
-  es: "es",
-  et: "et",
-  eu: "eu",
-  fa: "fa",
-  fi: "fi",
-  fo: "fo",
-  fr: "fr",
-  gl: "gl",
-  gu: "gu",
-  ha: "ha",
-  haw: "haw",
-  he: "he",
-  hi: "hi",
-  hr: "hr",
-  ht: "ht",
-  hu: "hu",
-  hy: "hy",
-  id: "id",
-  is: "is",
-  it: "it",
-  ja: "ja",
-  jw: "jw",
-  ka: "ka",
-  kk: "kk",
-  km: "km",
-  kn: "kn",
-  ko: "ko",
-  la: "la",
-  lb: "lb",
-  ln: "ln",
-  lo: "lo",
-  lt: "lt",
-  lv: "lv",
-  mg: "mg",
-  mi: "mi",
-  mk: "mk",
-  ml: "ml",
-  mn: "mn",
-  mr: "mr",
-  ms: "ms",
-  mt: "mt",
-  my: "my",
-  ne: "ne",
-  nl: "nl",
-  nn: "nn",
-  no: "no",
-  oc: "oc",
-  pa: "pa",
-  pl: "pl",
-  ps: "ps",
-  pt: "pt",
-  ro: "ro",
-  ru: "ru",
-  sa: "sa",
-  sd: "sd",
-  si: "si",
-  sk: "sk",
-  sl: "sl",
-  sn: "sn",
-  so: "so",
-  sq: "sq",
-  sr: "sr",
-  su: "su",
-  sv: "sv",
-  sw: "sw",
-  ta: "ta",
-  te: "te",
-  tg: "tg",
-  th: "th",
-  tk: "tk",
-  tl: "tl",
-  tr: "tr",
-  tt: "tt",
-  uk: "uk",
-  ur: "ur",
-  uz: "uz",
-  vi: "vi",
-  wo: "wo",
-  yi: "yi",
-  yo: "yo",
-  zh: "zh"
-};
-
 // src/generated/gladia/schema/translationMessageType.ts
 var TranslationMessageType = {
   translation: "translation"
@@ -1983,7 +2053,7 @@ var GladiaAdapter = class extends BaseAdapter {
       }))
     );
     return extractWords(allWords, (item) => ({
-      text: item.word.word,
+      word: item.word.word,
       start: item.word.start,
       end: item.word.end,
       confidence: item.word.confidence,
@@ -2003,11 +2073,11 @@ var GladiaAdapter = class extends BaseAdapter {
       end: utterance.end,
       speaker: utterance.speaker?.toString(),
       confidence: utterance.confidence,
-      words: utterance.words.map((word) => ({
-        text: word.word,
-        start: word.start,
-        end: word.end,
-        confidence: word.confidence
+      words: utterance.words.map((w) => ({
+        word: w.word,
+        start: w.start,
+        end: w.end,
+        confidence: w.confidence
       }))
     }));
   }
@@ -2059,11 +2129,46 @@ var GladiaAdapter = class extends BaseAdapter {
    * Creates a WebSocket connection to Gladia for streaming transcription.
    * First initializes a session via REST API, then connects to WebSocket.
    *
+   * Supports all Gladia streaming features:
+   * - Real-time transcription with interim/final results
+   * - Speech detection events (speech_start, speech_end)
+   * - Real-time translation to other languages
+   * - Real-time sentiment analysis
+   * - Real-time named entity recognition
+   * - Post-processing summarization and chapterization
+   * - Audio preprocessing (audio enhancement, speech threshold)
+   * - Custom vocabulary and spelling
+   * - Multi-language code switching
+   *
    * @param options - Streaming configuration options
+   * @param options.encoding - Audio encoding (wav/pcm, wav/alaw, wav/ulaw)
+   * @param options.sampleRate - Sample rate (8000, 16000, 32000, 44100, 48000)
+   * @param options.bitDepth - Bit depth (8, 16, 24, 32)
+   * @param options.channels - Number of channels (1-8)
+   * @param options.language - Language code for transcription
+   * @param options.interimResults - Enable partial/interim transcripts
+   * @param options.endpointing - Silence duration to end utterance (0.01-10 seconds)
+   * @param options.maxSilence - Max duration without endpointing (5-60 seconds)
+   * @param options.customVocabulary - Words to boost in recognition
+   * @param options.sentimentAnalysis - Enable real-time sentiment analysis
+   * @param options.entityDetection - Enable named entity recognition
+   * @param options.summarization - Enable post-processing summarization
+   * @param options.gladiaStreaming - Full Gladia streaming options (pre_processing, realtime_processing, post_processing, messages_config)
    * @param callbacks - Event callbacks for transcription results
+   * @param callbacks.onTranscript - Interim/final transcript received
+   * @param callbacks.onUtterance - Complete utterance detected
+   * @param callbacks.onSpeechStart - Speech detected (requires messages_config.receive_speech_events)
+   * @param callbacks.onSpeechEnd - Speech ended (requires messages_config.receive_speech_events)
+   * @param callbacks.onTranslation - Translation result (requires translation enabled)
+   * @param callbacks.onSentiment - Sentiment analysis result
+   * @param callbacks.onEntity - Named entity detected
+   * @param callbacks.onSummarization - Summarization completed
+   * @param callbacks.onChapterization - Chapterization completed
+   * @param callbacks.onAudioAck - Audio chunk acknowledged
+   * @param callbacks.onLifecycle - Session lifecycle events
    * @returns Promise that resolves with a StreamingSession
    *
-   * @example Real-time streaming
+   * @example Basic real-time streaming
    * ```typescript
    * const session = await adapter.transcribeStream({
    *   encoding: 'wav/pcm',
@@ -2085,15 +2190,124 @@ var GladiaAdapter = class extends BaseAdapter {
    * });
    *
    * // Send audio chunks
-   * const audioChunk = getAudioChunk(); // Your audio source
+   * const audioChunk = getAudioChunk();
    * await session.sendAudio({ data: audioChunk });
    *
    * // Close when done
    * await session.close();
    * ```
+   *
+   * @example Advanced streaming with all features
+   * ```typescript
+   * const session = await adapter.transcribeStream({
+   *   encoding: 'wav/pcm',
+   *   sampleRate: 16000,
+   *   language: 'en',
+   *   sentimentAnalysis: true,
+   *   entityDetection: true,
+   *   summarization: true,
+   *   gladiaStreaming: {
+   *     pre_processing: {
+   *       audio_enhancer: true,
+   *       speech_threshold: 0.5
+   *     },
+   *     realtime_processing: {
+   *       translation: true,
+   *       translation_config: { target_languages: ['fr', 'es'] }
+   *     },
+   *     post_processing: {
+   *       chapterization: true
+   *     },
+   *     messages_config: {
+   *       receive_speech_events: true,
+   *       receive_acknowledgments: true,
+   *       receive_lifecycle_events: true
+   *     }
+   *   }
+   * }, {
+   *   onTranscript: (e) => console.log('Transcript:', e.text),
+   *   onSpeechStart: (e) => console.log('Speech started at:', e.timestamp),
+   *   onSpeechEnd: (e) => console.log('Speech ended at:', e.timestamp),
+   *   onTranslation: (e) => console.log(`${e.targetLanguage}: ${e.translatedText}`),
+   *   onSentiment: (e) => console.log('Sentiment:', e.sentiment),
+   *   onEntity: (e) => console.log(`Entity: ${e.type} - ${e.text}`),
+   *   onSummarization: (e) => console.log('Summary:', e.summary),
+   *   onChapterization: (e) => console.log('Chapters:', e.chapters),
+   *   onAudioAck: (e) => console.log('Audio ack:', e.byteRange),
+   *   onLifecycle: (e) => console.log('Lifecycle:', e.eventType)
+   * });
+   * ```
    */
   async transcribeStream(options, callbacks) {
     this.validateConfig();
+    const streamingRequest = this.buildStreamingRequest(options);
+    const initResponse = await streamingControllerInitStreamingSessionV2(
+      streamingRequest,
+      void 0,
+      // no params
+      this.getAxiosConfig()
+    );
+    const { id, url: wsUrl } = initResponse.data;
+    const ws = new WebSocket(wsUrl);
+    let sessionStatus = "connecting";
+    setupWebSocketHandlers(ws, callbacks, (status) => {
+      sessionStatus = status;
+    });
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        this.handleWebSocketMessage(message, callbacks);
+      } catch (error) {
+        callbacks?.onError?.({
+          code: ERROR_CODES.PARSE_ERROR,
+          message: "Failed to parse WebSocket message",
+          details: error
+        });
+      }
+    });
+    await waitForWebSocketOpen(ws);
+    return {
+      id,
+      provider: this.name,
+      createdAt: /* @__PURE__ */ new Date(),
+      getStatus: () => sessionStatus,
+      sendAudio: async (chunk) => {
+        validateSessionForAudio(sessionStatus, ws.readyState, WebSocket.OPEN);
+        ws.send(chunk.data);
+        if (chunk.isLast) {
+          ws.send(
+            JSON.stringify({
+              type: "stop_recording"
+            })
+          );
+        }
+      },
+      close: async () => {
+        if (sessionStatus === "closed" || sessionStatus === "closing") {
+          return;
+        }
+        sessionStatus = "closing";
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(
+            JSON.stringify({
+              type: "stop_recording"
+            })
+          );
+        }
+        await closeWebSocket(ws);
+        sessionStatus = "closed";
+      }
+    };
+  }
+  /**
+   * Build streaming request with full type safety from OpenAPI specs
+   *
+   * Maps normalized options to Gladia streaming request format,
+   * including all advanced features like pre-processing, real-time
+   * processing, post-processing, and message configuration.
+   */
+  buildStreamingRequest(options) {
+    const gladiaOpts = options?.gladiaStreaming || {};
     let validatedSampleRate;
     if (options?.sampleRate) {
       validatedSampleRate = validateEnumValue(
@@ -2103,112 +2317,376 @@ var GladiaAdapter = class extends BaseAdapter {
         "Gladia"
       );
     }
+    let validatedBitDepth;
+    if (options?.bitDepth) {
+      validatedBitDepth = validateEnumValue(
+        options.bitDepth,
+        StreamingSupportedBitDepthEnum,
+        "bit depth",
+        "Gladia"
+      );
+    }
     const streamingRequest = {
+      // Spread any direct Gladia streaming options first
+      ...gladiaOpts,
+      // Audio format configuration (these are excluded from gladiaStreaming to avoid conflicts)
       encoding: options?.encoding ? mapEncodingToProvider(options.encoding, "gladia") : void 0,
       sample_rate: validatedSampleRate,
+      bit_depth: validatedBitDepth,
       channels: options?.channels,
-      endpointing: options?.endpointing,
-      model: options?.model
+      // Model and processing
+      model: options?.model ?? gladiaOpts.model,
+      endpointing: options?.endpointing ?? gladiaOpts.endpointing,
+      maximum_duration_without_endpointing: options?.maxSilence ?? gladiaOpts.maximum_duration_without_endpointing
     };
-    if (options?.language) {
+    if (options?.language || options?.codeSwitching || gladiaOpts.language_config) {
       streamingRequest.language_config = {
-        languages: [options.language]
+        ...gladiaOpts.language_config,
+        languages: options?.language ? [options.language] : gladiaOpts.language_config?.languages,
+        code_switching: options?.codeSwitching ?? gladiaOpts.language_config?.code_switching
       };
     }
-    const initResponse = await streamingControllerInitStreamingSessionV2(
-      streamingRequest,
-      void 0,
-      // no params
-      this.getAxiosConfig()
-    );
-    const { id, url: wsUrl } = initResponse.data;
-    const ws = new WebSocket(wsUrl);
-    let sessionStatus = "connecting";
-    setupWebSocketHandlers(ws, callbacks, (status) => {
-      sessionStatus = status;
-    });
-    ws.on("message", (data) => {
-      try {
-        const message = JSON.parse(data.toString());
-        if (message.type === "transcript") {
-          const transcriptMessage = message;
-          const messageData = transcriptMessage.data;
-          const utterance = messageData.utterance;
-          callbacks?.onTranscript?.({
-            type: "transcript",
-            text: utterance.text,
-            isFinal: messageData.is_final,
-            confidence: utterance.confidence,
-            words: utterance.words.map((word) => ({
-              text: word.word,
-              start: word.start,
-              end: word.end,
-              confidence: word.confidence
-            })),
-            data: message
+    if (gladiaOpts.pre_processing) {
+      streamingRequest.pre_processing = gladiaOpts.pre_processing;
+    }
+    const realtimeProcessing = gladiaOpts.realtime_processing || {};
+    const hasRealtimeOptions = options?.customVocabulary || options?.sentimentAnalysis || options?.entityDetection || realtimeProcessing.translation || realtimeProcessing.custom_vocabulary || realtimeProcessing.custom_spelling || realtimeProcessing.named_entity_recognition || realtimeProcessing.sentiment_analysis;
+    if (hasRealtimeOptions) {
+      streamingRequest.realtime_processing = {
+        ...realtimeProcessing,
+        // Custom vocabulary
+        custom_vocabulary: options?.customVocabulary && options.customVocabulary.length > 0 || realtimeProcessing.custom_vocabulary,
+        custom_vocabulary_config: options?.customVocabulary && options.customVocabulary.length > 0 ? {
+          ...realtimeProcessing.custom_vocabulary_config,
+          vocabulary: options.customVocabulary
+        } : realtimeProcessing.custom_vocabulary_config,
+        // Sentiment analysis
+        sentiment_analysis: options?.sentimentAnalysis ?? realtimeProcessing.sentiment_analysis,
+        // Named entity recognition
+        named_entity_recognition: options?.entityDetection ?? realtimeProcessing.named_entity_recognition
+      };
+    }
+    const postProcessing = gladiaOpts.post_processing || {};
+    if (options?.summarization || postProcessing.summarization || postProcessing.chapterization) {
+      streamingRequest.post_processing = {
+        ...postProcessing,
+        summarization: options?.summarization ?? postProcessing.summarization
+      };
+    }
+    if (gladiaOpts.messages_config) {
+      streamingRequest.messages_config = gladiaOpts.messages_config;
+    } else if (options?.interimResults !== void 0) {
+      streamingRequest.messages_config = {
+        receive_partial_transcripts: options.interimResults,
+        receive_final_transcripts: true
+      };
+    }
+    if (gladiaOpts.callback || gladiaOpts.callback_config) {
+      streamingRequest.callback = gladiaOpts.callback;
+      streamingRequest.callback_config = gladiaOpts.callback_config;
+    }
+    if (gladiaOpts.custom_metadata) {
+      streamingRequest.custom_metadata = gladiaOpts.custom_metadata;
+    }
+    return streamingRequest;
+  }
+  /**
+   * Handle all WebSocket message types from Gladia streaming
+   *
+   * Processes transcript, utterance, speech events, real-time processing
+   * results (translation, sentiment, NER), post-processing results
+   * (summarization, chapterization), acknowledgments, and lifecycle events.
+   */
+  handleWebSocketMessage(message, callbacks) {
+    const msg = message;
+    const messageType = msg.type;
+    switch (messageType) {
+      // ─────────────────────────────────────────────────────────────────
+      // Transcript events
+      // ─────────────────────────────────────────────────────────────────
+      case "transcript": {
+        const transcriptMessage = message;
+        const messageData = transcriptMessage.data;
+        const utterance = messageData.utterance;
+        callbacks?.onTranscript?.({
+          type: "transcript",
+          text: utterance.text,
+          isFinal: messageData.is_final,
+          confidence: utterance.confidence,
+          language: utterance.language,
+          channel: utterance.channel,
+          speaker: utterance.speaker?.toString(),
+          words: utterance.words.map((w) => ({
+            word: w.word,
+            start: w.start,
+            end: w.end,
+            confidence: w.confidence
+          })),
+          data: message
+        });
+        break;
+      }
+      case "utterance": {
+        const transcriptMessage = message;
+        const messageData = transcriptMessage.data;
+        const utterance = messageData.utterance;
+        callbacks?.onUtterance?.({
+          text: utterance.text,
+          start: utterance.start,
+          end: utterance.end,
+          speaker: utterance.speaker?.toString(),
+          confidence: utterance.confidence,
+          words: utterance.words.map((w) => ({
+            word: w.word,
+            start: w.start,
+            end: w.end,
+            confidence: w.confidence
+          }))
+        });
+        break;
+      }
+      // Post-processing transcripts (final accumulated transcript)
+      case "post_transcript": {
+        const postTranscript = message;
+        callbacks?.onTranscript?.({
+          type: "transcript",
+          text: postTranscript.data?.full_transcript || "",
+          isFinal: true,
+          data: message
+        });
+        break;
+      }
+      case "post_final_transcript": {
+        const postFinal = message;
+        callbacks?.onTranscript?.({
+          type: "transcript",
+          text: postFinal.data?.transcription?.full_transcript || "",
+          isFinal: true,
+          data: message
+        });
+        break;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Speech detection events
+      // ─────────────────────────────────────────────────────────────────
+      case "speech_start": {
+        const speechStart = message;
+        const event = {
+          type: "speech_start",
+          timestamp: speechStart.data.time,
+          channel: speechStart.data.channel,
+          sessionId: speechStart.session_id
+        };
+        callbacks?.onSpeechStart?.(event);
+        break;
+      }
+      case "speech_end": {
+        const speechEnd = message;
+        const event = {
+          type: "speech_end",
+          timestamp: speechEnd.data.time,
+          channel: speechEnd.data.channel,
+          sessionId: speechEnd.session_id
+        };
+        callbacks?.onSpeechEnd?.(event);
+        break;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Real-time processing events
+      // ─────────────────────────────────────────────────────────────────
+      case "translation": {
+        const translationMsg = message;
+        if (translationMsg.error) {
+          callbacks?.onError?.({
+            code: ERROR_CODES.TRANSCRIPTION_ERROR,
+            message: "Translation failed",
+            details: translationMsg.error
+          });
+        } else if (translationMsg.data) {
+          const event = {
+            utteranceId: translationMsg.data.utterance_id,
+            original: translationMsg.data.utterance.text,
+            targetLanguage: translationMsg.data.target_language,
+            translatedText: translationMsg.data.translated_utterance.text,
+            isFinal: true
+          };
+          callbacks?.onTranslation?.(event);
+        }
+        break;
+      }
+      case "sentiment_analysis": {
+        const sentimentMsg = message;
+        if (sentimentMsg.error) {
+          callbacks?.onError?.({
+            code: ERROR_CODES.TRANSCRIPTION_ERROR,
+            message: "Sentiment analysis failed",
+            details: sentimentMsg.error
+          });
+        } else if (sentimentMsg.data) {
+          for (const result of sentimentMsg.data.results) {
+            const event = {
+              utteranceId: sentimentMsg.data.utterance_id,
+              sentiment: result.sentiment,
+              confidence: void 0
+              // Gladia doesn't provide confidence for sentiment
+            };
+            callbacks?.onSentiment?.(event);
+          }
+        }
+        break;
+      }
+      case "named_entity_recognition": {
+        const nerMsg = message;
+        if (nerMsg.error) {
+          callbacks?.onError?.({
+            code: ERROR_CODES.TRANSCRIPTION_ERROR,
+            message: "Named entity recognition failed",
+            details: nerMsg.error
           });
-        } else if (message.type === "utterance") {
-          const transcriptMessage = message;
-          const messageData = transcriptMessage.data;
-          const utterance = messageData.utterance;
-          const utteranceData = {
-            text: utterance.text,
-            start: utterance.start,
-            end: utterance.end,
-            speaker: utterance.speaker?.toString(),
-            confidence: utterance.confidence,
-            words: utterance.words.map((word) => ({
-              text: word.word,
-              start: word.start,
-              end: word.end,
-              confidence: word.confidence
-            }))
-          };
-          callbacks?.onUtterance?.(utteranceData);
-        } else if (message.type === "metadata") {
-          callbacks?.onMetadata?.(message);
+        } else if (nerMsg.data) {
+          for (const entity of nerMsg.data.results) {
+            const event = {
+              utteranceId: nerMsg.data.utterance_id,
+              text: entity.text,
+              type: entity.entity_type,
+              start: entity.start,
+              end: entity.end
+            };
+            callbacks?.onEntity?.(event);
+          }
         }
-      } catch (error) {
-        callbacks?.onError?.({
-          code: ERROR_CODES.PARSE_ERROR,
-          message: "Failed to parse WebSocket message",
-          details: error
-        });
+        break;
       }
-    });
-    await waitForWebSocketOpen(ws);
-    return {
-      id,
-      provider: this.name,
-      createdAt: /* @__PURE__ */ new Date(),
-      getStatus: () => sessionStatus,
-      sendAudio: async (chunk) => {
-        validateSessionForAudio(sessionStatus, ws.readyState, WebSocket.OPEN);
-        ws.send(chunk.data);
-        if (chunk.isLast) {
-          ws.send(
-            JSON.stringify({
-              type: "stop_recording"
-            })
-          );
+      // ─────────────────────────────────────────────────────────────────
+      // Post-processing events
+      // ─────────────────────────────────────────────────────────────────
+      case "post_summarization": {
+        const summaryMsg = message;
+        if (summaryMsg.error) {
+          callbacks?.onSummarization?.({
+            summary: "",
+            error: typeof summaryMsg.error === "string" ? summaryMsg.error : "Summarization failed"
+          });
+        } else if (summaryMsg.data) {
+          callbacks?.onSummarization?.({
+            summary: summaryMsg.data.results
+          });
         }
-      },
-      close: async () => {
-        if (sessionStatus === "closed" || sessionStatus === "closing") {
-          return;
+        break;
+      }
+      case "post_chapterization": {
+        const chapterMsg = message;
+        if (chapterMsg.error) {
+          callbacks?.onChapterization?.({
+            chapters: [],
+            error: typeof chapterMsg.error === "string" ? chapterMsg.error : "Chapterization failed"
+          });
+        } else if (chapterMsg.data) {
+          callbacks?.onChapterization?.({
+            chapters: chapterMsg.data.results.map((ch) => ({
+              headline: ch.headline,
+              summary: ch.summary || ch.abstractive_summary || ch.extractive_summary || "",
+              start: ch.start,
+              end: ch.end
+            }))
+          });
         }
-        sessionStatus = "closing";
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.send(
-            JSON.stringify({
-              type: "stop_recording"
-            })
-          );
+        break;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Acknowledgment events
+      // ─────────────────────────────────────────────────────────────────
+      case "audio_chunk_ack": {
+        const ackMsg = message;
+        if (ackMsg.error) {
+          callbacks?.onError?.({
+            code: ERROR_CODES.TRANSCRIPTION_ERROR,
+            message: "Audio chunk not acknowledged",
+            details: ackMsg.error
+          });
+        } else if (ackMsg.data) {
+          const event = {
+            byteRange: ackMsg.data.byte_range,
+            timeRange: ackMsg.data.time_range,
+            timestamp: ackMsg.created_at
+          };
+          callbacks?.onAudioAck?.(event);
         }
-        await closeWebSocket(ws);
-        sessionStatus = "closed";
+        break;
       }
-    };
+      case "stop_recording_ack": {
+        const stopAck = message;
+        if (stopAck.error) {
+          callbacks?.onError?.({
+            code: ERROR_CODES.TRANSCRIPTION_ERROR,
+            message: "Stop recording not acknowledged",
+            details: stopAck.error
+          });
+        }
+        break;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Lifecycle events
+      // ─────────────────────────────────────────────────────────────────
+      case "start_session": {
+        const startSession = message;
+        const event = {
+          eventType: "start_session",
+          timestamp: startSession.created_at,
+          sessionId: startSession.session_id
+        };
+        callbacks?.onLifecycle?.(event);
+        break;
+      }
+      case "start_recording": {
+        const startRecording = message;
+        const event = {
+          eventType: "start_recording",
+          timestamp: startRecording.created_at,
+          sessionId: startRecording.session_id
+        };
+        callbacks?.onLifecycle?.(event);
+        break;
+      }
+      case "end_recording": {
+        const endRecording = message;
+        const event = {
+          eventType: "end_recording",
+          timestamp: endRecording.created_at,
+          sessionId: endRecording.session_id
+        };
+        callbacks?.onLifecycle?.(event);
+        break;
+      }
+      case "end_session": {
+        const endSession = message;
+        const event = {
+          eventType: "end_session",
+          timestamp: endSession.created_at,
+          sessionId: endSession.session_id
+        };
+        callbacks?.onLifecycle?.(event);
+        break;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Metadata and other events
+      // ─────────────────────────────────────────────────────────────────
+      case "metadata":
+        callbacks?.onMetadata?.(msg);
+        break;
+      case "error": {
+        const errorMsg = msg;
+        callbacks?.onError?.({
+          code: errorMsg.error?.code || ERROR_CODES.TRANSCRIPTION_ERROR,
+          message: errorMsg.error?.message || "Unknown streaming error",
+          details: msg
+        });
+        break;
+      }
+      default:
+        callbacks?.onMetadata?.(msg);
+        break;
+    }
   }
 };
 function createGladiaAdapter(config) {
@@ -2866,14 +3344,14 @@ var AssemblyAIAdapter = class extends BaseAdapter {
     if (!transcript.words || transcript.words.length === 0) {
       return void 0;
     }
-    return transcript.words.map((word) => ({
-      text: word.text,
-      start: word.start / 1e3,
+    return transcript.words.map((w) => ({
+      word: w.text,
+      start: w.start / 1e3,
       // Convert ms to seconds
-      end: word.end / 1e3,
+      end: w.end / 1e3,
       // Convert ms to seconds
-      confidence: word.confidence,
-      speaker: word.speaker || void 0
+      confidence: w.confidence,
+      speaker: w.speaker || void 0
     }));
   }
   /**
@@ -2891,11 +3369,11 @@ var AssemblyAIAdapter = class extends BaseAdapter {
       // Convert ms to seconds
       speaker: utterance.speaker || void 0,
       confidence: utterance.confidence,
-      words: utterance.words.map((word) => ({
-        text: word.text,
-        start: word.start / 1e3,
-        end: word.end / 1e3,
-        confidence: word.confidence
+      words: utterance.words.map((w) => ({
+        word: w.text,
+        start: w.start / 1e3,
+        end: w.end / 1e3,
+        confidence: w.confidence
       }))
     }));
   }
@@ -2903,19 +3381,37 @@ var AssemblyAIAdapter = class extends BaseAdapter {
    * Stream audio for real-time transcription
    *
    * Creates a WebSocket connection to AssemblyAI for streaming transcription.
-   * First obtains a temporary token, then connects and streams audio chunks.
+   * Uses the v3 Universal Streaming API with full support for all parameters.
+   *
+   * Supports all AssemblyAI streaming features:
+   * - Real-time transcription with interim/final results (Turn events)
+   * - End-of-turn detection tuning (confidence threshold, silence duration)
+   * - Voice Activity Detection (VAD) threshold tuning
+   * - Real-time text formatting
+   * - Profanity filtering
+   * - Custom vocabulary (keyterms)
+   * - Language detection
+   * - Model selection (English or Multilingual)
+   * - Dynamic configuration updates mid-stream
+   * - Force endpoint command
    *
    * @param options - Streaming configuration options
+   * @param options.sampleRate - Sample rate (8000, 16000, 22050, 44100, 48000)
+   * @param options.encoding - Audio encoding (pcm_s16le, pcm_mulaw)
+   * @param options.assemblyaiStreaming - All AssemblyAI-specific streaming options
    * @param callbacks - Event callbacks for transcription results
-   * @returns Promise that resolves with a StreamingSession
+   * @param callbacks.onTranscript - Interim/final transcript received (Turn event)
+   * @param callbacks.onUtterance - Complete utterance (Turn with end_of_turn=true)
+   * @param callbacks.onMetadata - Session metadata (Begin, Termination events)
+   * @param callbacks.onError - Error occurred
+   * @param callbacks.onClose - Connection closed
+   * @returns Promise that resolves with an extended StreamingSession
    *
-   * @example Real-time streaming
+   * @example Basic real-time streaming
    * ```typescript
    * const session = await adapter.transcribeStream({
-   *   encoding: 'pcm_s16le',
    *   sampleRate: 16000,
-   *   language: 'en',
-   *   interimResults: true
+   *   encoding: 'pcm_s16le'
    * }, {
    *   onOpen: () => console.log('Connected'),
    *   onTranscript: (event) => {
@@ -2930,21 +3426,50 @@ var AssemblyAIAdapter = class extends BaseAdapter {
    * });
    *
    * // Send audio chunks
-   * const audioChunk = getAudioChunk(); // Your audio source
+   * const audioChunk = getAudioChunk();
    * await session.sendAudio({ data: audioChunk });
    *
    * // Close when done
    * await session.close();
    * ```
+   *
+   * @example Advanced streaming with all features
+   * ```typescript
+   * const session = await adapter.transcribeStream({
+   *   sampleRate: 16000,
+   *   assemblyaiStreaming: {
+   *     speechModel: 'universal-streaming-multilingual',
+   *     languageDetection: true,
+   *     endOfTurnConfidenceThreshold: 0.7,
+   *     minEndOfTurnSilenceWhenConfident: 500,
+   *     maxTurnSilence: 15000,
+   *     vadThreshold: 0.3,
+   *     formatTurns: true,
+   *     filterProfanity: true,
+   *     keyterms: ['TypeScript', 'JavaScript', 'API'],
+   *     inactivityTimeout: 60000
+   *   }
+   * }, {
+   *   onTranscript: (e) => console.log('Transcript:', e.text),
+   *   onMetadata: (m) => console.log('Metadata:', m)
+   * });
+   *
+   * // Update configuration mid-stream
+   * session.updateConfiguration?.({
+   *   end_of_turn_confidence_threshold: 0.5,
+   *   vad_threshold: 0.2
+   * });
+   *
+   * // Force endpoint detection
+   * session.forceEndpoint?.();
+   * ```
    */
   async transcribeStream(options, callbacks) {
     this.validateConfig();
     if (!this.config?.apiKey) {
       throw new Error("API key is required for streaming");
     }
-    const sampleRate = options?.sampleRate || 16e3;
-    const encoding = options?.encoding ? mapEncodingToProvider(options.encoding, "assemblyai") : "pcm_s16le";
-    const wsUrl = `${this.wsBaseUrl}?sample_rate=${sampleRate}&encoding=${encoding}`;
+    const wsUrl = this.buildStreamingUrl(options);
     const ws = new WebSocket2(wsUrl, {
       headers: {
         Authorization: this.config.apiKey
@@ -2968,43 +3493,7 @@ var AssemblyAIAdapter = class extends BaseAdapter {
     ws.on("message", (data) => {
       try {
         const message = JSON.parse(data.toString());
-        if ("error" in message) {
-          callbacks?.onError?.({
-            code: "API_ERROR",
-            message: message.error
-          });
-          return;
-        }
-        if (message.type === "Begin") {
-          const beginMsg = message;
-          callbacks?.onMetadata?.({
-            sessionId: beginMsg.id,
-            expiresAt: new Date(beginMsg.expires_at).toISOString()
-          });
-        } else if (message.type === "Turn") {
-          const turnMsg = message;
-          callbacks?.onTranscript?.({
-            type: "transcript",
-            text: turnMsg.transcript,
-            isFinal: turnMsg.end_of_turn,
-            confidence: turnMsg.end_of_turn_confidence,
-            words: turnMsg.words.map((word) => ({
-              text: word.text,
-              start: word.start / 1e3,
-              // Convert ms to seconds
-              end: word.end / 1e3,
-              confidence: word.confidence
-            })),
-            data: turnMsg
-          });
-        } else if (message.type === "Termination") {
-          const termMsg = message;
-          callbacks?.onMetadata?.({
-            terminated: true,
-            audioDurationSeconds: termMsg.audio_duration_seconds,
-            sessionDurationSeconds: termMsg.session_duration_seconds
-          });
-        }
+        this.handleWebSocketMessage(message, callbacks);
       } catch (error) {
         callbacks?.onError?.({
           code: "PARSE_ERROR",
@@ -3056,11 +3545,7 @@ var AssemblyAIAdapter = class extends BaseAdapter {
         }
         if (chunk.isLast) {
           flushAudioBuffer();
-          ws.send(
-            JSON.stringify({
-              terminate_session: true
-            })
-          );
+          ws.send(JSON.stringify({ type: "Terminate" }));
         }
       },
       close: async () => {
@@ -3070,11 +3555,7 @@ var AssemblyAIAdapter = class extends BaseAdapter {
         sessionStatus = "closing";
         flushAudioBuffer();
         if (ws.readyState === WebSocket2.OPEN) {
-          ws.send(
-            JSON.stringify({
-              terminate_session: true
-            })
-          );
+          ws.send(JSON.stringify({ type: "Terminate" }));
         }
         return new Promise((resolve) => {
           const timeout = setTimeout(() => {
@@ -3088,9 +3569,166 @@ var AssemblyAIAdapter = class extends BaseAdapter {
             resolve();
           });
         });
+      },
+      /**
+       * Update streaming configuration mid-session
+       *
+       * Allows changing VAD, end-of-turn, and formatting settings
+       * without restarting the stream.
+       *
+       * @param config - Configuration parameters to update
+       */
+      updateConfiguration: (config) => {
+        if (ws.readyState !== WebSocket2.OPEN) {
+          throw new Error("Cannot update configuration: WebSocket is not open");
+        }
+        const updateMsg = {
+          type: "UpdateConfiguration",
+          ...config
+        };
+        ws.send(JSON.stringify(updateMsg));
+      },
+      /**
+       * Force endpoint detection
+       *
+       * Immediately triggers end-of-turn, useful for manual control
+       * of turn boundaries (e.g., when user presses a button).
+       */
+      forceEndpoint: () => {
+        if (ws.readyState !== WebSocket2.OPEN) {
+          throw new Error("Cannot force endpoint: WebSocket is not open");
+        }
+        const forceMsg = {
+          type: "ForceEndpoint"
+        };
+        ws.send(JSON.stringify(forceMsg));
       }
     };
   }
+  /**
+   * Build WebSocket URL with all streaming parameters
+   */
+  buildStreamingUrl(options) {
+    const params = new URLSearchParams();
+    const aaiOpts = options?.assemblyaiStreaming || {};
+    const sampleRate = options?.sampleRate || aaiOpts.sampleRate || 16e3;
+    params.append("sample_rate", String(sampleRate));
+    const encoding = options?.encoding ? mapEncodingToProvider(options.encoding, "assemblyai") : aaiOpts.encoding || "pcm_s16le";
+    params.append("encoding", encoding);
+    if (aaiOpts.speechModel) {
+      params.append("speech_model", aaiOpts.speechModel);
+    }
+    if (aaiOpts.languageDetection) {
+      params.append("language_detection", "true");
+    }
+    if (aaiOpts.endOfTurnConfidenceThreshold !== void 0) {
+      params.append(
+        "end_of_turn_confidence_threshold",
+        String(aaiOpts.endOfTurnConfidenceThreshold)
+      );
+    }
+    if (aaiOpts.minEndOfTurnSilenceWhenConfident !== void 0) {
+      params.append(
+        "min_end_of_turn_silence_when_confident",
+        String(aaiOpts.minEndOfTurnSilenceWhenConfident)
+      );
+    }
+    if (aaiOpts.maxTurnSilence !== void 0) {
+      params.append("max_turn_silence", String(aaiOpts.maxTurnSilence));
+    }
+    if (aaiOpts.vadThreshold !== void 0) {
+      params.append("vad_threshold", String(aaiOpts.vadThreshold));
+    }
+    if (aaiOpts.formatTurns !== void 0) {
+      params.append("format_turns", String(aaiOpts.formatTurns));
+    }
+    if (aaiOpts.filterProfanity) {
+      params.append("filter_profanity", "true");
+    }
+    const keyterms = options?.customVocabulary || aaiOpts.keyterms;
+    if (keyterms && keyterms.length > 0) {
+      keyterms.forEach((term) => params.append("keyterms", term));
+    }
+    if (aaiOpts.keytermsPrompt && aaiOpts.keytermsPrompt.length > 0) {
+      aaiOpts.keytermsPrompt.forEach((prompt) => params.append("keyterms_prompt", prompt));
+    }
+    if (aaiOpts.inactivityTimeout !== void 0) {
+      params.append("inactivity_timeout", String(aaiOpts.inactivityTimeout));
+    }
+    return `${this.wsBaseUrl}?${params.toString()}`;
+  }
+  /**
+   * Handle all WebSocket message types from AssemblyAI streaming
+   */
+  handleWebSocketMessage(message, callbacks) {
+    if ("error" in message) {
+      callbacks?.onError?.({
+        code: "API_ERROR",
+        message: message.error
+      });
+      return;
+    }
+    const typedMessage = message;
+    switch (typedMessage.type) {
+      case "Begin": {
+        const beginMsg = typedMessage;
+        callbacks?.onMetadata?.({
+          type: "begin",
+          sessionId: beginMsg.id,
+          expiresAt: new Date(beginMsg.expires_at).toISOString()
+        });
+        break;
+      }
+      case "Turn": {
+        const turnMsg = typedMessage;
+        callbacks?.onTranscript?.({
+          type: "transcript",
+          text: turnMsg.transcript,
+          isFinal: turnMsg.end_of_turn,
+          confidence: turnMsg.end_of_turn_confidence,
+          language: turnMsg.language_code,
+          words: turnMsg.words.map((w) => ({
+            word: w.text,
+            start: w.start / 1e3,
+            // Convert ms to seconds
+            end: w.end / 1e3,
+            confidence: w.confidence
+          })),
+          data: turnMsg
+        });
+        if (turnMsg.end_of_turn) {
+          const words = turnMsg.words;
+          const start = words.length > 0 ? words[0].start / 1e3 : 0;
+          const end = words.length > 0 ? words[words.length - 1].end / 1e3 : 0;
+          callbacks?.onUtterance?.({
+            text: turnMsg.transcript,
+            start,
+            end,
+            confidence: turnMsg.end_of_turn_confidence,
+            words: turnMsg.words.map((w) => ({
+              word: w.text,
+              start: w.start / 1e3,
+              end: w.end / 1e3,
+              confidence: w.confidence
+            }))
+          });
+        }
+        break;
+      }
+      case "Termination": {
+        const termMsg = typedMessage;
+        callbacks?.onMetadata?.({
+          type: "termination",
+          audioDurationSeconds: termMsg.audio_duration_seconds,
+          sessionDurationSeconds: termMsg.session_duration_seconds
+        });
+        break;
+      }
+      default:
+        callbacks?.onMetadata?.(message);
+        break;
+    }
+  }
 };
 function createAssemblyAIAdapter(config) {
   const adapter = new AssemblyAIAdapter();
@@ -3352,11 +3990,11 @@ var DeepgramAdapter = class extends BaseAdapter {
       return void 0;
     }
     return alternative.words.map(
-      (word) => ({
-        text: word.word || "",
-        start: word.start || 0,
-        end: word.end || 0,
-        confidence: word.confidence,
+      (w) => ({
+        word: w.word || "",
+        start: w.start || 0,
+        end: w.end || 0,
+        confidence: w.confidence,
         speaker: void 0
         // Speaker info is at utterance level, not word level
       })
@@ -3376,11 +4014,11 @@ var DeepgramAdapter = class extends BaseAdapter {
       end: utterance.end || 0,
       speaker: utterance.speaker?.toString(),
       confidence: utterance.confidence,
-      words: utterance.words?.map((word) => ({
-        text: word.word || "",
-        start: word.start || 0,
-        end: word.end || 0,
-        confidence: word.confidence
+      words: utterance.words?.map((w) => ({
+        word: w.word || "",
+        start: w.start || 0,
+        end: w.end || 0,
+        confidence: w.confidence
       }))
     }));
   }
@@ -3399,11 +4037,44 @@ var DeepgramAdapter = class extends BaseAdapter {
    * Creates a WebSocket connection to Deepgram for streaming transcription.
    * Send audio chunks via session.sendAudio() and receive results via callbacks.
    *
+   * Supports all Deepgram streaming features:
+   * - Real-time transcription with interim/final results
+   * - Speech detection events (SpeechStarted, UtteranceEnd)
+   * - Speaker diarization
+   * - Language detection
+   * - Real-time sentiment, entity detection, topics, intents
+   * - Custom vocabulary (keywords, keyterms)
+   * - PII redaction
+   * - Filler words, numerals, measurements, paragraphs
+   * - Profanity filtering
+   * - Dictation mode
+   *
    * @param options - Streaming configuration options
+   * @param options.encoding - Audio encoding (linear16, flac, mulaw, opus, speex, g729)
+   * @param options.sampleRate - Sample rate in Hz
+   * @param options.channels - Number of audio channels
+   * @param options.language - Language code for transcription
+   * @param options.model - Model to use (nova-2, nova-3, base, enhanced, etc.)
+   * @param options.diarization - Enable speaker identification
+   * @param options.languageDetection - Auto-detect language
+   * @param options.interimResults - Enable partial transcripts
+   * @param options.summarization - Enable summarization
+   * @param options.sentimentAnalysis - Enable sentiment analysis
+   * @param options.entityDetection - Enable entity detection
+   * @param options.piiRedaction - Enable PII redaction
+   * @param options.customVocabulary - Keywords to boost recognition
+   * @param options.deepgramStreaming - All Deepgram-specific streaming options
    * @param callbacks - Event callbacks for transcription results
+   * @param callbacks.onTranscript - Interim/final transcript received
+   * @param callbacks.onUtterance - Complete utterance detected
+   * @param callbacks.onSpeechStart - Speech detected (Deepgram SpeechStarted)
+   * @param callbacks.onSpeechEnd - Speech ended (Deepgram UtteranceEnd)
+   * @param callbacks.onMetadata - Metadata received
+   * @param callbacks.onError - Error occurred
+   * @param callbacks.onClose - Connection closed
    * @returns Promise that resolves with a StreamingSession
    *
-   * @example Real-time streaming
+   * @example Basic real-time streaming
    * ```typescript
    * const session = await adapter.transcribeStream({
    *   encoding: 'linear16',
@@ -3426,32 +4097,47 @@ var DeepgramAdapter = class extends BaseAdapter {
    * });
    *
    * // Send audio chunks
-   * const audioChunk = getAudioChunk(); // Your audio source
+   * const audioChunk = getAudioChunk();
    * await session.sendAudio({ data: audioChunk });
    *
    * // Close when done
    * await session.close();
    * ```
+   *
+   * @example Advanced streaming with all features
+   * ```typescript
+   * const session = await adapter.transcribeStream({
+   *   encoding: 'linear16',
+   *   sampleRate: 16000,
+   *   language: 'en',
+   *   model: 'nova-3',
+   *   diarization: true,
+   *   sentimentAnalysis: true,
+   *   entityDetection: true,
+   *   deepgramStreaming: {
+   *     fillerWords: true,
+   *     numerals: true,
+   *     profanityFilter: true,
+   *     topics: true,
+   *     intents: true,
+   *     customTopic: ['sales', 'support'],
+   *     customIntent: ['purchase', 'complaint'],
+   *     keyterm: ['TypeScript', 'JavaScript'],
+   *     utteranceSplit: 800,
+   *     punctuate: true,
+   *     smartFormat: true
+   *   }
+   * }, {
+   *   onTranscript: (e) => console.log('Transcript:', e.text),
+   *   onSpeechStart: (e) => console.log('Speech started at:', e.timestamp),
+   *   onSpeechEnd: (e) => console.log('Utterance ended'),
+   *   onMetadata: (m) => console.log('Metadata:', m)
+   * });
+   * ```
    */
   async transcribeStream(options, callbacks) {
     this.validateConfig();
-    const params = new URLSearchParams();
-    if (options?.encoding) params.append("encoding", options.encoding);
-    if (options?.sampleRate) params.append("sample_rate", options.sampleRate.toString());
-    if (options?.channels) params.append("channels", options.channels.toString());
-    if (options?.language) params.append("language", options.language);
-    if (options?.model) params.append("model", options.model);
-    if (options?.languageDetection) params.append("detect_language", "true");
-    if (options?.diarization) params.append("diarize", "true");
-    if (options?.interimResults) params.append("interim_results", "true");
-    if (options?.summarization) params.append("summarize", "true");
-    if (options?.sentimentAnalysis) params.append("sentiment", "true");
-    if (options?.entityDetection) params.append("detect_entities", "true");
-    if (options?.piiRedaction) params.append("redact", "pii");
-    if (options?.customVocabulary && options.customVocabulary.length > 0) {
-      params.append("keywords", options.customVocabulary.join(","));
-    }
-    const wsUrl = `${this.wsBaseUrl}?${params.toString()}`;
+    const wsUrl = this.buildStreamingUrl(options);
     const ws = new WebSocket3(wsUrl, {
       headers: {
         Authorization: `Token ${this.config.apiKey}`
@@ -3466,31 +4152,7 @@ var DeepgramAdapter = class extends BaseAdapter {
     ws.on("message", (data) => {
       try {
         const message = JSON.parse(data.toString());
-        if (message.type === "Results") {
-          const channel = message.channel.alternatives[0];
-          if (channel) {
-            const transcript = channel.transcript;
-            const isFinal = message.is_final;
-            const words = channel.words?.map((word) => ({
-              text: word.word,
-              start: word.start,
-              end: word.end,
-              confidence: word.confidence
-            }));
-            callbacks?.onTranscript?.({
-              type: "transcript",
-              text: transcript,
-              isFinal,
-              words,
-              confidence: channel.confidence,
-              data: message
-            });
-          }
-        } else if (message.type === "UtteranceEnd") {
-          callbacks?.onMetadata?.(message);
-        } else if (message.type === "Metadata") {
-          callbacks?.onMetadata?.(message);
-        }
+        this.handleWebSocketMessage(message, callbacks);
       } catch (error) {
         callbacks?.onError?.({
           code: "PARSE_ERROR",
@@ -3563,6 +4225,210 @@ var DeepgramAdapter = class extends BaseAdapter {
       }
     };
   }
+  /**
+   * Build WebSocket URL with all streaming parameters
+   */
+  buildStreamingUrl(options) {
+    const params = new URLSearchParams();
+    const dgOpts = options?.deepgramStreaming || {};
+    if (options?.encoding || dgOpts.encoding) {
+      params.append("encoding", options?.encoding || dgOpts.encoding);
+    }
+    if (options?.sampleRate || dgOpts.sampleRate) {
+      params.append("sample_rate", String(options?.sampleRate || dgOpts.sampleRate));
+    }
+    if (options?.channels || dgOpts.channels) {
+      params.append("channels", String(options?.channels || dgOpts.channels));
+    }
+    if (options?.language || dgOpts.language) {
+      params.append("language", options?.language || dgOpts.language);
+    }
+    if (options?.model || dgOpts.model) {
+      params.append("model", options?.model || dgOpts.model);
+    }
+    if (dgOpts.version) {
+      params.append("version", dgOpts.version);
+    }
+    if (options?.languageDetection || dgOpts.languageDetection) {
+      params.append("detect_language", "true");
+    }
+    if (options?.diarization || dgOpts.diarization) {
+      params.append("diarize", "true");
+    }
+    if (options?.interimResults || dgOpts.interimResults) {
+      params.append("interim_results", "true");
+    }
+    if (dgOpts.punctuate !== void 0) {
+      params.append("punctuate", String(dgOpts.punctuate));
+    }
+    if (dgOpts.smartFormat !== void 0) {
+      params.append("smart_format", String(dgOpts.smartFormat));
+    }
+    if (dgOpts.fillerWords) {
+      params.append("filler_words", "true");
+    }
+    if (dgOpts.numerals) {
+      params.append("numerals", "true");
+    }
+    if (dgOpts.measurements) {
+      params.append("measurements", "true");
+    }
+    if (dgOpts.paragraphs) {
+      params.append("paragraphs", "true");
+    }
+    if (dgOpts.profanityFilter) {
+      params.append("profanity_filter", "true");
+    }
+    if (dgOpts.dictation) {
+      params.append("dictation", "true");
+    }
+    if (dgOpts.utteranceSplit) {
+      params.append("utt_split", String(dgOpts.utteranceSplit));
+    }
+    if (options?.summarization || dgOpts.summarize) {
+      params.append("summarize", "true");
+    }
+    if (options?.sentimentAnalysis || dgOpts.sentiment) {
+      params.append("sentiment", "true");
+    }
+    if (options?.entityDetection || dgOpts.detectEntities) {
+      params.append("detect_entities", "true");
+    }
+    if (dgOpts.topics) {
+      params.append("topics", "true");
+    }
+    if (dgOpts.customTopic && dgOpts.customTopic.length > 0) {
+      dgOpts.customTopic.forEach((topic) => params.append("custom_topic", topic));
+    }
+    if (dgOpts.customTopicMode) {
+      params.append("custom_topic_mode", dgOpts.customTopicMode);
+    }
+    if (dgOpts.intents) {
+      params.append("intents", "true");
+    }
+    if (dgOpts.customIntent && dgOpts.customIntent.length > 0) {
+      dgOpts.customIntent.forEach((intent) => params.append("custom_intent", intent));
+    }
+    if (dgOpts.customIntentMode) {
+      params.append("custom_intent_mode", dgOpts.customIntentMode);
+    }
+    const keywords = options?.customVocabulary || dgOpts.keywords;
+    if (keywords) {
+      const keywordList = Array.isArray(keywords) ? keywords : [keywords];
+      keywordList.forEach((kw) => params.append("keywords", kw));
+    }
+    if (dgOpts.keyterm && dgOpts.keyterm.length > 0) {
+      dgOpts.keyterm.forEach((term) => params.append("keyterm", term));
+    }
+    if (options?.piiRedaction || dgOpts.redact) {
+      if (Array.isArray(dgOpts.redact)) {
+        dgOpts.redact.forEach((r) => params.append("redact", r));
+      } else if (dgOpts.redact === true || options?.piiRedaction) {
+        params.append("redact", "pii");
+        params.append("redact", "pci");
+      }
+    }
+    if (dgOpts.callback) {
+      params.append("callback", dgOpts.callback);
+    }
+    if (dgOpts.tag && dgOpts.tag.length > 0) {
+      dgOpts.tag.forEach((t) => params.append("tag", t));
+    }
+    if (dgOpts.extra) {
+      params.append("extra", JSON.stringify(dgOpts.extra));
+    }
+    if (options?.endpointing !== void 0 || dgOpts.endpointing !== void 0) {
+      const ep = options?.endpointing ?? dgOpts.endpointing;
+      if (ep === false) {
+        params.append("endpointing", "false");
+      } else if (typeof ep === "number") {
+        params.append("endpointing", String(ep));
+      }
+    }
+    if (dgOpts.vadThreshold !== void 0) {
+      params.append("vad_events", "true");
+    }
+    return `${this.wsBaseUrl}?${params.toString()}`;
+  }
+  /**
+   * Handle all WebSocket message types from Deepgram streaming
+   */
+  handleWebSocketMessage(message, callbacks) {
+    switch (message.type) {
+      case "Results": {
+        const channel = message.channel.alternatives[0];
+        if (channel && channel.transcript) {
+          callbacks?.onTranscript?.({
+            type: "transcript",
+            text: channel.transcript,
+            isFinal: message.is_final,
+            confidence: channel.confidence,
+            language: message.channel.detected_language,
+            words: channel.words?.map((w) => ({
+              word: w.punctuated_word || w.word,
+              start: w.start,
+              end: w.end,
+              confidence: w.confidence,
+              speaker: w.speaker?.toString()
+            })),
+            data: message
+          });
+        }
+        if (message.speech_final && channel && channel.transcript) {
+          callbacks?.onUtterance?.({
+            text: channel.transcript,
+            start: message.start,
+            end: message.start + message.duration,
+            confidence: channel.confidence,
+            words: channel.words?.map((w) => ({
+              word: w.punctuated_word || w.word,
+              start: w.start,
+              end: w.end,
+              confidence: w.confidence
+            }))
+          });
+        }
+        break;
+      }
+      case "SpeechStarted": {
+        const event = {
+          type: "speech_start",
+          timestamp: message.timestamp,
+          channel: message.channel[0]
+        };
+        callbacks?.onSpeechStart?.(event);
+        break;
+      }
+      case "UtteranceEnd": {
+        const event = {
+          type: "speech_end",
+          timestamp: message.last_word_end,
+          channel: message.channel[0]
+        };
+        callbacks?.onSpeechEnd?.(event);
+        break;
+      }
+      case "Metadata": {
+        callbacks?.onMetadata?.(message);
+        break;
+      }
+      case "Error": {
+        callbacks?.onError?.({
+          code: message.variant || "DEEPGRAM_ERROR",
+          message: message.message || message.description || "Unknown error",
+          details: message
+        });
+        break;
+      }
+      case "CloseStream": {
+        break;
+      }
+      default: {
+        callbacks?.onMetadata?.(message);
+        break;
+      }
+    }
+  }
 };
 function createDeepgramAdapter(config) {
   const adapter = new DeepgramAdapter();
@@ -3816,12 +4682,12 @@ var AzureSTTAdapter = class extends BaseAdapter {
     const recognizedPhrases = transcriptionData.recognizedPhrases || [];
     const fullText = combinedPhrases.map((phrase) => phrase.display || phrase.lexical).join(" ") || "";
     const words = recognizedPhrases.flatMap(
-      (phrase) => (phrase.nBest?.[0]?.words || []).map((word) => ({
-        text: word.word,
-        start: word.offsetInTicks / 1e7,
+      (phrase) => (phrase.nBest?.[0]?.words || []).map((w) => ({
+        word: w.word,
+        start: w.offsetInTicks / 1e7,
         // Convert ticks to seconds
-        end: (word.offsetInTicks + word.durationInTicks) / 1e7,
-        confidence: word.confidence,
+        end: (w.offsetInTicks + w.durationInTicks) / 1e7,
+        confidence: w.confidence,
         speaker: phrase.speaker !== void 0 ? phrase.speaker.toString() : void 0
       }))
     );
@@ -4102,10 +4968,10 @@ var OpenAIWhisperAdapter = class extends BaseAdapter {
     }
     if ("duration" in response && "language" in response) {
       const verboseResponse = response;
-      const words = verboseResponse.words?.map((word) => ({
-        text: word.word,
-        start: word.start,
-        end: word.end,
+      const words = verboseResponse.words?.map((w) => ({
+        word: w.word,
+        start: w.start,
+        end: w.end,
         confidence: void 0
       }));
       const requestId2 = `openai-${Date.now()}`;
@@ -4371,7 +5237,7 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
   normalizeResponse(response) {
     const text = response.results.filter((r) => r.type === "word" && r.alternatives).map((r) => r.alternatives[0]?.content || "").join(" ");
     const words = response.results.filter((r) => r.type === "word" && r.start_time !== void 0 && r.end_time !== void 0).map((result) => ({
-      text: result.alternatives?.[0]?.content || "",
+      word: result.alternatives?.[0]?.content || "",
       start: result.start_time,
       end: result.end_time,
       confidence: result.alternatives?.[0]?.confidence,
@@ -4522,12 +5388,12 @@ var GladiaWebhookHandler = class extends BaseWebhookHandler {
   /**
    * Convert Gladia WordDTO to unified Word type
    */
-  mapWord(word) {
+  mapWord(w) {
     return {
-      text: word.word,
-      start: word.start,
-      end: word.end,
-      confidence: word.confidence
+      word: w.word,
+      start: w.start,
+      end: w.end,
+      confidence: w.confidence
     };
   }
   /**
@@ -4865,11 +5731,11 @@ var DeepgramWebhookHandler = class extends BaseWebhookHandler {
           raw: payload
         };
       }
-      const words = alternative.words && alternative.words.length > 0 ? alternative.words.map((word) => ({
-        text: word.word || "",
-        start: word.start || 0,
-        end: word.end || 0,
-        confidence: word.confidence
+      const words = alternative.words && alternative.words.length > 0 ? alternative.words.map((w) => ({
+        word: w.word || "",
+        start: w.start || 0,
+        end: w.end || 0,
+        confidence: w.confidence
       })) : void 0;
       const speakers = response.results.utterances && response.results.utterances.length > 0 ? response.results.utterances.map((utterance) => ({
         id: utterance.speaker?.toString() || "unknown",
@@ -4883,11 +5749,11 @@ var DeepgramWebhookHandler = class extends BaseWebhookHandler {
         end: utterance.end || 0,
         speaker: utterance.speaker?.toString(),
         confidence: utterance.confidence,
-        words: utterance.words && utterance.words.length > 0 ? utterance.words.map((word) => ({
-          text: word.word || "",
-          start: word.start || 0,
-          end: word.end || 0,
-          confidence: word.confidence
+        words: utterance.words && utterance.words.length > 0 ? utterance.words.map((w) => ({
+          word: w.word || "",
+          start: w.start || 0,
+          end: w.end || 0,
+          confidence: w.confidence
         })) : void 0
       })) : void 0;
       const summary = alternative.summaries?.[0]?.summary;
@@ -5398,6 +6264,9 @@ function createWebhookRouter() {
 }
 export {
   AssemblyAIAdapter,
+  AssemblyAIEncoding,
+  AssemblyAISampleRate,
+  AssemblyAISpeechModel,
   schema_exports2 as AssemblyAITypes,
   AssemblyAIWebhookHandler,
   AzureSTTAdapter,
@@ -5405,8 +6274,18 @@ export {
   BaseAdapter,
   BaseWebhookHandler,
   DeepgramAdapter,
+  ListenV1EncodingParameter as DeepgramEncoding,
+  DeepgramModel,
+  ListenV1RedactParameterOneOfItem as DeepgramRedact,
+  SharedCustomTopicModeParameter as DeepgramTopicMode,
   DeepgramWebhookHandler,
   GladiaAdapter,
+  StreamingSupportedBitDepthEnum as GladiaBitDepth,
+  StreamingSupportedEncodingEnum as GladiaEncoding,
+  TranscriptionLanguageCodeEnum as GladiaLanguage,
+  StreamingSupportedModels as GladiaModel,
+  StreamingSupportedSampleRateEnum as GladiaSampleRate,
+  TranslationLanguageCodeEnum as GladiaTranslationLanguage,
   schema_exports as GladiaTypes,
   GladiaWebhookHandler,
   ListenV1EncodingParameter,