voice-router-dev 0.1.7 → 0.1.9

package/dist/index.mjs

@@ -210,24 +210,165 @@ function createVoiceRouter(config, adapters) {
   return router;
 }
 
+// src/generated/deepgram/schema/listenV1EncodingParameter.ts
+var ListenV1EncodingParameter = {
+  linear16: "linear16",
+  flac: "flac",
+  mulaw: "mulaw",
+  opus: "opus",
+  speex: "speex",
+  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/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/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) */
+  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
+   * 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) {
+  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: err.code || "UNKNOWN_ERROR",
+        code: code || err.code || ERROR_CODES.UNKNOWN_ERROR,
         message: err.message || "An unknown error occurred",
-        statusCode: statusCode || err.statusCode,
-        details: error
+        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
+        }
       }
     };
   }
@@ -242,6 +383,64 @@ var BaseAdapter = class {
       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.
+   *
+   * @param transcriptId - Job/transcript ID to poll
+   * @param options - Polling configuration
+   * @returns Final transcription result
+   */
+  async pollForCompletion(transcriptId, options) {
+    const { maxAttempts = DEFAULT_POLLING.MAX_ATTEMPTS, intervalMs = DEFAULT_POLLING.INTERVAL_MS } = options || {};
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.getTranscript(transcriptId);
+      if (!result.success) {
+        return result;
+      }
+      const status = result.data?.status;
+      if (status === "completed") {
+        return result;
+      }
+      if (status === "error") {
+        return this.createErrorResponse(
+          new Error("Transcription failed"),
+          void 0,
+          ERROR_CODES.TRANSCRIPTION_ERROR
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return {
+      success: false,
+      provider: this.name,
+      error: {
+        code: ERROR_CODES.POLLING_TIMEOUT,
+        message: `Transcription did not complete after ${maxAttempts} attempts`
+      }
+    };
+  }
 };
 
 // src/adapters/gladia-adapter.ts
@@ -288,6 +487,143 @@ function mapEncodingToProvider(unifiedEncoding, provider) {
   return providerEncoding;
 }
 
+// src/utils/websocket-helpers.ts
+function waitForWebSocketOpen(ws, timeoutMs = DEFAULT_TIMEOUTS.WS_CONNECTION) {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("WebSocket connection timeout"));
+    }, timeoutMs);
+    ws.once("open", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    ws.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+  });
+}
+function closeWebSocket(ws, timeoutMs = DEFAULT_TIMEOUTS.WS_CLOSE) {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      ws.terminate();
+      resolve();
+    }, timeoutMs);
+    ws.close();
+    ws.once("close", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+function setupWebSocketHandlers(ws, callbacks, setSessionStatus) {
+  ws.on("open", () => {
+    setSessionStatus("open");
+    callbacks?.onOpen?.();
+  });
+  ws.on("error", (error) => {
+    callbacks?.onError?.(createError(ERROR_CODES.WEBSOCKET_ERROR, error.message, error));
+  });
+  ws.on("close", (code, reason) => {
+    setSessionStatus("closed");
+    callbacks?.onClose?.(code, reason.toString());
+  });
+}
+function validateSessionForAudio(sessionStatus, wsReadyState, WebSocketOpen) {
+  if (sessionStatus !== "open") {
+    throw new Error(`Cannot send audio: session is ${sessionStatus}`);
+  }
+  if (wsReadyState !== WebSocketOpen) {
+    throw new Error("WebSocket is not open");
+  }
+}
+
+// src/utils/validation.ts
+function validateEnumValue(value, enumType, fieldName, provider) {
+  const validValues = Object.values(enumType);
+  const isValid = validValues.some((v) => v === value);
+  if (!isValid) {
+    throw new Error(
+      `${provider} does not support ${fieldName} '${value}'. Supported values (from OpenAPI spec): ${validValues.join(", ")}`
+    );
+  }
+  return value;
+}
+
+// src/utils/transcription-helpers.ts
+function extractSpeakersFromUtterances(utterances, getSpeakerId, formatLabel) {
+  if (!utterances || utterances.length === 0) {
+    return void 0;
+  }
+  const speakerSet = /* @__PURE__ */ new Set();
+  utterances.forEach((utterance) => {
+    const speakerId = getSpeakerId(utterance);
+    if (speakerId !== void 0) {
+      speakerSet.add(String(speakerId));
+    }
+  });
+  if (speakerSet.size === 0) {
+    return void 0;
+  }
+  return Array.from(speakerSet).map((speakerId) => ({
+    id: speakerId,
+    label: formatLabel ? formatLabel(speakerId) : `Speaker ${speakerId}`
+  }));
+}
+function extractWords(words, mapper) {
+  if (!words || words.length === 0) {
+    return void 0;
+  }
+  const normalizedWords = words.map(mapper);
+  return normalizedWords.length > 0 ? normalizedWords : void 0;
+}
+var STATUS_MAPPINGS = {
+  gladia: {
+    queued: "queued",
+    processing: "processing",
+    done: "completed",
+    error: "error"
+  },
+  assemblyai: {
+    queued: "queued",
+    processing: "processing",
+    completed: "completed",
+    error: "error"
+  },
+  deepgram: {
+    queued: "queued",
+    processing: "processing",
+    completed: "completed",
+    error: "error"
+  },
+  azure: {
+    succeeded: "completed",
+    running: "processing",
+    notstarted: "queued",
+    failed: "error"
+  },
+  speechmatics: {
+    running: "processing",
+    done: "completed",
+    rejected: "error",
+    expired: "error"
+  }
+};
+function normalizeStatus(providerStatus, provider, defaultStatus = "queued") {
+  if (!providerStatus) return defaultStatus;
+  const mapping = STATUS_MAPPINGS[provider];
+  const statusKey = providerStatus.toString().toLowerCase();
+  if (statusKey in mapping) {
+    return mapping[statusKey];
+  }
+  for (const [key, value] of Object.entries(mapping)) {
+    if (statusKey.includes(key)) {
+      return value;
+    }
+  }
+  return defaultStatus;
+}
+
 // src/generated/gladia/api/gladiaControlAPI.ts
 import axios from "axios";
 
@@ -824,21 +1160,6 @@ var StreamingResponseStatus = {
   error: "error"
 };
 
-// src/generated/gladia/schema/streamingSupportedBitDepthEnum.ts
-var StreamingSupportedBitDepthEnum = {
-  NUMBER_8: 8,
-  NUMBER_16: 16,
-  NUMBER_24: 24,
-  NUMBER_32: 32
-};
-
-// src/generated/gladia/schema/streamingSupportedEncodingEnum.ts
-var StreamingSupportedEncodingEnum = {
-  "wav/pcm": "wav/pcm",
-  "wav/alaw": "wav/alaw",
-  "wav/ulaw": "wav/ulaw"
-};
-
 // src/generated/gladia/schema/streamingSupportedModels.ts
 var StreamingSupportedModels = {
   "solaria-1": "solaria-1"
@@ -850,15 +1171,6 @@ var StreamingSupportedRegions = {
   "eu-west": "eu-west"
 };
 
-// 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/subtitlesFormatEnum.ts
 var SubtitlesFormatEnum = {
   srt: "srt",
@@ -1408,21 +1720,10 @@ var GladiaAdapter = class extends BaseAdapter {
   }
   /**
    * Get axios config for generated API client functions
-   * Configures headers and base URL
+   * Configures headers and base URL using Gladia's x-gladia-key header
    */
   getAxiosConfig() {
-    if (!this.config) {
-      throw new Error("Adapter not initialized. Call initialize() first.");
-    }
-    return {
-      baseURL: this.config.baseUrl || this.baseUrl,
-      timeout: this.config.timeout || 6e4,
-      headers: {
-        "x-gladia-key": this.config.apiKey,
-        "Content-Type": "application/json",
-        ...this.config.headers
-      }
-    };
+    return super.getAxiosConfig("x-gladia-key");
   }
   /**
    * Submit audio for transcription
@@ -1589,29 +1890,13 @@ var GladiaAdapter = class extends BaseAdapter {
    * Normalize Gladia response to unified format
    */
   normalizeResponse(response) {
-    let status;
-    switch (response.status) {
-      case "queued":
-        status = "queued";
-        break;
-      case "processing":
-        status = "processing";
-        break;
-      case "done":
-        status = "completed";
-        break;
-      case "error":
-        status = "error";
-        break;
-      default:
-        status = "queued";
-    }
+    const status = normalizeStatus(response.status, "gladia");
     if (response.status === "error") {
       return {
         success: false,
         provider: this.name,
         error: {
-          code: response.error_code?.toString() || "TRANSCRIPTION_ERROR",
+          code: response.error_code?.toString() || ERROR_CODES.TRANSCRIPTION_ERROR,
           message: "Transcription failed",
           statusCode: response.error_code || void 0
         },
@@ -1651,22 +1936,11 @@ var GladiaAdapter = class extends BaseAdapter {
    * Extract speaker information from Gladia response
    */
   extractSpeakers(transcription) {
-    if (!transcription?.utterances) {
-      return void 0;
-    }
-    const speakerSet = /* @__PURE__ */ new Set();
-    transcription.utterances.forEach((utterance) => {
-      if (utterance.speaker !== void 0) {
-        speakerSet.add(utterance.speaker);
-      }
-    });
-    if (speakerSet.size === 0) {
-      return void 0;
-    }
-    return Array.from(speakerSet).map((speakerId) => ({
-      id: speakerId.toString(),
-      label: `Speaker ${speakerId}`
-    }));
+    return extractSpeakersFromUtterances(
+      transcription?.utterances,
+      (utterance) => utterance.speaker,
+      (id) => `Speaker ${id}`
+    );
   }
   /**
    * Extract word timestamps from Gladia response
@@ -1677,14 +1951,17 @@ var GladiaAdapter = class extends BaseAdapter {
     }
     const allWords = transcription.utterances.flatMap(
       (utterance) => utterance.words.map((word) => ({
-        text: word.word,
-        start: word.start,
-        end: word.end,
-        confidence: word.confidence,
-        speaker: utterance.speaker?.toString()
+        word,
+        speaker: utterance.speaker
       }))
     );
-    return allWords.length > 0 ? allWords : void 0;
+    return extractWords(allWords, (item) => ({
+      text: item.word.word,
+      start: item.word.start,
+      end: item.word.end,
+      confidence: item.word.confidence,
+      speaker: item.speaker?.toString()
+    }));
   }
   /**
    * Extract utterances from Gladia response
@@ -1710,38 +1987,6 @@ var GladiaAdapter = class extends BaseAdapter {
   /**
    * Poll for transcription completion
    */
-  async pollForCompletion(jobId, maxAttempts = 60, intervalMs = 2e3) {
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const result = await this.getTranscript(jobId);
-      if (!result.success) {
-        return result;
-      }
-      const status = result.data?.status;
-      if (status === "completed") {
-        return result;
-      }
-      if (status === "error") {
-        return {
-          success: false,
-          provider: this.name,
-          error: {
-            code: "TRANSCRIPTION_ERROR",
-            message: "Transcription failed"
-          },
-          raw: result.raw
-        };
-      }
-      await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-    return {
-      success: false,
-      provider: this.name,
-      error: {
-        code: "POLLING_TIMEOUT",
-        message: `Transcription did not complete after ${maxAttempts} attempts`
-      }
-    };
-  }
   /**
    * Stream audio for real-time transcription
    *
@@ -1785,14 +2030,12 @@ var GladiaAdapter = class extends BaseAdapter {
     this.validateConfig();
     let validatedSampleRate;
     if (options?.sampleRate) {
-      const validRates = Object.values(StreamingSupportedSampleRateEnum);
-      const isValidRate = validRates.some((rate) => rate === options.sampleRate);
-      if (!isValidRate) {
-        throw new Error(
-          `Gladia does not support sample rate ${options.sampleRate} Hz. Supported rates (from OpenAPI spec): ${validRates.join(", ")} Hz`
-        );
-      }
-      validatedSampleRate = options.sampleRate;
+      validatedSampleRate = validateEnumValue(
+        options.sampleRate,
+        StreamingSupportedSampleRateEnum,
+        "sample rate",
+        "Gladia"
+      );
     }
     const streamingRequest = {
       encoding: options?.encoding ? mapEncodingToProvider(options.encoding, "gladia") : void 0,
@@ -1814,9 +2057,8 @@ var GladiaAdapter = class extends BaseAdapter {
     const { id, url: wsUrl } = initResponse.data;
     const ws = new WebSocket(wsUrl);
     let sessionStatus = "connecting";
-    ws.on("open", () => {
-      sessionStatus = "open";
-      callbacks?.onOpen?.();
+    setupWebSocketHandlers(ws, callbacks, (status) => {
+      sessionStatus = status;
     });
     ws.on("message", (data) => {
       try {
@@ -1861,48 +2103,20 @@ var GladiaAdapter = class extends BaseAdapter {
         }
       } catch (error) {
         callbacks?.onError?.({
-          code: "PARSE_ERROR",
+          code: ERROR_CODES.PARSE_ERROR,
           message: "Failed to parse WebSocket message",
           details: error
         });
       }
     });
-    ws.on("error", (error) => {
-      callbacks?.onError?.({
-        code: "WEBSOCKET_ERROR",
-        message: error.message,
-        details: error
-      });
-    });
-    ws.on("close", (code, reason) => {
-      sessionStatus = "closed";
-      callbacks?.onClose?.(code, reason.toString());
-    });
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("WebSocket connection timeout"));
-      }, 1e4);
-      ws.once("open", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-      ws.once("error", (error) => {
-        clearTimeout(timeout);
-        reject(error);
-      });
-    });
+    await waitForWebSocketOpen(ws);
     return {
       id,
       provider: this.name,
       createdAt: /* @__PURE__ */ new Date(),
       getStatus: () => sessionStatus,
       sendAudio: async (chunk) => {
-        if (sessionStatus !== "open") {
-          throw new Error(`Cannot send audio: session is ${sessionStatus}`);
-        }
-        if (ws.readyState !== WebSocket.OPEN) {
-          throw new Error("WebSocket is not open");
-        }
+        validateSessionForAudio(sessionStatus, ws.readyState, WebSocket.OPEN);
         ws.send(chunk.data);
         if (chunk.isLast) {
           ws.send(
@@ -1924,18 +2138,8 @@ var GladiaAdapter = class extends BaseAdapter {
             })
           );
         }
-        return new Promise((resolve) => {
-          const timeout = setTimeout(() => {
-            ws.terminate();
-            resolve();
-          }, 5e3);
-          ws.close();
-          ws.once("close", () => {
-            clearTimeout(timeout);
-            sessionStatus = "closed";
-            resolve();
-          });
-        });
+        await closeWebSocket(ws);
+        sessionStatus = "closed";
       }
     };
   }
@@ -2269,9 +2473,6 @@ var createTranscript = (transcriptParams, options) => {
 var getTranscript = (transcriptId, options) => {
   return axios2.get(`/v2/transcript/${transcriptId}`, options);
 };
-var createTemporaryToken = (createRealtimeTemporaryTokenParams, options) => {
-  return axios2.post("/v2/realtime/token", createRealtimeTemporaryTokenParams, options);
-};
 
 // src/adapters/assemblyai-adapter.ts
 var AssemblyAIAdapter = class extends BaseAdapter {
@@ -2289,26 +2490,17 @@ var AssemblyAIAdapter = class extends BaseAdapter {
       entityDetection: true,
       piiRedaction: true
     };
-    this.baseUrl = "https://api.assemblyai.com/v2";
-    this.wsBaseUrl = "wss://api.assemblyai.com/v2/realtime/ws";
+    this.baseUrl = "https://api.assemblyai.com";
+    // Generated functions already include /v2 path
+    this.wsBaseUrl = "wss://streaming.assemblyai.com/v3/ws";
   }
+  // v3 Universal Streaming endpoint
   /**
    * Get axios config for generated API client functions
-   * Configures headers and base URL
+   * Configures headers and base URL using authorization header
    */
   getAxiosConfig() {
-    if (!this.config) {
-      throw new Error("Adapter not initialized. Call initialize() first.");
-    }
-    return {
-      baseURL: this.config.baseUrl || this.baseUrl,
-      timeout: this.config.timeout || 6e4,
-      headers: {
-        authorization: this.config.apiKey,
-        "Content-Type": "application/json",
-        ...this.config.headers
-      }
-    };
+    return super.getAxiosConfig("authorization");
   }
   /**
    * Submit audio for transcription
@@ -2586,41 +2778,6 @@ var AssemblyAIAdapter = class extends BaseAdapter {
       }))
     }));
   }
-  /**
-   * Poll for transcription completion
-   */
-  async pollForCompletion(transcriptId, maxAttempts = 60, intervalMs = 3e3) {
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const result = await this.getTranscript(transcriptId);
-      if (!result.success) {
-        return result;
-      }
-      const status = result.data?.status;
-      if (status === "completed") {
-        return result;
-      }
-      if (status === "error") {
-        return {
-          success: false,
-          provider: this.name,
-          error: {
-            code: "TRANSCRIPTION_ERROR",
-            message: "Transcription failed"
-          },
-          raw: result.raw
-        };
-      }
-      await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-    return {
-      success: false,
-      provider: this.name,
-      error: {
-        code: "POLLING_TIMEOUT",
-        message: `Transcription did not complete after ${maxAttempts} attempts`
-      }
-    };
-  }
   /**
    * Stream audio for real-time transcription
    *
@@ -2661,14 +2818,17 @@ var AssemblyAIAdapter = class extends BaseAdapter {
    */
   async transcribeStream(options, callbacks) {
     this.validateConfig();
-    const tokenResponse = await createTemporaryToken(
-      { expires_in: 3600 },
-      // Token expires in 1 hour
-      this.getAxiosConfig()
-    );
-    const token = tokenResponse.data.token;
-    const wsUrl = `${this.wsBaseUrl}?sample_rate=${options?.sampleRate || 16e3}&token=${token}`;
-    const ws = new WebSocket2(wsUrl);
+    if (!this.config?.apiKey) {
+      throw new Error("API key is required for streaming");
+    }
+    const sampleRate = options?.sampleRate || 16e3;
+    const encoding = options?.encoding || "pcm_s16le";
+    const wsUrl = `${this.wsBaseUrl}?sample_rate=${sampleRate}&encoding=${encoding}`;
+    const ws = new WebSocket2(wsUrl, {
+      headers: {
+        Authorization: this.config.apiKey
+      }
+    });
     let sessionStatus = "connecting";
     const sessionId = `assemblyai-${Date.now()}-${Math.random().toString(36).substring(7)}`;
     ws.on("open", () => {
@@ -2678,41 +2838,42 @@ var AssemblyAIAdapter = class extends BaseAdapter {
     ws.on("message", (data) => {
       try {
         const message = JSON.parse(data.toString());
-        if (message.message_type === "SessionBegins") {
+        if ("error" in message) {
+          callbacks?.onError?.({
+            code: "API_ERROR",
+            message: message.error
+          });
+          return;
+        }
+        if (message.type === "Begin") {
+          const beginMsg = message;
           callbacks?.onMetadata?.({
-            sessionId: message.session_id,
-            expiresAt: message.expires_at
+            sessionId: beginMsg.id,
+            expiresAt: new Date(beginMsg.expires_at).toISOString()
           });
-        } else if (message.message_type === "PartialTranscript") {
+        } else if (message.type === "Turn") {
+          const turnMsg = message;
           callbacks?.onTranscript?.({
             type: "transcript",
-            text: message.text,
-            isFinal: false,
-            confidence: message.confidence,
-            words: message.words.map((word) => ({
+            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: message
+            data: turnMsg
           });
-        } else if (message.message_type === "FinalTranscript") {
-          callbacks?.onTranscript?.({
-            type: "transcript",
-            text: message.text,
-            isFinal: true,
-            confidence: message.confidence,
-            words: message.words.map((word) => ({
-              text: word.text,
-              start: word.start / 1e3,
-              end: word.end / 1e3,
-              confidence: word.confidence
-            })),
-            data: message
+        } else if (message.type === "Termination") {
+          const termMsg = message;
+          callbacks?.onMetadata?.({
+            terminated: true,
+            audioDurationSeconds: termMsg.audio_duration_seconds,
+            sessionDurationSeconds: termMsg.session_duration_seconds
           });
-        } else if (message.message_type === "SessionTerminated") {
-          callbacks?.onMetadata?.({ terminated: true });
         }
       } catch (error) {
         callbacks?.onError?.({
@@ -3262,7 +3423,24 @@ function createDeepgramAdapter(config) {
 }
 
 // src/adapters/azure-stt-adapter.ts
+import axios5 from "axios";
+
+// src/generated/azure/api/speechServicesAPIV31.ts
 import axios4 from "axios";
+var transcriptionsCreate = (transcription, options) => {
+  return axios4.post("/transcriptions", transcription, options);
+};
+var transcriptionsGet = (id, options) => {
+  return axios4.get(`/transcriptions/${id}`, options);
+};
+var transcriptionsListFiles = (id, params, options) => {
+  return axios4.get(`/transcriptions/${id}/files`, {
+    ...options,
+    params: { ...params, ...options?.params }
+  });
+};
+
+// src/adapters/azure-stt-adapter.ts
 var AzureSTTAdapter = class extends BaseAdapter {
   constructor() {
     super(...arguments);
@@ -3279,20 +3457,20 @@ var AzureSTTAdapter = class extends BaseAdapter {
       entityDetection: false,
       piiRedaction: false
     };
+    this.baseUrl = "https://eastus.api.cognitive.microsoft.com/speechtotext/v3.1";
   }
+  // Default, overridden in initialize()
   initialize(config) {
     super.initialize(config);
     this.region = config.region || "eastus";
     this.baseUrl = config.baseUrl || `https://${this.region}.api.cognitive.microsoft.com/speechtotext/v3.1`;
-    this.client = axios4.create({
-      baseURL: this.baseUrl,
-      timeout: config.timeout || 6e4,
-      headers: {
-        "Ocp-Apim-Subscription-Key": config.apiKey,
-        "Content-Type": "application/json",
-        ...config.headers
-      }
-    });
+  }
+  /**
+   * Get axios config for generated API client functions
+   * Configures headers and base URL using Azure subscription key
+   */
+  getAxiosConfig() {
+    return super.getAxiosConfig("Ocp-Apim-Subscription-Key");
   }
   /**
    * Submit audio for transcription
@@ -3324,9 +3502,9 @@ var AzureSTTAdapter = class extends BaseAdapter {
         contentUrls: [audio.url],
         properties: this.buildTranscriptionProperties(options)
       };
-      const response = await this.client.post(
-        "/transcriptions",
-        transcriptionRequest
+      const response = await transcriptionsCreate(
+        transcriptionRequest,
+        this.getAxiosConfig()
       );
       const transcription = response.data;
       return {
@@ -3357,9 +3535,7 @@ var AzureSTTAdapter = class extends BaseAdapter {
   async getTranscript(transcriptId) {
     this.validateConfig();
     try {
-      const statusResponse = await this.client.get(
-        `/transcriptions/${transcriptId}`
-      );
+      const statusResponse = await transcriptionsGet(transcriptId, this.getAxiosConfig());
       const transcription = statusResponse.data;
       const status = this.normalizeStatus(transcription.status);
       if (status !== "completed") {
@@ -3387,7 +3563,11 @@ var AzureSTTAdapter = class extends BaseAdapter {
           raw: transcription
         };
       }
-      const filesResponse = await this.client.get(transcription.links.files);
+      const filesResponse = await transcriptionsListFiles(
+        transcriptId,
+        void 0,
+        this.getAxiosConfig()
+      );
       const files = filesResponse.data?.values || [];
       const resultFile = files.find((file) => file.kind === "Transcription");
       if (!resultFile?.links?.contentUrl) {
@@ -3401,7 +3581,7 @@ var AzureSTTAdapter = class extends BaseAdapter {
           raw: transcription
         };
       }
-      const contentResponse = await axios4.get(resultFile.links.contentUrl);
+      const contentResponse = await axios5.get(resultFile.links.contentUrl);
       const transcriptionData = contentResponse.data;
       return this.normalizeResponse(transcription, transcriptionData);
     } catch (error) {
@@ -3500,7 +3680,57 @@ function createAzureSTTAdapter(config) {
 }
 
 // src/adapters/openai-whisper-adapter.ts
-import axios5 from "axios";
+import axios7 from "axios";
+
+// src/generated/openai/api/openAIAPI.ts
+import axios6 from "axios";
+var createTranscription = (createTranscriptionRequest, options) => {
+  const formData = new FormData();
+  formData.append("file", createTranscriptionRequest.file);
+  formData.append("model", createTranscriptionRequest.model);
+  if (createTranscriptionRequest.language !== void 0) {
+    formData.append("language", createTranscriptionRequest.language);
+  }
+  if (createTranscriptionRequest.prompt !== void 0) {
+    formData.append("prompt", createTranscriptionRequest.prompt);
+  }
+  if (createTranscriptionRequest.response_format !== void 0) {
+    formData.append("response_format", createTranscriptionRequest.response_format);
+  }
+  if (createTranscriptionRequest.temperature !== void 0) {
+    formData.append("temperature", createTranscriptionRequest.temperature.toString());
+  }
+  if (createTranscriptionRequest.include !== void 0) {
+    createTranscriptionRequest.include.forEach((value) => formData.append("include", value));
+  }
+  if (createTranscriptionRequest.timestamp_granularities !== void 0) {
+    createTranscriptionRequest.timestamp_granularities.forEach(
+      (value) => formData.append("timestamp_granularities", value)
+    );
+  }
+  if (createTranscriptionRequest.stream !== void 0 && createTranscriptionRequest.stream !== null) {
+    formData.append("stream", createTranscriptionRequest.stream.toString());
+  }
+  if (createTranscriptionRequest.chunking_strategy !== void 0 && createTranscriptionRequest.chunking_strategy !== null) {
+    formData.append(
+      "chunking_strategy",
+      typeof createTranscriptionRequest.chunking_strategy === "object" ? JSON.stringify(createTranscriptionRequest.chunking_strategy) : createTranscriptionRequest.chunking_strategy
+    );
+  }
+  if (createTranscriptionRequest.known_speaker_names !== void 0) {
+    createTranscriptionRequest.known_speaker_names.forEach(
+      (value) => formData.append("known_speaker_names", value)
+    );
+  }
+  if (createTranscriptionRequest.known_speaker_references !== void 0) {
+    createTranscriptionRequest.known_speaker_references.forEach(
+      (value) => formData.append("known_speaker_references", value)
+    );
+  }
+  return axios6.post("/audio/transcriptions", formData, options);
+};
+
+// src/adapters/openai-whisper-adapter.ts
 var OpenAIWhisperAdapter = class extends BaseAdapter {
   constructor() {
     super(...arguments);
@@ -3522,19 +3752,12 @@ var OpenAIWhisperAdapter = class extends BaseAdapter {
     };
     this.baseUrl = "https://api.openai.com/v1";
   }
-  initialize(config) {
-    super.initialize(config);
-    this.baseUrl = config.baseUrl || this.baseUrl;
-    this.client = axios5.create({
-      baseURL: this.baseUrl,
-      timeout: config.timeout || 12e4,
-      // 2 minutes default (audio processing can take time)
-      headers: {
-        Authorization: `Bearer ${config.apiKey}`,
-        "Content-Type": "multipart/form-data",
-        ...config.headers
-      }
-    });
+  /**
+   * Get axios config for generated API client functions
+   * Configures headers and base URL using Bearer token authorization
+   */
+  getAxiosConfig() {
+    return super.getAxiosConfig("Authorization", (apiKey) => `Bearer ${apiKey}`);
   }
   /**
    * Submit audio for transcription
@@ -3556,7 +3779,7 @@ var OpenAIWhisperAdapter = class extends BaseAdapter {
       let audioData;
       let fileName = "audio.mp3";
       if (audio.type === "url") {
-        const response2 = await axios5.get(audio.url, {
+        const response2 = await axios7.get(audio.url, {
           responseType: "arraybuffer"
         });
         audioData = Buffer.from(response2.data);
@@ -3581,40 +3804,37 @@ var OpenAIWhisperAdapter = class extends BaseAdapter {
       const model = this.selectModel(options);
       const isDiarization = model === "gpt-4o-transcribe-diarize";
       const needsWords = options?.wordTimestamps === true;
-      const requestBody = {
+      const request = {
         file: audioData,
+        // Generated type expects Blob
         model
       };
       if (options?.language) {
-        requestBody.language = options.language;
+        request.language = options.language;
       }
       if (options?.metadata?.prompt) {
-        requestBody.prompt = options.metadata.prompt;
+        request.prompt = options.metadata.prompt;
       }
       if (options?.metadata?.temperature !== void 0) {
-        requestBody.temperature = options.metadata.temperature;
+        request.temperature = options.metadata.temperature;
       }
       if (isDiarization) {
-        requestBody.response_format = "diarized_json";
+        request.response_format = "diarized_json";
         if (options?.metadata?.knownSpeakerNames) {
-          requestBody["known_speaker_names"] = options.metadata.knownSpeakerNames;
+          request.known_speaker_names = options.metadata.knownSpeakerNames;
         }
         if (options?.metadata?.knownSpeakerReferences) {
-          requestBody["known_speaker_references"] = options.metadata.knownSpeakerReferences;
+          request.known_speaker_references = options.metadata.knownSpeakerReferences;
         }
       } else if (needsWords || options?.diarization) {
-        requestBody.response_format = "verbose_json";
+        request.response_format = "verbose_json";
         if (needsWords) {
-          requestBody.timestamp_granularities = ["word", "segment"];
+          request.timestamp_granularities = ["word", "segment"];
         }
       } else {
-        requestBody.response_format = "json";
+        request.response_format = "json";
       }
-      const response = await this.client.post("/audio/transcriptions", requestBody, {
-        headers: {
-          "Content-Type": "multipart/form-data"
-        }
-      });
+      const response = await createTranscription(request, this.getAxiosConfig());
       return this.normalizeResponse(response.data, model, isDiarization);
     } catch (error) {
       return this.createErrorResponse(error);
@@ -3735,7 +3955,7 @@ function createOpenAIWhisperAdapter(config) {
 }
 
 // src/adapters/speechmatics-adapter.ts
-import axios6 from "axios";
+import axios8 from "axios";
 var SpeechmaticsAdapter = class extends BaseAdapter {
   constructor() {
     super(...arguments);
@@ -3757,7 +3977,7 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
   initialize(config) {
     super.initialize(config);
     this.baseUrl = config.baseUrl || this.baseUrl;
-    this.client = axios6.create({
+    this.client = axios8.create({
       baseURL: this.baseUrl,
       timeout: config.timeout || 12e4,
       headers: {
@@ -4892,9 +5112,16 @@ export {
   GladiaAdapter,
   schema_exports as GladiaTypes,
   GladiaWebhookHandler,
+  ListenV1EncodingParameter,
   OpenAIWhisperAdapter,
+  SpeakV1ContainerParameter,
+  SpeakV1EncodingParameter,
+  SpeakV1SampleRateParameter,
   SpeechmaticsAdapter,
   SpeechmaticsWebhookHandler,
+  StreamingSupportedBitDepthEnum,
+  StreamingSupportedEncodingEnum,
+  StreamingSupportedSampleRateEnum,
   VoiceRouter,
   WebhookRouter,
   createAssemblyAIAdapter,