@voice-kit/core 0.1.2 → 0.1.3

package/dist/stt.js

@@ -1,815 +0,0 @@
-import { AssemblyAI } from 'assemblyai';
-import pino from 'pino';
-import { DeepgramClient } from '@deepgram/sdk';
-import axios from 'axios';
-import { EventEmitter } from 'events';
-import { createOpenAI } from '@ai-sdk/openai';
-
-// src/stt/assembly/index.ts
-
-// src/errors/base.ts
-var VoiceKitError = class extends Error {
-  code;
-  callId;
-  provider;
-  retryable;
-  severity;
-  cause;
-  constructor(params) {
-    super(params.message);
-    this.name = this.constructor.name;
-    this.code = params.code;
-    this.callId = params.callId;
-    this.provider = params.provider;
-    this.retryable = params.retryable ?? false;
-    this.severity = params.severity ?? "medium";
-    this.cause = params.cause;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      callId: this.callId,
-      provider: this.provider,
-      retryable: this.retryable,
-      severity: this.severity
-    };
-  }
-};
-
-// src/errors/stt.errors.ts
-var STTError = class extends VoiceKitError {
-  languageCode;
-  constructor(params) {
-    super(params);
-    this.languageCode = params.languageCode;
-  }
-};
-var STTConnectionError = class extends STTError {
-  constructor(provider, cause, callId) {
-    super({
-      code: "STT_CONNECTION_FAILED",
-      message: `Failed to connect to ${provider} STT service`,
-      provider,
-      callId,
-      retryable: true,
-      severity: "high",
-      cause
-    });
-  }
-};
-var STTStreamError = class extends STTError {
-  constructor(provider, cause, callId) {
-    super({
-      code: "STT_STREAM_ERROR",
-      message: `STT stream error from ${provider}`,
-      provider,
-      callId,
-      retryable: true,
-      severity: "medium",
-      cause
-    });
-  }
-};
-var STTLanguageNotSupportedError = class extends STTError {
-  constructor(provider, language) {
-    super({
-      code: "STT_LANGUAGE_NOT_SUPPORTED",
-      message: `Language '${language}' is not supported by ${provider}`,
-      provider,
-      retryable: false,
-      severity: "low",
-      languageCode: language
-    });
-  }
-};
-var logger = pino({ name: "@voice-kit/core:stt:assemblyai" });
-var SUPPORTED_LANGUAGES = [
-  "en",
-  "en_au",
-  "en_uk",
-  "en_us",
-  "hi",
-  "fr",
-  "de",
-  "es",
-  "it",
-  "pt",
-  "nl",
-  "ja",
-  "zh"
-];
-var AssemblyAISTTProvider = class {
-  name = "assemblyai";
-  supportsStreaming = false;
-  supportedLanguages = SUPPORTED_LANGUAGES;
-  client;
-  config;
-  constructor(config) {
-    const apiKey = config.apiKey ?? process.env["ASSEMBLYAI_API_KEY"];
-    if (!apiKey) throw new STTConnectionError("assemblyai", new Error("ASSEMBLYAI_API_KEY not set"));
-    this.client = new AssemblyAI({ apiKey });
-    this.config = {
-      language: config.language ?? "en",
-      alternateLanguages: config.alternateLanguages ?? [],
-      apiKey,
-      model: config.model ?? "best",
-      wordTimestamps: config.wordTimestamps ?? true,
-      interimResults: false,
-      smartFormat: config.smartFormat ?? true,
-      region: ""
-    };
-  }
-  /**
-   * Batch-transcribes collected audio. AssemblyAI has no realtime streaming.
-   * Collects all audio from the iterable, uploads, then polls for result.
-   *
-   * @param audio  Async iterable of PCM buffers
-   */
-  async *transcribeStream(audio) {
-    const chunks = [];
-    for await (const chunk of audio) chunks.push(chunk);
-    const result = await this.transcribeBatch(Buffer.concat(chunks));
-    yield result;
-  }
-  /**
-   * Upload audio to AssemblyAI and wait for async transcription.
-   * Suitable for call recordings. Average latency: 15–45s per minute of audio.
-   *
-   * @param audio  Raw WAV/PCM/MP3 buffer
-   *
-   * @example
-   * ```ts
-   * const stt = createSTT('assemblyai', { wordTimestamps: true })
-   * const result = await stt.transcribeBatch(recordingBuffer)
-   * console.log(result.words) // Word-level timestamps
-   * ```
-   */
-  async transcribeBatch(audio) {
-    const startMs = Date.now();
-    try {
-      logger.debug({ bytes: audio.length, language: this.config.language }, "AssemblyAI transcription started");
-      const transcript = await this.client.transcripts.transcribe({
-        audio,
-        language_code: this.config.language,
-        speech_model: this.config.model,
-        punctuate: this.config.smartFormat,
-        format_text: this.config.smartFormat,
-        word_boost: [],
-        ...this.config.wordTimestamps && { timestamps: true }
-      });
-      if (transcript.status === "error") {
-        throw new STTStreamError("assemblyai", new Error(transcript.error ?? "Transcription failed"));
-      }
-      logger.info(
-        { id: transcript.id, duration: transcript.audio_duration, latencyMs: Date.now() - startMs },
-        "AssemblyAI transcription complete"
-      );
-      return {
-        transcript: transcript.text ?? "",
-        isFinal: true,
-        confidence: transcript.confidence ?? 0.9,
-        language: this.config.language,
-        languageSwitchDetected: false,
-        words: this.config.wordTimestamps && transcript.words ? transcript.words.map((w) => ({
-          word: w.text,
-          startMs: w.start,
-          endMs: w.end,
-          confidence: w.confidence
-        })) : void 0,
-        latencyMs: Date.now() - startMs
-      };
-    } catch (err) {
-      if (err instanceof STTStreamError) throw err;
-      throw new STTStreamError("assemblyai", err);
-    }
-  }
-};
-var logger2 = pino({ name: "@voice-kit/core:stt:deepgram" });
-var SUPPORTED_LANGUAGES2 = [
-  "en-IN",
-  "hi-IN",
-  "ta-IN",
-  "te-IN",
-  "kn-IN",
-  "mr-IN",
-  "en-US",
-  "en-GB",
-  "en-AU"
-];
-var BACKOFF = {
-  baseMs: 100,
-  maxMs: 5e3,
-  jitterPct: 0.2,
-  maxAttempts: 3
-};
-function backoffDelay(attempt) {
-  const base = Math.min(BACKOFF.baseMs * Math.pow(2, attempt), BACKOFF.maxMs);
-  const jitter = base * BACKOFF.jitterPct * (Math.random() * 2 - 1);
-  return Math.round(base + jitter);
-}
-var DeepgramSTTProvider = class {
-  name = "deepgram";
-  supportsStreaming = true;
-  supportedLanguages = SUPPORTED_LANGUAGES2;
-  client;
-  config;
-  constructor(config) {
-    const apiKey = config.apiKey ?? process.env["DEEPGRAM_API_KEY"];
-    if (!apiKey) throw new STTConnectionError("deepgram", new Error("DEEPGRAM_API_KEY not set"));
-    this.client = new DeepgramClient({ apiKey });
-    this.config = {
-      language: config.language ?? "en-IN",
-      alternateLanguages: config.alternateLanguages ?? [],
-      apiKey,
-      // nova-3 is now Deepgram's latest recommended model
-      model: config.model ?? "nova-3",
-      wordTimestamps: config.wordTimestamps ?? false,
-      interimResults: config.interimResults ?? true,
-      smartFormat: config.smartFormat ?? true,
-      region: config.region ?? ""
-    };
-  }
-  /**
-   * Stream audio to Deepgram and receive interim + final transcription results.
-   * Handles reconnection transparently with exponential backoff.
-   *
-   * @param audio  Async iterable of 16kHz PCM buffers from AudioPipeline
-   *
-   * @example
-   * ```ts
-   * const stt = createSTT('deepgram', { language: 'hi-IN' })
-   * for await (const result of stt.transcribeStream(audioIterable)) {
-   *   if (result.isFinal) console.log('User said:', result.transcript)
-   * }
-   * ```
-   */
-  async *transcribeStream(audio) {
-    let attempt = 0;
-    const startMs = Date.now();
-    while (attempt <= BACKOFF.maxAttempts) {
-      const connection = await this.connectWithRetry(attempt);
-      const results = [];
-      let done = false;
-      let error = null;
-      connection.on("message", (data) => {
-        if (data.type !== "Results") return;
-        const alt = data.channel?.alternatives?.[0];
-        if (!alt?.transcript) return;
-        const isFinal = data.is_final === true;
-        const result = {
-          transcript: alt.transcript,
-          isFinal,
-          // speech_final=true means Deepgram detected end-of-utterance (endpointing).
-          // A frame can be speech_final without is_final — callers should act on both.
-          confidence: alt.confidence ?? 0,
-          // alt.languages populated when detect_language is enabled
-          language: alt.languages?.[0] ?? this.config.language,
-          languageSwitchDetected: false,
-          words: this.config.wordTimestamps ? alt.words?.map((w) => ({
-            word: w.word ?? "",
-            startMs: (w.start ?? 0) * 1e3,
-            endMs: (w.end ?? 0) * 1e3,
-            confidence: w.confidence ?? 0,
-            punctuatedWord: w.punctuated_word
-          })) : void 0,
-          latencyMs: Date.now() - startMs
-        };
-        results.push(result);
-        if (isFinal) {
-          logger2.debug(
-            { transcript: result.transcript, confidence: result.confidence, language: result.language },
-            "Deepgram final transcript"
-          );
-        }
-      });
-      connection.on("close", () => {
-        done = true;
-      });
-      connection.on("error", (err) => {
-        error = err;
-        logger2.warn({ err, attempt }, "Deepgram stream error");
-      });
-      const sendAudio = async () => {
-        try {
-          for await (const chunk of audio) {
-            connection.socket.send(chunk);
-          }
-          connection.socket.send(JSON.stringify({ type: "Finalize" }));
-        } catch (err) {
-          error = err instanceof Error ? err : new Error(String(err));
-        }
-      };
-      const sendPromise = sendAudio();
-      let resultIndex = 0;
-      while (!done || resultIndex < results.length) {
-        if (resultIndex < results.length) {
-          yield results[resultIndex++];
-        } else {
-          await new Promise((r) => setTimeout(r, 10));
-        }
-        if (error && attempt < BACKOFF.maxAttempts) {
-          try {
-            connection.socket.close();
-          } catch {
-          }
-          break;
-        }
-        if (error && attempt >= BACKOFF.maxAttempts) {
-          await sendPromise.catch(() => {
-          });
-          throw new STTStreamError("deepgram", error);
-        }
-      }
-      await sendPromise.catch(() => {
-      });
-      if (!error) return;
-      attempt++;
-      await new Promise((r) => setTimeout(r, backoffDelay(attempt)));
-      logger2.info({ attempt }, "Deepgram reconnecting...");
-    }
-    throw new STTStreamError("deepgram", new Error("Max reconnect attempts exceeded"));
-  }
-  /**
-   * Transcribe a complete audio buffer (non-streaming).
-   * Uses Deepgram pre-recorded API.
-   *
-   * @param audio  Raw PCM or WAV buffer
-   */
-  async transcribeBatch(audio) {
-    const startMs = Date.now();
-    try {
-      const response = await this.client.listen.v1.media.transcribeFile(
-        audio,
-        {
-          model: this.config.model,
-          language: this.config.language,
-          // v5: boolean-like options must be strings
-          smart_format: true,
-          diarize: false
-        }
-      );
-      const alt = response?.results?.channels?.[0]?.alternatives?.[0];
-      return {
-        transcript: alt?.transcript ?? "",
-        isFinal: true,
-        confidence: alt?.confidence ?? 0,
-        language: this.config.language,
-        languageSwitchDetected: false,
-        latencyMs: Date.now() - startMs
-      };
-    } catch (err) {
-      if (err instanceof STTStreamError) throw err;
-      throw new STTStreamError("deepgram", err instanceof Error ? err : new Error(String(err)));
-    }
-  }
-  /**
-   * Create and open a live WebSocket connection to Deepgram.
-   *
-   * v5 connection lifecycle (3 explicit steps):
-   *   1. await listen.v1.connect(options)  — constructs the connection object
-   *   2. connection.connect()              — initiates the WebSocket handshake
-   *   3. await connection.waitForOpen()    — resolves once the socket is ready
-   *
-   * @internal
-   */
-  async connectWithRetry(attempt) {
-    const delay = attempt > 0 ? backoffDelay(attempt) : 0;
-    if (delay > 0) await new Promise((r) => setTimeout(r, delay));
-    try {
-      logger2.debug({ attempt, language: this.config.language }, "Connecting to Deepgram");
-      const connection = await this.client.listen.v1.connect({
-        model: this.config.model,
-        language: this.config.language,
-        // v5: boolean-like options must be strings
-        smart_format: "true",
-        interim_results: String(this.config.interimResults),
-        encoding: "linear16",
-        sample_rate: 16e3,
-        channels: 1,
-        utterance_end_ms: "1000",
-        ...this.config.alternateLanguages.length > 0 && {
-          detect_language: "true",
-          // language must be omitted when detect_language is enabled
-          language: void 0
-        },
-        Authorization: `Token ${this.config.apiKey}`
-      });
-      connection.connect();
-      await Promise.race([
-        connection.waitForOpen(),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new STTConnectionError("deepgram", new Error("Connection timeout"))),
-            1e4
-          )
-        )
-      ]);
-      logger2.info({ attempt, language: this.config.language }, "Deepgram connected");
-      return connection;
-    } catch (err) {
-      if (err instanceof STTConnectionError) throw err;
-      throw new STTConnectionError("deepgram", err instanceof Error ? err : new Error(String(err)));
-    }
-  }
-};
-var logger3 = pino({ name: "@voice-kit/core:stt:sarvam" });
-var SARVAM_API_BASE = "https://api.sarvam.ai";
-var SUPPORTED_LANGUAGES3 = [
-  "hi-IN",
-  "kn-IN",
-  "ta-IN",
-  "te-IN",
-  "mr-IN",
-  "bn-IN",
-  "gu-IN",
-  "pa-IN",
-  "or-IN",
-  "ml-IN"
-];
-var SARVAM_MODELS = {
-  "hi-IN": "saarika:v1",
-  "kn-IN": "saarika:v1",
-  "ta-IN": "saarika:v1",
-  "te-IN": "saarika:v1",
-  "mr-IN": "saarika:v1",
-  "bn-IN": "saarika:v1",
-  "gu-IN": "saarika:v1",
-  "pa-IN": "saarika:v1",
-  "or-IN": "saarika:v1",
-  "ml-IN": "saarika:v1"
-};
-var SarvamSTTProvider = class {
-  name = "sarvam";
-  supportsStreaming = false;
-  // Sarvam REST API is batch-only
-  supportedLanguages = SUPPORTED_LANGUAGES3;
-  http;
-  config;
-  constructor(config) {
-    const apiKey = config.apiKey ?? process.env["SARVAM_API_KEY"];
-    if (!apiKey) throw new STTConnectionError("sarvam", new Error("SARVAM_API_KEY not set"));
-    const language = config.language ?? "hi-IN";
-    if (!SUPPORTED_LANGUAGES3.includes(language)) {
-      throw new STTLanguageNotSupportedError("sarvam", language);
-    }
-    this.http = axios.create({
-      baseURL: SARVAM_API_BASE,
-      headers: {
-        "API-Subscription-Key": apiKey,
-        "Content-Type": "multipart/form-data"
-      },
-      timeout: 3e4
-    });
-    this.config = {
-      language,
-      alternateLanguages: config.alternateLanguages ?? [],
-      apiKey,
-      model: config.model ?? SARVAM_MODELS[language] ?? "saarika:v1",
-      wordTimestamps: false,
-      // Sarvam doesn't support word timestamps yet
-      interimResults: false,
-      smartFormat: config.smartFormat ?? true,
-      region: config.region ?? ""
-    };
-  }
-  /**
-   * Collects audio and transcribes via Sarvam batch API.
-   * Sarvam doesn't support realtime streaming.
-   *
-   * @param audio  Async iterable of 16kHz PCM buffers
-   */
-  async *transcribeStream(audio) {
-    const chunks = [];
-    for await (const chunk of audio) chunks.push(chunk);
-    const result = await this.transcribeBatch(Buffer.concat(chunks));
-    yield result;
-  }
-  /**
-   * Transcribe a WAV/PCM audio buffer in an Indic language.
-   *
-   * @param audio  16kHz PCM or WAV buffer
-   *
-   * @example
-   * ```ts
-   * const stt = createSTT('sarvam', { language: 'ta-IN' })
-   * const result = await stt.transcribeBatch(tamilAudioBuffer)
-   * console.log(result.transcript) // Tamil text
-   * ```
-   */
-  async transcribeBatch(audio) {
-    const startMs = Date.now();
-    try {
-      logger3.debug(
-        { language: this.config.language, bytes: audio.length },
-        "Sarvam transcription request"
-      );
-      const form = new FormData();
-      form.append("file", new Blob([audio], { type: "audio/wav" }), "audio.wav");
-      form.append("language_code", this.config.language);
-      form.append("model", this.config.model);
-      if (this.config.smartFormat) {
-        form.append("with_disfluencies", "false");
-      }
-      const response = await this.http.post(
-        "/speech-to-text",
-        form
-      );
-      const data = response.data;
-      logger3.info(
-        { language: data.language_code, confidence: data.confidence, latencyMs: Date.now() - startMs },
-        "Sarvam transcription complete"
-      );
-      return {
-        transcript: data.transcript,
-        isFinal: true,
-        confidence: data.confidence ?? 0.9,
-        language: data.language_code ?? this.config.language,
-        languageSwitchDetected: false,
-        latencyMs: Date.now() - startMs
-      };
-    } catch (err) {
-      if (axios.isAxiosError(err)) {
-        throw new STTStreamError(
-          "sarvam",
-          new Error(`Sarvam API error: ${err.response?.status} ${JSON.stringify(err.response?.data)}`)
-        );
-      }
-      throw new STTStreamError("sarvam", err);
-    }
-  }
-};
-var logger4 = pino({ name: "@voice-kit/core:stt:language-detect" });
-var DEVANAGARI_RANGE = /[\u0900-\u097F]/;
-var MIN_WORDS_FOR_CLASSIFICATION = 2;
-var SWITCH_CONFIDENCE_THRESHOLD = 0.6;
-var NEUTRAL_TOKENS = /* @__PURE__ */ new Set([
-  "ok",
-  "okay",
-  "haan",
-  "nahin",
-  "nahi",
-  "kya",
-  "hai",
-  "ho",
-  "na",
-  "toh",
-  "aur",
-  "ya",
-  "matlab",
-  "yani",
-  "i",
-  "a",
-  "the",
-  "is",
-  "are",
-  "and",
-  "or"
-]);
-var LanguageSwitchDetector = class extends EventEmitter {
-  currentLanguage;
-  primaryLanguage;
-  /** Rolling window of recent language classifications for smoothing. */
-  recentClassifications = [];
-  windowSize = 5;
-  constructor(primaryLanguage = "en-IN") {
-    super();
-    this.primaryLanguage = primaryLanguage;
-    this.currentLanguage = primaryLanguage;
-  }
-  /**
-   * Analyze a transcript for language switches.
-   * Should be called on every STT final result.
-   *
-   * @param transcript  The transcribed text to analyze
-   * @returns           Detected language of the transcript
-   */
-  analyze(transcript) {
-    const words = this.tokenize(transcript);
-    if (words.length === 0) return this.currentLanguage;
-    const classification = this.classifySegment(words);
-    const confidence = this.computeConfidence(words, classification);
-    this.recentClassifications.push(classification);
-    if (this.recentClassifications.length > this.windowSize) {
-      this.recentClassifications.shift();
-    }
-    const smoothed = this.smoothedLanguage();
-    if (smoothed !== this.currentLanguage && confidence >= SWITCH_CONFIDENCE_THRESHOLD && smoothed !== "unknown") {
-      const event = {
-        from: this.currentLanguage,
-        to: smoothed,
-        position: 0,
-        // position in full conversation
-        confidence,
-        transcript,
-        detectedAt: /* @__PURE__ */ new Date()
-      };
-      const prev = this.currentLanguage;
-      this.currentLanguage = smoothed;
-      logger4.info(
-        { from: prev, to: smoothed, confidence, transcript: transcript.slice(0, 50) },
-        "Language switch detected"
-      );
-      this.emit("language.switched", event);
-    }
-    return this.currentLanguage;
-  }
-  /**
-   * Analyze a transcript and return per-word language classification.
-   * Useful for word-level Hinglish mixing visualization.
-   *
-   * @param transcript  Text to analyze
-   * @returns           Array of { word, language } pairs
-   */
-  analyzeWords(transcript) {
-    const words = this.tokenize(transcript);
-    return words.map((word) => ({
-      word,
-      language: this.classifyWord(word)
-    }));
-  }
-  /** Reset to primary language (e.g., on new call). */
-  reset() {
-    this.currentLanguage = this.primaryLanguage;
-    this.recentClassifications = [];
-  }
-  /** Current detected language. */
-  get language() {
-    return this.currentLanguage;
-  }
-  // ─── Private helpers ────────────────────────────────────────────────────────
-  tokenize(text) {
-    return text.toLowerCase().split(/\s+/).filter((w) => w.length > 0 && !NEUTRAL_TOKENS.has(w));
-  }
-  classifyWord(word) {
-    if (DEVANAGARI_RANGE.test(word)) return "hi-IN";
-    if (/^[a-z]+$/.test(word)) return "en-IN";
-    return "unknown";
-  }
-  classifySegment(words) {
-    let hindiCount = 0;
-    let englishCount = 0;
-    for (const word of words) {
-      const lang = this.classifyWord(word);
-      if (lang === "hi-IN") hindiCount++;
-      else if (lang === "en-IN") englishCount++;
-    }
-    if (hindiCount === 0 && englishCount === 0) return "unknown";
-    if (hindiCount > englishCount) return "hi-IN";
-    if (englishCount > hindiCount) return "en-IN";
-    return this.primaryLanguage;
-  }
-  computeConfidence(words, classification) {
-    const relevant = words.filter((w) => this.classifyWord(w) !== "unknown");
-    if (relevant.length < MIN_WORDS_FOR_CLASSIFICATION) return 0;
-    const matching = relevant.filter((w) => this.classifyWord(w) === classification);
-    return matching.length / relevant.length;
-  }
-  smoothedLanguage() {
-    if (this.recentClassifications.length === 0) return this.primaryLanguage;
-    const counts = { "hi-IN": 0, "en-IN": 0, "unknown": 0 };
-    for (const lang of this.recentClassifications) {
-      counts[lang]++;
-    }
-    if (counts["hi-IN"] > counts["en-IN"]) return "hi-IN";
-    if (counts["en-IN"] > counts["hi-IN"]) return "en-IN";
-    return this.currentLanguage;
-  }
-};
-function isInglish(transcript) {
-  const hasDevanagari = DEVANAGARI_RANGE.test(transcript);
-  const hasLatin = /[a-zA-Z]/.test(transcript);
-  return hasDevanagari && hasLatin;
-}
-var logger5 = pino({ name: "@voice-kit/core:stt:whisper" });
-var WHISPER_LANGUAGES = [
-  "en",
-  "hi",
-  "ta",
-  "te",
-  "kn",
-  "mr",
-  "bn",
-  "gu",
-  "pa",
-  "ur",
-  "fr",
-  "de",
-  "es",
-  "pt",
-  "it",
-  "nl",
-  "pl",
-  "ru",
-  "ja",
-  "zh"
-];
-var WhisperSTTProvider = class {
-  name = "whisper";
-  supportsStreaming = false;
-  supportedLanguages = WHISPER_LANGUAGES;
-  config;
-  constructor(config) {
-    const apiKey = config.apiKey ?? process.env["OPENAI_API_KEY"];
-    if (!apiKey) throw new STTStreamError("whisper", new Error("OPENAI_API_KEY not set"));
-    const language = config.language ?? "en-IN";
-    const whisperLang = language.split("-")[0] ?? "en";
-    if (!WHISPER_LANGUAGES.includes(whisperLang)) {
-      throw new STTLanguageNotSupportedError("whisper", language);
-    }
-    this.config = {
-      language,
-      alternateLanguages: config.alternateLanguages ?? [],
-      apiKey,
-      model: config.model ?? "whisper-1",
-      wordTimestamps: config.wordTimestamps ?? false,
-      interimResults: false,
-      smartFormat: false,
-      region: ""
-    };
-  }
-  /**
-   * Streaming not supported by Whisper. Collects all audio then transcribes.
-   * For realtime use, use createSTT('deepgram') instead.
-   */
-  async *transcribeStream(audio) {
-    const chunks = [];
-    for await (const chunk of audio) chunks.push(chunk);
-    const result = await this.transcribeBatch(Buffer.concat(chunks));
-    yield result;
-  }
-  /**
-   * Transcribe a complete audio buffer via Whisper.
-   *
-   * @param audio  WAV or PCM buffer
-   */
-  async transcribeBatch(audio) {
-    const startMs = Date.now();
-    const language = this.config.language.split("-")[0] ?? "en";
-    try {
-      logger5.debug({ language, bytes: audio.length }, "Whisper batch transcription");
-      const openai = createOpenAI({ apiKey: this.config.apiKey });
-      const file = new File([audio], "audio.wav", { type: "audio/wav" });
-      const formData = new FormData();
-      formData.append("file", file);
-      formData.append("model", this.config.model);
-      formData.append("language", language);
-      if (this.config.wordTimestamps) {
-        formData.append("timestamp_granularities[]", "word");
-        formData.append("response_format", "verbose_json");
-      }
-      const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
-        method: "POST",
-        headers: { Authorization: `Bearer ${this.config.apiKey}` },
-        body: formData
-      });
-      if (!response.ok) {
-        throw new Error(`Whisper API error: ${response.status} ${response.statusText}`);
-      }
-      const data = await response.json();
-      return {
-        transcript: data.text,
-        isFinal: true,
-        confidence: 0.95,
-        // Whisper doesn't return confidence
-        language: this.config.language,
-        languageSwitchDetected: false,
-        words: this.config.wordTimestamps && data.words ? data.words.map((w) => ({
-          word: w.word,
-          startMs: w.start * 1e3,
-          endMs: w.end * 1e3,
-          confidence: 0.95
-        })) : void 0,
-        latencyMs: Date.now() - startMs
-      };
-    } catch (err) {
-      if (err instanceof STTStreamError) throw err;
-      throw new STTStreamError("whisper", err);
-    }
-  }
-};
-
-// src/stt/STT-factory.ts
-function createSTT(provider, config) {
-  const cfg = config ?? {};
-  switch (provider) {
-    case "deepgram":
-      return new DeepgramSTTProvider(cfg);
-    case "whisper":
-      return new WhisperSTTProvider(cfg);
-    case "assemblyai":
-      return new AssemblyAISTTProvider(cfg);
-    case "sarvam":
-      return new SarvamSTTProvider(cfg);
-    default: {
-      const _exhaustive = provider;
-      throw new Error(`Unknown STT provider: ${String(_exhaustive)}`);
-    }
-  }
-}
-
-export { AssemblyAISTTProvider, DeepgramSTTProvider, LanguageSwitchDetector, SarvamSTTProvider, WhisperSTTProvider, createSTT, isInglish };
-//# sourceMappingURL=stt.js.map
-//# sourceMappingURL=stt.js.map