voice-router-dev 0.8.6 → 0.8.8

package/dist/index.mjs

@@ -8041,6 +8041,7 @@ var AzureSTTAdapter = class extends BaseAdapter {
       id: String(speakerId),
       label: `Speaker ${speakerId}`
     })) : void 0;
+    const utterances = words.length > 0 ? buildUtterancesFromWords(words) : void 0;
     const transcriptionId = transcription.self?.split("/").pop() || "";
     return {
       success: true,
@@ -8054,6 +8055,7 @@ var AzureSTTAdapter = class extends BaseAdapter {
         duration: transcriptionData.duration ? transcriptionData.duration / 1e7 : void 0,
         speakers,
         words: words.length > 0 ? words : void 0,
+        utterances: utterances && utterances.length > 0 ? utterances : void 0,
         createdAt: transcription.createdDateTime,
         completedAt: transcription.lastActionDateTime
       },
@@ -8689,6 +8691,7 @@ function createOpenAIWhisperAdapter(config) {
 
 // src/adapters/speechmatics-adapter.ts
 import axios8 from "axios";
+import WebSocket6 from "ws";
 
 // src/generated/speechmatics/schema/notificationConfigContentsItem.ts
 var NotificationConfigContentsItem = {
@@ -8738,8 +8741,7 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
     super(...arguments);
     this.name = "speechmatics";
     this.capabilities = {
-      streaming: false,
-      // Batch only (streaming available via separate WebSocket API)
+      streaming: true,
       diarization: true,
       wordTimestamps: true,
       languageDetection: false,
@@ -8874,13 +8876,16 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
         jobConfig.fetch_data = {
           url: audio.url
         };
-        requestBody = { config: JSON.stringify(jobConfig) };
-        headers = { "Content-Type": "application/json" };
+        const formData = new FormData();
+        formData.append("config", JSON.stringify(jobConfig));
+        requestBody = formData;
+        headers = { "Content-Type": "multipart/form-data" };
       } else if (audio.type === "file") {
-        requestBody = {
-          config: JSON.stringify(jobConfig),
-          data_file: audio.file
-        };
+        const formData = new FormData();
+        formData.append("config", JSON.stringify(jobConfig));
+        const audioBlob = audio.file instanceof Blob ? audio.file : new Blob([audio.file], { type: audio.mimeType || "audio/wav" });
+        formData.append("data_file", audioBlob, audio.filename || "audio.wav");
+        requestBody = formData;
         headers = { "Content-Type": "multipart/form-data" };
       } else {
         return {
@@ -8985,6 +8990,381 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
       throw error;
     }
   }
+  /**
+   * Build WebSocket URL for real-time streaming
+   *
+   * Note: Real-time API uses a different host from the batch API:
+   * - Batch: {region}.asr.api.speechmatics.com
+   * - Real-time: {region}.rt.speechmatics.com
+   *
+   * @param region - Regional endpoint identifier
+   * @returns WebSocket URL for real-time API
+   */
+  getRegionalWsUrl(region) {
+    if (this.config?.wsBaseUrl) {
+      return this.config.wsBaseUrl;
+    }
+    const regionPrefix = region || "eu1";
+    return `wss://${regionPrefix}.rt.speechmatics.com/v2`;
+  }
+  /**
+   * Stream audio for real-time transcription via WebSocket
+   *
+   * Connects to Speechmatics' real-time API and sends audio chunks
+   * for transcription with results returned via callbacks.
+   *
+   * @param options - Streaming configuration options
+   * @param callbacks - Event callbacks for transcription results
+   * @returns Promise that resolves with a StreamingSession
+   *
+   * @example Basic streaming
+   * ```typescript
+   * const session = await adapter.transcribeStream({
+   *   language: 'en',
+   *   speechmaticsStreaming: {
+   *     enablePartials: true,
+   *     operatingPoint: 'enhanced'
+   *   }
+   * }, {
+   *   onTranscript: (event) => console.log(event.text),
+   *   onUtterance: (utt) => console.log(`[${utt.speaker}]: ${utt.text}`),
+   *   onError: (error) => console.error(error)
+   * });
+   *
+   * await session.sendAudio({ data: audioBuffer });
+   * await session.close();
+   * ```
+   */
+  async transcribeStream(options, callbacks) {
+    this.validateConfig();
+    const smOpts = options?.speechmaticsStreaming || {};
+    const region = smOpts.region || this.config?.region;
+    const wsUrl = this.getRegionalWsUrl(region);
+    const ws = new WebSocket6(wsUrl, {
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`
+      }
+    });
+    let sessionStatus = "connecting";
+    const sessionId = `speechmatics-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    let seqNo = 0;
+    let utteranceResults = [];
+    const sessionReady = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("WebSocket connection timeout"));
+      }, 1e4);
+      let wsOpen = false;
+      ws.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+      ws.once("open", () => {
+        wsOpen = true;
+        const encoding = smOpts.encoding || options?.encoding || "pcm_s16le";
+        const sampleRate = smOpts.sampleRate || options?.sampleRate || 16e3;
+        const startMsg = {
+          message: "StartRecognition",
+          audio_format: {
+            type: "raw",
+            encoding,
+            sample_rate: sampleRate
+          },
+          transcription_config: {
+            language: smOpts.language || options?.language || "en",
+            enable_partials: smOpts.enablePartials ?? options?.interimResults ?? true
+          }
+        };
+        const txConfig = startMsg.transcription_config;
+        if (smOpts.domain) txConfig.domain = smOpts.domain;
+        if (smOpts.operatingPoint) txConfig.operating_point = smOpts.operatingPoint;
+        if (smOpts.maxDelay !== void 0) txConfig.max_delay = smOpts.maxDelay;
+        if (smOpts.maxDelayMode) txConfig.max_delay_mode = smOpts.maxDelayMode;
+        if (smOpts.enableEntities !== void 0) txConfig.enable_entities = smOpts.enableEntities;
+        if (smOpts.diarization === "speaker" || options?.diarization) {
+          txConfig.diarization = "speaker";
+          if (smOpts.maxSpeakers) {
+            txConfig.speaker_diarization_config = {
+              max_speakers: smOpts.maxSpeakers
+            };
+          } else if (options?.speakersExpected) {
+            txConfig.speaker_diarization_config = {
+              max_speakers: options.speakersExpected
+            };
+          }
+        }
+        if (smOpts.additionalVocab && smOpts.additionalVocab.length > 0) {
+          txConfig.additional_vocab = smOpts.additionalVocab.map((word) => ({
+            content: word
+          }));
+        } else if (options?.customVocabulary && options.customVocabulary.length > 0) {
+          txConfig.additional_vocab = options.customVocabulary.map((word) => ({
+            content: word
+          }));
+        }
+        if (smOpts.conversationConfig) {
+          txConfig.conversation_config = {
+            end_of_utterance_silence_trigger: smOpts.conversationConfig.endOfUtteranceSilenceTrigger
+          };
+        }
+        const startPayload = JSON.stringify(startMsg);
+        if (callbacks?.onRawMessage) {
+          callbacks.onRawMessage({
+            provider: "speechmatics",
+            direction: "outgoing",
+            timestamp: Date.now(),
+            payload: startPayload,
+            messageType: "StartRecognition"
+          });
+        }
+        ws.send(startPayload);
+      });
+      const onMessage = (data) => {
+        const rawPayload = data.toString();
+        try {
+          const msg = JSON.parse(rawPayload);
+          if (msg.message === "RecognitionStarted") {
+            clearTimeout(timeout);
+            ws.removeListener("message", onMessage);
+            ws.emit("message", data);
+            resolve();
+          } else if (msg.message === "Error") {
+            clearTimeout(timeout);
+            ws.removeListener("message", onMessage);
+            reject(new Error(msg.reason || "Recognition failed to start"));
+          }
+        } catch {
+        }
+      };
+      ws.on("message", onMessage);
+    });
+    ws.on("message", (data) => {
+      const rawPayload = data.toString();
+      try {
+        const message = JSON.parse(rawPayload);
+        if (callbacks?.onRawMessage) {
+          callbacks.onRawMessage({
+            provider: "speechmatics",
+            direction: "incoming",
+            timestamp: Date.now(),
+            payload: rawPayload,
+            messageType: message.message
+          });
+        }
+        this.handleStreamingMessage(message, callbacks, utteranceResults);
+      } catch (error) {
+        if (callbacks?.onRawMessage) {
+          callbacks.onRawMessage({
+            provider: "speechmatics",
+            direction: "incoming",
+            timestamp: Date.now(),
+            payload: rawPayload,
+            messageType: "parse_error"
+          });
+        }
+        callbacks?.onError?.({
+          code: "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 sessionReady;
+    sessionStatus = "open";
+    callbacks?.onOpen?.();
+    return {
+      id: sessionId,
+      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 !== WebSocket6.OPEN) {
+          throw new Error("WebSocket is not open");
+        }
+        if (callbacks?.onRawMessage) {
+          const audioPayload = chunk.data instanceof ArrayBuffer ? chunk.data : chunk.data.buffer.slice(
+            chunk.data.byteOffset,
+            chunk.data.byteOffset + chunk.data.byteLength
+          );
+          callbacks.onRawMessage({
+            provider: this.name,
+            direction: "outgoing",
+            timestamp: Date.now(),
+            payload: audioPayload,
+            messageType: "audio"
+          });
+        }
+        ws.send(chunk.data);
+        seqNo++;
+        if (chunk.isLast) {
+          const endMsg = JSON.stringify({
+            message: "EndOfStream",
+            last_seq_no: seqNo
+          });
+          if (callbacks?.onRawMessage) {
+            callbacks.onRawMessage({
+              provider: this.name,
+              direction: "outgoing",
+              timestamp: Date.now(),
+              payload: endMsg,
+              messageType: "EndOfStream"
+            });
+          }
+          ws.send(endMsg);
+        }
+      },
+      close: async () => {
+        if (sessionStatus === "closed" || sessionStatus === "closing") {
+          return;
+        }
+        sessionStatus = "closing";
+        if (ws.readyState === WebSocket6.OPEN) {
+          seqNo++;
+          ws.send(
+            JSON.stringify({
+              message: "EndOfStream",
+              last_seq_no: seqNo
+            })
+          );
+        }
+        return new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            ws.terminate();
+            sessionStatus = "closed";
+            resolve();
+          }, 5e3);
+          const onMsg = (data) => {
+            try {
+              const msg = JSON.parse(data.toString());
+              if (msg.message === "EndOfTranscript") {
+                ws.removeListener("message", onMsg);
+                clearTimeout(timeout);
+                ws.close();
+              }
+            } catch {
+            }
+          };
+          ws.on("message", onMsg);
+          ws.once("close", () => {
+            clearTimeout(timeout);
+            sessionStatus = "closed";
+            resolve();
+          });
+        });
+      }
+    };
+  }
+  /**
+   * Handle incoming Speechmatics real-time WebSocket messages
+   */
+  handleStreamingMessage(message, callbacks, utteranceResults) {
+    switch (message.message) {
+      case "RecognitionStarted": {
+        break;
+      }
+      case "AddPartialTranscript": {
+        const results = message.results || [];
+        const text = buildTextFromSpeechmaticsResults(results);
+        if (text) {
+          callbacks?.onTranscript?.({
+            type: "transcript",
+            text,
+            isFinal: false,
+            words: this.extractWordsFromResults(results),
+            data: message
+          });
+        }
+        break;
+      }
+      case "AddTranscript": {
+        const results = message.results || [];
+        const text = buildTextFromSpeechmaticsResults(results);
+        if (utteranceResults) {
+          utteranceResults.push(...results);
+        }
+        if (text) {
+          callbacks?.onTranscript?.({
+            type: "transcript",
+            text,
+            isFinal: true,
+            words: this.extractWordsFromResults(results),
+            data: message
+          });
+        }
+        break;
+      }
+      case "EndOfUtterance": {
+        if (utteranceResults && utteranceResults.length > 0) {
+          const text = buildTextFromSpeechmaticsResults(utteranceResults);
+          const words = this.extractWordsFromResults(utteranceResults);
+          const utterances = buildUtterancesFromWords(words);
+          if (utterances.length > 0) {
+            for (const utt of utterances) {
+              callbacks?.onUtterance?.(utt);
+            }
+          } else if (text) {
+            callbacks?.onUtterance?.({
+              text,
+              start: words.length > 0 ? words[0].start : 0,
+              end: words.length > 0 ? words[words.length - 1].end : 0,
+              words
+            });
+          }
+          utteranceResults.length = 0;
+        }
+        break;
+      }
+      case "AudioAdded": {
+        break;
+      }
+      case "EndOfTranscript": {
+        break;
+      }
+      case "Info":
+      case "Warning": {
+        callbacks?.onMetadata?.(message);
+        break;
+      }
+      case "Error": {
+        const errMsg = message;
+        callbacks?.onError?.({
+          code: errMsg.type || "SPEECHMATICS_ERROR",
+          message: errMsg.reason || "Unknown error",
+          details: message
+        });
+        break;
+      }
+      default: {
+        callbacks?.onMetadata?.(message);
+        break;
+      }
+    }
+  }
+  /**
+   * Extract unified Word[] from Speechmatics recognition results
+   */
+  extractWordsFromResults(results) {
+    return results.filter((r) => r.type === "word" && r.start_time !== void 0 && r.end_time !== void 0).map((result) => ({
+      word: result.alternatives?.[0]?.content || "",
+      start: result.start_time,
+      end: result.end_time,
+      confidence: result.alternatives?.[0]?.confidence,
+      speaker: result.alternatives?.[0]?.speaker
+    }));
+  }
   /**
    * Normalize Speechmatics status to unified status
    * Uses generated JobDetailsStatus enum values
@@ -9203,26 +9583,13 @@ var SonioxAdapter = class extends BaseAdapter {
       } else if (audio.type === "file") {
         const formData = new FormData();
         const audioBlob = audio.file instanceof Blob ? audio.file : new Blob([audio.file], { type: audio.mimeType || "audio/wav" });
-        formData.append("audio", audioBlob, audio.filename || "audio.wav");
-        formData.append("model", requestBody.model);
-        if (options?.language) {
-          formData.append("language_hints", JSON.stringify([options.language]));
-        }
-        if (options?.diarization) {
-          formData.append("enable_speaker_diarization", "true");
-        }
-        if (options?.languageDetection) {
-          formData.append("enable_language_identification", "true");
-        }
-        if (options?.customVocabulary) {
-          formData.append("context", JSON.stringify({ terms: options.customVocabulary }));
-        }
-        const response2 = await this.client.post("/speech/transcribe", formData, {
+        formData.append("file", audioBlob, audio.filename || "audio.wav");
+        const uploadResponse = await this.client.post("/files", formData, {
           headers: {
             "Content-Type": "multipart/form-data"
           }
         });
-        return this.normalizeResponse(response2.data);
+        requestBody.file_id = uploadResponse.data.id;
       } else {
         return {
           success: false,
@@ -9247,8 +9614,9 @@ var SonioxAdapter = class extends BaseAdapter {
           terms: options.customVocabulary
         };
       }
-      const response = await this.client.post("/speech/transcribe", requestBody);
-      return this.normalizeResponse(response.data);
+      const response = await this.client.post("/transcriptions", requestBody);
+      const transcriptionId = response.data.id;
+      return await this.pollForCompletion(transcriptionId);
     } catch (error) {
       return this.createErrorResponse(error);
     }
@@ -9256,8 +9624,9 @@ var SonioxAdapter = class extends BaseAdapter {
   /**
    * Get transcription result by ID
    *
-   * Soniox batch transcription is synchronous (returns immediately),
-   * but this method can be used for consistency with other providers.
+   * Checks job status via GET /v1/transcriptions/{id}, then fetches
+   * the full transcript via GET /v1/transcriptions/{id}/transcript
+   * when completed.
    *
    * @param transcriptId - Transcript ID
    * @returns Transcription response
@@ -9265,8 +9634,39 @@ var SonioxAdapter = class extends BaseAdapter {
   async getTranscript(transcriptId) {
     this.validateConfig();
     try {
-      const response = await this.client.get(`/speech/transcripts/${transcriptId}`);
-      return this.normalizeResponse(response.data);
+      const statusResponse = await this.client.get(`/transcriptions/${transcriptId}`);
+      const job = statusResponse.data;
+      if (job.status === "error") {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "TRANSCRIPTION_ERROR",
+            message: job.error_message || "Transcription failed"
+          }
+        };
+      }
+      if (job.status !== "completed") {
+        return {
+          success: true,
+          provider: this.name,
+          data: {
+            id: job.id,
+            text: "",
+            status: job.status
+          },
+          raw: job
+        };
+      }
+      const transcriptResponse = await this.client.get(
+        `/transcriptions/${transcriptId}/transcript`
+      );
+      return this.normalizeResponse({
+        ...transcriptResponse.data,
+        // Carry over job metadata
+        id: job.id,
+        audio_duration_ms: job.audio_duration_ms
+      });
     } catch (error) {
       return this.createErrorResponse(error);
     }
@@ -9286,50 +9686,51 @@ var SonioxAdapter = class extends BaseAdapter {
     const sessionId = `soniox_${Date.now()}_${Math.random().toString(36).substring(7)}`;
     const createdAt = /* @__PURE__ */ new Date();
     const wsBase = this.config?.wsBaseUrl || (this.config?.baseUrl ? this.deriveWsUrl(this.config.baseUrl) : `wss://${this.getRegionalWsHost()}`);
-    const wsUrl = new URL(`${wsBase}/transcribe-websocket`);
-    wsUrl.searchParams.set("api_key", this.config.apiKey);
-    const modelId = options?.sonioxStreaming?.model || options?.model || "stt-rt-preview";
-    wsUrl.searchParams.set("model", modelId);
-    if (options?.encoding) {
+    const wsUrl = `${wsBase}/transcribe-websocket`;
+    const modelId = options?.sonioxStreaming?.model || options?.model || "stt-rt-v4";
+    const sonioxOpts = options?.sonioxStreaming;
+    const initMessage = {
+      api_key: this.config.apiKey,
+      model: modelId
+    };
+    if (sonioxOpts?.audioFormat) {
+      initMessage.audio_format = sonioxOpts.audioFormat;
+    } else if (options?.encoding) {
       const encodingMap = {
         linear16: "pcm_s16le",
         pcm: "pcm_s16le",
         mulaw: "mulaw",
         alaw: "alaw"
       };
-      wsUrl.searchParams.set("audio_format", encodingMap[options.encoding] || options.encoding);
+      initMessage.audio_format = encodingMap[options.encoding] || options.encoding;
     }
-    if (options?.sampleRate) {
-      wsUrl.searchParams.set("sample_rate", options.sampleRate.toString());
+    if (sonioxOpts?.sampleRate || options?.sampleRate) {
+      initMessage.sample_rate = sonioxOpts?.sampleRate || options?.sampleRate;
     }
-    if (options?.channels) {
-      wsUrl.searchParams.set("num_channels", options.channels.toString());
+    if (sonioxOpts?.numChannels || options?.channels) {
+      initMessage.num_channels = sonioxOpts?.numChannels || options?.channels;
     }
-    const sonioxOpts = options?.sonioxStreaming;
     if (sonioxOpts) {
       if (sonioxOpts.languageHints && sonioxOpts.languageHints.length > 0) {
-        wsUrl.searchParams.set("language_hints", JSON.stringify(sonioxOpts.languageHints));
+        initMessage.language_hints = sonioxOpts.languageHints;
       }
       if (sonioxOpts.enableLanguageIdentification) {
-        wsUrl.searchParams.set("enable_language_identification", "true");
+        initMessage.enable_language_identification = true;
       }
       if (sonioxOpts.enableEndpointDetection) {
-        wsUrl.searchParams.set("enable_endpoint_detection", "true");
+        initMessage.enable_endpoint_detection = true;
       }
       if (sonioxOpts.enableSpeakerDiarization) {
-        wsUrl.searchParams.set("enable_speaker_diarization", "true");
+        initMessage.enable_speaker_diarization = true;
       }
       if (sonioxOpts.context) {
-        wsUrl.searchParams.set(
-          "context",
-          typeof sonioxOpts.context === "string" ? sonioxOpts.context : JSON.stringify(sonioxOpts.context)
-        );
+        initMessage.context = typeof sonioxOpts.context === "string" ? sonioxOpts.context : sonioxOpts.context;
       }
       if (sonioxOpts.translation) {
-        wsUrl.searchParams.set("translation", JSON.stringify(sonioxOpts.translation));
+        initMessage.translation = sonioxOpts.translation;
       }
       if (sonioxOpts.clientReferenceId) {
-        wsUrl.searchParams.set("client_reference_id", sonioxOpts.clientReferenceId);
+        initMessage.client_reference_id = sonioxOpts.clientReferenceId;
       }
     }
     if (!sonioxOpts?.languageHints && options?.language) {
@@ -9338,24 +9739,33 @@ var SonioxAdapter = class extends BaseAdapter {
           `[Soniox] Warning: language="multi" is Deepgram-specific and not supported by Soniox. For automatic language detection, use languageDetection: true instead, or specify a language code like 'en'.`
         );
       }
-      wsUrl.searchParams.set("language_hints", JSON.stringify([options.language]));
+      initMessage.language_hints = [options.language];
     }
     if (!sonioxOpts?.enableSpeakerDiarization && options?.diarization) {
-      wsUrl.searchParams.set("enable_speaker_diarization", "true");
+      initMessage.enable_speaker_diarization = true;
     }
     if (!sonioxOpts?.enableLanguageIdentification && options?.languageDetection) {
-      wsUrl.searchParams.set("enable_language_identification", "true");
-    }
-    if (options?.interimResults !== false) {
+      initMessage.enable_language_identification = true;
     }
     let status = "connecting";
     let openedAt = null;
     let receivedData = false;
     const WebSocketImpl = typeof WebSocket !== "undefined" ? WebSocket : __require("ws");
-    const ws = new WebSocketImpl(wsUrl.toString());
+    const ws = new WebSocketImpl(wsUrl);
     ws.onopen = () => {
-      status = "open";
       openedAt = Date.now();
+      const initPayload = JSON.stringify(initMessage);
+      if (callbacks?.onRawMessage) {
+        callbacks.onRawMessage({
+          provider: this.name,
+          direction: "outgoing",
+          timestamp: Date.now(),
+          payload: initPayload,
+          messageType: "init"
+        });
+      }
+      ws.send(initPayload);
+      status = "open";
       callbacks?.onOpen?.();
     };
     ws.onmessage = (event) => {
@@ -9434,10 +9844,10 @@ var SonioxAdapter = class extends BaseAdapter {
     ws.onclose = (event) => {
       status = "closed";
       const timeSinceOpen = openedAt ? Date.now() - openedAt : null;
-      const isImmediateClose = timeSinceOpen !== null && timeSinceOpen < 1e3 && !receivedData;
-      if (isImmediateClose && event.code === 1e3) {
+      const isEarlyClose = timeSinceOpen !== null && timeSinceOpen < 5e3 && !receivedData;
+      if (isEarlyClose && event.code === 1e3) {
         const errorMessage = [
-          "Soniox closed connection immediately after opening.",
+          "Soniox closed connection shortly after opening.",
           `Current config: region=${this.region}, model=${modelId}`,
           "Likely causes:",
           "  - Invalid API key or region mismatch (keys are region-specific, current: " + this.region + ")",
@@ -9558,8 +9968,10 @@ var SonioxAdapter = class extends BaseAdapter {
    * Normalize Soniox response to unified format
    */
   normalizeResponse(response) {
-    const text = response.text || (response.tokens ? response.tokens.filter((t) => t.is_final).map((t) => t.text).join("") : "");
-    const words = response.tokens ? response.tokens.filter((t) => t.is_final && t.start_ms !== void 0 && t.end_ms !== void 0).map((token) => ({
+    const text = response.text || (response.tokens ? response.tokens.filter((t) => t.is_final !== false).map((t) => t.text).join("") : "");
+    const words = response.tokens ? response.tokens.filter(
+      (t) => t.is_final !== false && t.start_ms !== void 0 && t.end_ms !== void 0
+    ).map((token) => ({
       word: token.text,
       start: token.start_ms / 1e3,
       end: token.end_ms / 1e3,
@@ -9576,7 +9988,8 @@ var SonioxAdapter = class extends BaseAdapter {
       id,
       label: `Speaker ${id}`
     })) : void 0;
-    const utterances = response.tokens ? this.buildUtterancesFromTokens(response.tokens.filter((t) => t.is_final)) : [];
+    const tokens = response.tokens ? response.tokens.filter((t) => t.is_final !== false) : [];
+    const utterances = tokens.length > 0 ? this.buildUtterancesFromTokens(tokens) : [];
     const language = response.tokens?.find((t) => t.language)?.language;
     return {
       success: true,
@@ -9586,7 +9999,7 @@ var SonioxAdapter = class extends BaseAdapter {
         text,
         status: TranscriptionStatus.completed,
         language,
-        duration: response.total_audio_proc_ms ? response.total_audio_proc_ms / 1e3 : void 0,
+        duration: response.audio_duration_ms ? response.audio_duration_ms / 1e3 : response.total_audio_proc_ms ? response.total_audio_proc_ms / 1e3 : void 0,
         speakers,
         words: words.length > 0 ? words : void 0,
         utterances: utterances.length > 0 ? utterances : void 0
@@ -36453,7 +36866,7 @@ var AzureCapabilities = {
   deleteTranscript: true
 };
 var SpeechmaticsCapabilities = {
-  streaming: false,
+  streaming: true,
   diarization: true,
   wordTimestamps: true,
   languageDetection: false,