voice-router-dev 0.2.8 → 0.3.1

package/dist/index.js

@@ -32,6 +32,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AssemblyAIAdapter: () => AssemblyAIAdapter,
+  AssemblyAIEncoding: () => AssemblyAIEncoding,
+  AssemblyAISampleRate: () => AssemblyAISampleRate,
+  AssemblyAISpeechModel: () => AssemblyAISpeechModel,
   AssemblyAITypes: () => schema_exports2,
   AssemblyAIWebhookHandler: () => AssemblyAIWebhookHandler,
   AzureSTTAdapter: () => AzureSTTAdapter,
@@ -39,8 +42,18 @@ __export(src_exports, {
   BaseAdapter: () => BaseAdapter,
   BaseWebhookHandler: () => BaseWebhookHandler,
   DeepgramAdapter: () => DeepgramAdapter,
+  DeepgramEncoding: () => ListenV1EncodingParameter,
+  DeepgramModel: () => DeepgramModel,
+  DeepgramRedact: () => ListenV1RedactParameterOneOfItem,
+  DeepgramTopicMode: () => SharedCustomTopicModeParameter,
   DeepgramWebhookHandler: () => DeepgramWebhookHandler,
   GladiaAdapter: () => GladiaAdapter,
+  GladiaBitDepth: () => StreamingSupportedBitDepthEnum,
+  GladiaEncoding: () => StreamingSupportedEncodingEnum,
+  GladiaLanguage: () => TranscriptionLanguageCodeEnum,
+  GladiaModel: () => StreamingSupportedModels,
+  GladiaSampleRate: () => StreamingSupportedSampleRateEnum,
+  GladiaTranslationLanguage: () => TranslationLanguageCodeEnum,
   GladiaTypes: () => schema_exports,
   GladiaWebhookHandler: () => GladiaWebhookHandler,
   ListenV1EncodingParameter: () => ListenV1EncodingParameter,
@@ -285,33 +298,17 @@ var ListenV1EncodingParameter = {
   g729: "g729"
 };
 
-// src/generated/deepgram/schema/speakV1EncodingParameter.ts
-var SpeakV1EncodingParameter = {
-  linear16: "linear16",
-  aac: "aac",
-  opus: "opus",
-  mp3: "mp3",
-  flac: "flac",
-  mulaw: "mulaw",
-  alaw: "alaw"
-};
-
-// src/generated/deepgram/schema/speakV1ContainerParameter.ts
-var SpeakV1ContainerParameter = {
-  none: "none",
-  wav: "wav",
-  ogg: "ogg"
+// src/generated/deepgram/schema/listenV1RedactParameterOneOfItem.ts
+var ListenV1RedactParameterOneOfItem = {
+  pci: "pci",
+  pii: "pii",
+  numbers: "numbers"
 };
 
-// src/generated/deepgram/schema/speakV1SampleRateParameter.ts
-var SpeakV1SampleRateParameter = {
-  NUMBER_16000: 16e3,
-  NUMBER_24000: 24e3,
-  NUMBER_32000: 32e3,
-  NUMBER_48000: 48e3,
-  null: null,
-  NUMBER_8000: 8e3,
-  NUMBER_22050: 22050
+// src/generated/deepgram/schema/sharedCustomTopicModeParameter.ts
+var SharedCustomTopicModeParameter = {
+  extended: "extended",
+  strict: "strict"
 };
 
 // src/generated/gladia/schema/streamingSupportedEncodingEnum.ts
@@ -338,137 +335,435 @@ var StreamingSupportedBitDepthEnum = {
   NUMBER_32: 32
 };
 
-// src/constants/defaults.ts
-var DEFAULT_TIMEOUTS = {
-  /** Standard HTTP request timeout for API calls (60 seconds) */
-  HTTP_REQUEST: 6e4,
-  /** Audio processing timeout for long audio files (120 seconds) */
-  AUDIO_PROCESSING: 12e4,
-  /** WebSocket connection establishment timeout (10 seconds) */
-  WS_CONNECTION: 1e4,
-  /** WebSocket graceful close timeout (5 seconds) */
-  WS_CLOSE: 5e3
-};
-var DEFAULT_POLLING = {
-  /** Maximum number of polling attempts before timing out */
-  MAX_ATTEMPTS: 60,
-  /** Standard interval between polling attempts (2 seconds) */
-  INTERVAL_MS: 2e3,
-  /** Slower interval for long-running jobs (3 seconds) */
-  SLOW_INTERVAL_MS: 3e3
+// src/generated/gladia/schema/streamingSupportedModels.ts
+var StreamingSupportedModels = {
+  "solaria-1": "solaria-1"
 };
 
-// src/utils/errors.ts
-var ERROR_CODES = {
-  /** Failed to parse API response or WebSocket message */
-  PARSE_ERROR: "PARSE_ERROR",
-  /** WebSocket connection error */
-  WEBSOCKET_ERROR: "WEBSOCKET_ERROR",
-  /** Async transcription job did not complete within timeout */
-  POLLING_TIMEOUT: "POLLING_TIMEOUT",
-  /** Transcription processing failed on provider side */
-  TRANSCRIPTION_ERROR: "TRANSCRIPTION_ERROR",
-  /** Connection attempt timed out */
-  CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
-  /** Invalid input provided to API */
-  INVALID_INPUT: "INVALID_INPUT",
-  /** Requested operation not supported by provider */
-  NOT_SUPPORTED: "NOT_SUPPORTED",
-  /** No transcription results available */
-  NO_RESULTS: "NO_RESULTS",
-  /** Unspecified or unknown error */
-  UNKNOWN_ERROR: "UNKNOWN_ERROR"
-};
-var ERROR_MESSAGES = {
-  PARSE_ERROR: "Failed to parse response data",
-  WEBSOCKET_ERROR: "WebSocket connection error",
-  POLLING_TIMEOUT: "Transcription did not complete within timeout period",
-  TRANSCRIPTION_ERROR: "Transcription processing failed",
-  CONNECTION_TIMEOUT: "Connection attempt timed out",
-  INVALID_INPUT: "Invalid input provided",
-  NOT_SUPPORTED: "Operation not supported by this provider",
-  NO_RESULTS: "No transcription results available",
-  UNKNOWN_ERROR: "An unknown error occurred"
+// 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"
 };
-function createError(code, customMessage, details) {
-  return {
-    code,
-    message: customMessage || ERROR_MESSAGES[code],
-    details
-  };
-}
 
-// src/adapters/base-adapter.ts
-var BaseAdapter = class {
-  initialize(config) {
-    this.config = config;
-  }
-  /**
-   * Helper method to create error responses with stack traces
-   *
-   * @param error - Error object or unknown error
-   * @param statusCode - Optional HTTP status code
-   * @param code - Optional error code (defaults to extracted or UNKNOWN_ERROR)
-   */
-  createErrorResponse(error, statusCode, code) {
-    const err = error;
-    const httpStatus = statusCode || err.statusCode || err.response?.status;
-    const httpStatusText = err.response?.statusText;
-    const responseData = err.response?.data;
-    return {
-      success: false,
-      provider: this.name,
-      error: {
-        code: code || err.code || ERROR_CODES.UNKNOWN_ERROR,
-        message: err.message || "An unknown error occurred",
-        statusCode: httpStatus,
-        details: {
-          // Include full error object
-          error,
-          // Include stack trace if available
-          stack: err.stack,
-          // Include HTTP response details
-          httpStatus,
-          httpStatusText,
-          responseData,
-          // Include provider name for debugging
-          provider: this.name
-        }
-      }
-    };
-  }
-  /**
-   * Helper method to validate configuration
-   */
-  validateConfig() {
-    if (!this.config) {
-      throw new Error(`Adapter ${this.name} is not initialized. Call initialize() first.`);
-    }
-    if (!this.config.apiKey) {
-      throw new Error(`API key is required for ${this.name} provider`);
-    }
-  }
-  /**
-   * Build axios config for generated API client functions
-   *
-   * @param authHeaderName - Header name for API key (e.g., "Authorization", "x-gladia-key")
-   * @param authHeaderValue - Optional function to format auth header value (defaults to raw API key)
-   * @returns Axios config object
-   */
-  getAxiosConfig(authHeaderName = "Authorization", authHeaderValue) {
-    this.validateConfig();
-    const authValue = authHeaderValue ? authHeaderValue(this.config.apiKey) : this.config.apiKey;
-    return {
-      baseURL: this.config.baseUrl || this.baseUrl,
-      timeout: this.config.timeout || DEFAULT_TIMEOUTS.HTTP_REQUEST,
-      headers: {
-        [authHeaderName]: authValue,
-        "Content-Type": "application/json",
-        ...this.config.headers
-      }
-    };
-  }
-  /**
+// 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/constants.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",
+  aac: "aac",
+  opus: "opus",
+  mp3: "mp3",
+  flac: "flac",
+  mulaw: "mulaw",
+  alaw: "alaw"
+};
+
+// src/generated/deepgram/schema/speakV1ContainerParameter.ts
+var SpeakV1ContainerParameter = {
+  none: "none",
+  wav: "wav",
+  ogg: "ogg"
+};
+
+// src/generated/deepgram/schema/speakV1SampleRateParameter.ts
+var SpeakV1SampleRateParameter = {
+  NUMBER_16000: 16e3,
+  NUMBER_24000: 24e3,
+  NUMBER_32000: 32e3,
+  NUMBER_48000: 48e3,
+  null: null,
+  NUMBER_8000: 8e3,
+  NUMBER_22050: 22050
+};
+
+// src/constants/defaults.ts
+var DEFAULT_TIMEOUTS = {
+  /** Standard HTTP request timeout for API calls (60 seconds) */
+  HTTP_REQUEST: 6e4,
+  /** Audio processing timeout for long audio files (120 seconds) */
+  AUDIO_PROCESSING: 12e4,
+  /** WebSocket connection establishment timeout (10 seconds) */
+  WS_CONNECTION: 1e4,
+  /** WebSocket graceful close timeout (5 seconds) */
+  WS_CLOSE: 5e3
+};
+var DEFAULT_POLLING = {
+  /** Maximum number of polling attempts before timing out */
+  MAX_ATTEMPTS: 60,
+  /** Standard interval between polling attempts (2 seconds) */
+  INTERVAL_MS: 2e3,
+  /** Slower interval for long-running jobs (3 seconds) */
+  SLOW_INTERVAL_MS: 3e3
+};
+
+// src/utils/errors.ts
+var ERROR_CODES = {
+  /** Failed to parse API response or WebSocket message */
+  PARSE_ERROR: "PARSE_ERROR",
+  /** WebSocket connection error */
+  WEBSOCKET_ERROR: "WEBSOCKET_ERROR",
+  /** Async transcription job did not complete within timeout */
+  POLLING_TIMEOUT: "POLLING_TIMEOUT",
+  /** Transcription processing failed on provider side */
+  TRANSCRIPTION_ERROR: "TRANSCRIPTION_ERROR",
+  /** Connection attempt timed out */
+  CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
+  /** Invalid input provided to API */
+  INVALID_INPUT: "INVALID_INPUT",
+  /** Requested operation not supported by provider */
+  NOT_SUPPORTED: "NOT_SUPPORTED",
+  /** No transcription results available */
+  NO_RESULTS: "NO_RESULTS",
+  /** Unspecified or unknown error */
+  UNKNOWN_ERROR: "UNKNOWN_ERROR"
+};
+var ERROR_MESSAGES = {
+  PARSE_ERROR: "Failed to parse response data",
+  WEBSOCKET_ERROR: "WebSocket connection error",
+  POLLING_TIMEOUT: "Transcription did not complete within timeout period",
+  TRANSCRIPTION_ERROR: "Transcription processing failed",
+  CONNECTION_TIMEOUT: "Connection attempt timed out",
+  INVALID_INPUT: "Invalid input provided",
+  NOT_SUPPORTED: "Operation not supported by this provider",
+  NO_RESULTS: "No transcription results available",
+  UNKNOWN_ERROR: "An unknown error occurred"
+};
+function createError(code, customMessage, details) {
+  return {
+    code,
+    message: customMessage || ERROR_MESSAGES[code],
+    details
+  };
+}
+
+// src/adapters/base-adapter.ts
+var BaseAdapter = class {
+  initialize(config) {
+    this.config = config;
+  }
+  /**
+   * Helper method to create error responses with stack traces
+   *
+   * @param error - Error object or unknown error
+   * @param statusCode - Optional HTTP status code
+   * @param code - Optional error code (defaults to extracted or UNKNOWN_ERROR)
+   */
+  createErrorResponse(error, statusCode, code) {
+    const err = error;
+    const httpStatus = statusCode || err.statusCode || err.response?.status;
+    const httpStatusText = err.response?.statusText;
+    const responseData = err.response?.data;
+    return {
+      success: false,
+      provider: this.name,
+      error: {
+        code: code || err.code || ERROR_CODES.UNKNOWN_ERROR,
+        message: err.message || "An unknown error occurred",
+        statusCode: httpStatus,
+        details: {
+          // Include full error object
+          error,
+          // Include stack trace if available
+          stack: err.stack,
+          // Include HTTP response details
+          httpStatus,
+          httpStatusText,
+          responseData,
+          // Include provider name for debugging
+          provider: this.name
+        }
+      }
+    };
+  }
+  /**
+   * Helper method to validate configuration
+   */
+  validateConfig() {
+    if (!this.config) {
+      throw new Error(`Adapter ${this.name} is not initialized. Call initialize() first.`);
+    }
+    if (!this.config.apiKey) {
+      throw new Error(`API key is required for ${this.name} provider`);
+    }
+  }
+  /**
+   * Build axios config for generated API client functions
+   *
+   * @param authHeaderName - Header name for API key (e.g., "Authorization", "x-gladia-key")
+   * @param authHeaderValue - Optional function to format auth header value (defaults to raw API key)
+   * @returns Axios config object
+   */
+  getAxiosConfig(authHeaderName = "Authorization", authHeaderValue) {
+    this.validateConfig();
+    const authValue = authHeaderValue ? authHeaderValue(this.config.apiKey) : this.config.apiKey;
+    return {
+      baseURL: this.config.baseUrl || this.baseUrl,
+      timeout: this.config.timeout || DEFAULT_TIMEOUTS.HTTP_REQUEST,
+      headers: {
+        [authHeaderName]: authValue,
+        "Content-Type": "application/json",
+        ...this.config.headers
+      }
+    };
+  }
+  /**
    * Generic polling helper for async transcription jobs
    *
    * Polls getTranscript() until job completes or times out.
@@ -1120,365 +1415,153 @@ var HistoryControllerGetListV1StatusItem = {
   queued: "queued",
   processing: "processing",
   done: "done",
-  error: "error"
-};
-
-// src/generated/gladia/schema/namedEntityRecognitionMessageType.ts
-var NamedEntityRecognitionMessageType = {
-  named_entity_recognition: "named_entity_recognition"
-};
-
-// src/generated/gladia/schema/postChapterizationMessageType.ts
-var PostChapterizationMessageType = {
-  post_chapterization: "post_chapterization"
-};
-
-// src/generated/gladia/schema/postFinalTranscriptMessageType.ts
-var PostFinalTranscriptMessageType = {
-  post_final_transcript: "post_final_transcript"
-};
-
-// src/generated/gladia/schema/postSummarizationMessageType.ts
-var PostSummarizationMessageType = {
-  post_summarization: "post_summarization"
-};
-
-// src/generated/gladia/schema/postTranscriptMessageType.ts
-var PostTranscriptMessageType = {
-  post_transcript: "post_transcript"
-};
-
-// src/generated/gladia/schema/preRecordedControllerGetPreRecordedJobsV2StatusItem.ts
-var PreRecordedControllerGetPreRecordedJobsV2StatusItem = {
-  queued: "queued",
-  processing: "processing",
-  done: "done",
-  error: "error"
-};
-
-// src/generated/gladia/schema/preRecordedResponseKind.ts
-var PreRecordedResponseKind = {
-  "pre-recorded": "pre-recorded"
-};
-
-// src/generated/gladia/schema/preRecordedResponseStatus.ts
-var PreRecordedResponseStatus = {
-  queued: "queued",
-  processing: "processing",
-  done: "done",
-  error: "error"
-};
-
-// src/generated/gladia/schema/sentimentAnalysisMessageType.ts
-var SentimentAnalysisMessageType = {
-  sentiment_analysis: "sentiment_analysis"
-};
-
-// src/generated/gladia/schema/speechEndMessageType.ts
-var SpeechEndMessageType = {
-  speech_end: "speech_end"
-};
-
-// src/generated/gladia/schema/speechStartMessageType.ts
-var SpeechStartMessageType = {
-  speech_start: "speech_start"
-};
-
-// src/generated/gladia/schema/startRecordingMessageType.ts
-var StartRecordingMessageType = {
-  start_recording: "start_recording"
-};
-
-// src/generated/gladia/schema/startSessionMessageType.ts
-var StartSessionMessageType = {
-  start_session: "start_session"
-};
-
-// src/generated/gladia/schema/stopRecordingAckMessageType.ts
-var StopRecordingAckMessageType = {
-  stop_recording: "stop_recording"
-};
-
-// src/generated/gladia/schema/stopRecordingActionType.ts
-var StopRecordingActionType = {
-  stop_recording: "stop_recording"
-};
-
-// src/generated/gladia/schema/streamingControllerGetStreamingJobsV2StatusItem.ts
-var StreamingControllerGetStreamingJobsV2StatusItem = {
-  queued: "queued",
-  processing: "processing",
-  done: "done",
-  error: "error"
-};
-
-// src/generated/gladia/schema/streamingResponseKind.ts
-var StreamingResponseKind = {
-  live: "live"
-};
-
-// src/generated/gladia/schema/streamingResponseStatus.ts
-var StreamingResponseStatus = {
-  queued: "queued",
-  processing: "processing",
-  done: "done",
-  error: "error"
-};
-
-// src/generated/gladia/schema/streamingSupportedModels.ts
-var StreamingSupportedModels = {
-  "solaria-1": "solaria-1"
+  error: "error"
 };
 
-// src/generated/gladia/schema/streamingSupportedRegions.ts
-var StreamingSupportedRegions = {
-  "us-west": "us-west",
-  "eu-west": "eu-west"
+// src/generated/gladia/schema/namedEntityRecognitionMessageType.ts
+var NamedEntityRecognitionMessageType = {
+  named_entity_recognition: "named_entity_recognition"
 };
 
-// src/generated/gladia/schema/subtitlesFormatEnum.ts
-var SubtitlesFormatEnum = {
-  srt: "srt",
-  vtt: "vtt"
+// src/generated/gladia/schema/postChapterizationMessageType.ts
+var PostChapterizationMessageType = {
+  post_chapterization: "post_chapterization"
 };
 
-// src/generated/gladia/schema/subtitlesStyleEnum.ts
-var SubtitlesStyleEnum = {
-  default: "default",
-  compliance: "compliance"
+// src/generated/gladia/schema/postFinalTranscriptMessageType.ts
+var PostFinalTranscriptMessageType = {
+  post_final_transcript: "post_final_transcript"
 };
 
-// src/generated/gladia/schema/summaryTypesEnum.ts
-var SummaryTypesEnum = {
-  general: "general",
-  bullet_points: "bullet_points",
-  concise: "concise"
+// src/generated/gladia/schema/postSummarizationMessageType.ts
+var PostSummarizationMessageType = {
+  post_summarization: "post_summarization"
 };
 
-// src/generated/gladia/schema/transcriptionControllerListV2KindItem.ts
-var TranscriptionControllerListV2KindItem = {
-  "pre-recorded": "pre-recorded",
-  live: "live"
+// src/generated/gladia/schema/postTranscriptMessageType.ts
+var PostTranscriptMessageType = {
+  post_transcript: "post_transcript"
 };
 
-// src/generated/gladia/schema/transcriptionControllerListV2StatusItem.ts
-var TranscriptionControllerListV2StatusItem = {
+// src/generated/gladia/schema/preRecordedControllerGetPreRecordedJobsV2StatusItem.ts
+var PreRecordedControllerGetPreRecordedJobsV2StatusItem = {
   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/preRecordedResponseKind.ts
+var PreRecordedResponseKind = {
+  "pre-recorded": "pre-recorded"
 };
 
-// src/generated/gladia/schema/transcriptMessageType.ts
-var TranscriptMessageType = {
-  transcript: "transcript"
+// src/generated/gladia/schema/preRecordedResponseStatus.ts
+var PreRecordedResponseStatus = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
 };
 
-// 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/sentimentAnalysisMessageType.ts
+var SentimentAnalysisMessageType = {
+  sentiment_analysis: "sentiment_analysis"
+};
+
+// src/generated/gladia/schema/speechEndMessageType.ts
+var SpeechEndMessageType = {
+  speech_end: "speech_end"
+};
+
+// src/generated/gladia/schema/speechStartMessageType.ts
+var SpeechStartMessageType = {
+  speech_start: "speech_start"
+};
+
+// src/generated/gladia/schema/startRecordingMessageType.ts
+var StartRecordingMessageType = {
+  start_recording: "start_recording"
+};
+
+// src/generated/gladia/schema/startSessionMessageType.ts
+var StartSessionMessageType = {
+  start_session: "start_session"
+};
+
+// src/generated/gladia/schema/stopRecordingAckMessageType.ts
+var StopRecordingAckMessageType = {
+  stop_recording: "stop_recording"
+};
+
+// src/generated/gladia/schema/stopRecordingActionType.ts
+var StopRecordingActionType = {
+  stop_recording: "stop_recording"
+};
+
+// src/generated/gladia/schema/streamingControllerGetStreamingJobsV2StatusItem.ts
+var StreamingControllerGetStreamingJobsV2StatusItem = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/streamingResponseKind.ts
+var StreamingResponseKind = {
+  live: "live"
+};
+
+// src/generated/gladia/schema/streamingResponseStatus.ts
+var StreamingResponseStatus = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/streamingSupportedRegions.ts
+var StreamingSupportedRegions = {
+  "us-west": "us-west",
+  "eu-west": "eu-west"
+};
+
+// src/generated/gladia/schema/subtitlesFormatEnum.ts
+var SubtitlesFormatEnum = {
+  srt: "srt",
+  vtt: "vtt"
+};
+
+// src/generated/gladia/schema/subtitlesStyleEnum.ts
+var SubtitlesStyleEnum = {
+  default: "default",
+  compliance: "compliance"
+};
+
+// src/generated/gladia/schema/summaryTypesEnum.ts
+var SummaryTypesEnum = {
+  general: "general",
+  bullet_points: "bullet_points",
+  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/transcriptMessageType.ts
+var TranscriptMessageType = {
+  transcript: "transcript"
 };
 
 // src/generated/gladia/schema/translationMessageType.ts
@@ -2124,11 +2207,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',
@@ -2150,36 +2268,57 @@ 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();
-    let validatedSampleRate;
-    if (options?.sampleRate) {
-      validatedSampleRate = validateEnumValue(
-        options.sampleRate,
-        StreamingSupportedSampleRateEnum,
-        "sample rate",
-        "Gladia"
-      );
-    }
-    const streamingRequest = {
-      encoding: options?.encoding ? mapEncodingToProvider(options.encoding, "gladia") : void 0,
-      sample_rate: validatedSampleRate,
-      channels: options?.channels,
-      endpointing: options?.endpointing,
-      model: options?.model
-    };
-    if (options?.language) {
-      streamingRequest.language_config = {
-        languages: [options.language]
-      };
-    }
+    const streamingRequest = this.buildStreamingRequest(options);
     const initResponse = await streamingControllerInitStreamingSessionV2(
       streamingRequest,
       void 0,
@@ -2195,44 +2334,7 @@ var GladiaAdapter = class extends BaseAdapter {
     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((w) => ({
-              word: w.word,
-              start: w.start,
-              end: w.end,
-              confidence: w.confidence
-            })),
-            data: message
-          });
-        } 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((w) => ({
-              word: w.word,
-              start: w.start,
-              end: w.end,
-              confidence: w.confidence
-            }))
-          };
-          callbacks?.onUtterance?.(utteranceData);
-        } else if (message.type === "metadata") {
-          callbacks?.onMetadata?.(message);
-        }
+        this.handleWebSocketMessage(message, callbacks);
       } catch (error) {
         callbacks?.onError?.({
           code: ERROR_CODES.PARSE_ERROR,
@@ -2240,40 +2342,429 @@ var GladiaAdapter = class extends BaseAdapter {
           details: error
         });
       }
-    });
-    await waitForWebSocketOpen(ws);
-    return {
-      id,
-      provider: this.name,
-      createdAt: /* @__PURE__ */ new Date(),
-      getStatus: () => sessionStatus,
-      sendAudio: async (chunk) => {
-        validateSessionForAudio(sessionStatus, ws.readyState, import_ws.default.OPEN);
-        ws.send(chunk.data);
-        if (chunk.isLast) {
-          ws.send(
-            JSON.stringify({
-              type: "stop_recording"
-            })
-          );
+    });
+    await waitForWebSocketOpen(ws);
+    return {
+      id,
+      provider: this.name,
+      createdAt: /* @__PURE__ */ new Date(),
+      getStatus: () => sessionStatus,
+      sendAudio: async (chunk) => {
+        validateSessionForAudio(sessionStatus, ws.readyState, import_ws.default.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 === import_ws.default.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(
+        options.sampleRate,
+        StreamingSupportedSampleRateEnum,
+        "sample rate",
+        "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,
+      // 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 || options?.codeSwitching || gladiaOpts.language_config) {
+      streamingRequest.language_config = {
+        ...gladiaOpts.language_config,
+        languages: options?.language ? [options.language] : gladiaOpts.language_config?.languages,
+        code_switching: options?.codeSwitching ?? gladiaOpts.language_config?.code_switching
+      };
+    }
+    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 (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);
+          }
+        }
+        break;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // 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
+          });
+        }
+        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
+            }))
+          });
         }
-      },
-      close: async () => {
-        if (sessionStatus === "closed" || sessionStatus === "closing") {
-          return;
+        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);
         }
-        sessionStatus = "closing";
-        if (ws.readyState === import_ws.default.OPEN) {
-          ws.send(
-            JSON.stringify({
-              type: "stop_recording"
-            })
-          );
+        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
+          });
         }
-        await closeWebSocket(ws);
-        sessionStatus = "closed";
+        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) {
@@ -2968,19 +3459,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) => {
@@ -2995,21 +3504,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 import_ws2.default(wsUrl, {
       headers: {
         Authorization: this.config.apiKey
@@ -3033,43 +3571,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((w) => ({
-              word: w.text,
-              start: w.start / 1e3,
-              // Convert ms to seconds
-              end: w.end / 1e3,
-              confidence: w.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",
@@ -3121,11 +3623,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 () => {
@@ -3135,11 +3633,7 @@ var AssemblyAIAdapter = class extends BaseAdapter {
         sessionStatus = "closing";
         flushAudioBuffer();
         if (ws.readyState === import_ws2.default.OPEN) {
-          ws.send(
-            JSON.stringify({
-              terminate_session: true
-            })
-          );
+          ws.send(JSON.stringify({ type: "Terminate" }));
         }
         return new Promise((resolve) => {
           const timeout = setTimeout(() => {
@@ -3153,9 +3647,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 !== import_ws2.default.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 !== import_ws2.default.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();
@@ -3464,11 +4115,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',
@@ -3491,32 +4175,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 import_ws3.default(wsUrl, {
       headers: {
         Authorization: `Token ${this.config.apiKey}`
@@ -3531,31 +4230,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((w) => ({
-              word: w.word,
-              start: w.start,
-              end: w.end,
-              confidence: w.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",
@@ -3628,6 +4303,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();
@@ -5464,6 +6343,9 @@ function createWebhookRouter() {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssemblyAIAdapter,
+  AssemblyAIEncoding,
+  AssemblyAISampleRate,
+  AssemblyAISpeechModel,
   AssemblyAITypes,
   AssemblyAIWebhookHandler,
   AzureSTTAdapter,
@@ -5471,8 +6353,18 @@ function createWebhookRouter() {
   BaseAdapter,
   BaseWebhookHandler,
   DeepgramAdapter,
+  DeepgramEncoding,
+  DeepgramModel,
+  DeepgramRedact,
+  DeepgramTopicMode,
   DeepgramWebhookHandler,
   GladiaAdapter,
+  GladiaBitDepth,
+  GladiaEncoding,
+  GladiaLanguage,
+  GladiaModel,
+  GladiaSampleRate,
+  GladiaTranslationLanguage,
   GladiaTypes,
   GladiaWebhookHandler,
   ListenV1EncodingParameter,