voice-router-dev 0.8.7 → 0.8.8

package/dist/index.js

@@ -8920,6 +8920,7 @@ function createOpenAIWhisperAdapter(config) {
 
 // src/adapters/speechmatics-adapter.ts
 var import_axios8 = __toESM(require("axios"));
+var import_ws5 = __toESM(require("ws"));
 
 // src/generated/speechmatics/schema/notificationConfigContentsItem.ts
 var NotificationConfigContentsItem = {
@@ -8969,8 +8970,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,
@@ -9219,6 +9219,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 import_ws5.default(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 !== import_ws5.default.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 === import_ws5.default.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
@@ -9540,50 +9915,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) {
@@ -9592,24 +9968,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) => {
@@ -9688,10 +10073,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 + ")",
@@ -36710,7 +37095,7 @@ var AzureCapabilities = {
   deleteTranscript: true
 };
 var SpeechmaticsCapabilities = {
-  streaming: false,
+  streaming: true,
   diarization: true,
   wordTimestamps: true,
   languageDetection: false,