@wovin/tranz 0.0.26

package/dist/providers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @wovin/tranz/providers - Transcription provider implementations
+ */
+export { createProvider, MistralProvider, WhisperProvider, GreenPTProvider, VOXTRAL_LIMITS, type ProviderName, type TranscribeParams, type TranscriptionResult, type TranscriptionProvider, } from './utils/transcription/providers.js';
+export { createMistralTranscriber, transcribe, type TranscribeOptions, type MistralTranscriberConfig, } from './utils/transcription/transcribe.js';
+//# sourceMappingURL=providers.d.ts.map

package/dist/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,cAAc,EACd,eAAe,EACf,eAAe,EACf,eAAe,EACf,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,GAC3B,MAAM,oCAAoC,CAAA;AAE3C,OAAO,EACL,wBAAwB,EACxB,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,GAC9B,MAAM,qCAAqC,CAAA"}

package/dist/providers.min.js

@@ -0,0 +1,681 @@
+// src/utils/transcription/providers.ts
+import { spawn } from "child_process";
+import * as fs from "fs";
+
+// src/utils/file-utils.ts
+import path from "path";
+var getName = (filePath) => {
+  return getFileInfo(filePath).name;
+};
+var getFileInfo = (filePath) => {
+  const normed = path.normalize(filePath);
+  return path.parse(normed);
+};
+
+// src/utils/transcription/providers.ts
+import { pipeline } from "stream";
+import { promisify } from "util";
+
+// src/utils/transcription/mime-detection.ts
+function detectAudioMimeType(buffer) {
+  if (buffer.length < 4) return "audio/ogg";
+  let offset = 0;
+  if (buffer[0] === 73 && buffer[1] === 68 && buffer[2] === 51) {
+    if (buffer.length >= 10) {
+      const size = (buffer[6] & 127) << 21 | (buffer[7] & 127) << 14 | (buffer[8] & 127) << 7 | buffer[9] & 127;
+      offset = 10 + size;
+      if (offset >= buffer.length) offset = 0;
+    }
+  }
+  if (buffer.length - offset >= 4) {
+    if (buffer[offset] === 255 && (buffer[offset + 1] === 251 || buffer[offset + 1] === 250) || buffer[offset] === 255 && buffer[offset + 1] === 243 || buffer[offset] === 255 && buffer[offset + 1] === 242) {
+      return "audio/mpeg";
+    }
+    if (buffer[offset] === 79 && buffer[offset + 1] === 103 && buffer[offset + 2] === 103 && buffer[offset + 3] === 83) {
+      return "audio/ogg";
+    }
+    if (buffer[offset] === 82 && buffer[offset + 1] === 73 && buffer[offset + 2] === 70 && buffer[offset + 3] === 70) {
+      return "audio/wav";
+    }
+    if (buffer[offset] === 102 && buffer[offset + 1] === 76 && buffer[offset + 2] === 97 && buffer[offset + 3] === 67) {
+      return "audio/flac";
+    }
+  }
+  return "audio/ogg";
+}
+
+// src/utils/transcription/providers.ts
+function createProvider(providerName, config) {
+  switch (providerName) {
+    case "whisper":
+      return new WhisperProvider(config);
+    case "mistral":
+      return new MistralProvider();
+    case "greenpt":
+      return new GreenPTProvider();
+    default:
+      throw new Error(`Unknown provider: ${providerName}`);
+  }
+}
+var WhisperProvider = class _WhisperProvider {
+  name = "whisper";
+  cacheDir;
+  static DEFAULTS = {
+    DIARIZE: false,
+    SILDUR: "1.3",
+    SILBUF: 0.2,
+    SILTHR: "-35dB",
+    MODEL_KEYS: {
+      tinyd: "ggml-small.en-tdrz.bin",
+      small: "ggml-small.bin",
+      medium: "ggml-medium.bin"
+    },
+    MODELS: {
+      tinyd: "https://huggingface.co/akashmjn/tinydiarize-whisper.cpp/resolve/main/ggml-small.en-tdrz.bin",
+      small: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.bin",
+      medium: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium.bin"
+    }
+  };
+  constructor(config) {
+    this.cacheDir = config?.cacheDir || `${process.env.HOME}/.cache/whisper-models`;
+  }
+  async transcribe(params) {
+    const {
+      audioPath,
+      outputDir = "./out",
+      diarize = _WhisperProvider.DEFAULTS.DIARIZE,
+      modelPath: providedModelPath
+    } = params;
+    let modelPath = providedModelPath;
+    const modelKey = diarize ? "tinyd" : "small";
+    if (!modelPath) {
+      modelPath = await this.ensureRequestedModelIsCached(modelKey);
+    }
+    const sourceFileName = getName(audioPath);
+    const outTransPath = `${outputDir}/${sourceFileName}-transcript`;
+    const tdrz = diarize ? "-tdrz" : "";
+    const args = [
+      tdrz,
+      "-t",
+      "8",
+      "-oj",
+      "-ng",
+      // TODO: consider withGPU option
+      "-f",
+      audioPath,
+      "-m",
+      modelPath,
+      "-of",
+      outTransPath
+    ].filter((arg) => arg !== "");
+    const cmd = `whisper-cli ${args.join(" ")}`;
+    console.log("spawning  ", cmd);
+    const whisperThread = spawn(`whisper-cli`, args);
+    return new Promise((resolveFx) => {
+      let whisperOutput = "";
+      const handleOut = (data) => {
+        const str = data.toString();
+        for (const match of ["[", "main:"]) {
+          if (str.startsWith(match) || str.includes("total time"))
+            console.log(str);
+        }
+        whisperOutput += data;
+      };
+      whisperThread.stdout.on("data", handleOut);
+      whisperThread.stderr.on("data", handleOut);
+      whisperThread.on("close", (code) => {
+        try {
+          const trans = JSON.parse(
+            fs.readFileSync(`${outTransPath}.json`).toString()
+          );
+          const transcriptionArray = trans.result?.transcription || [];
+          const text = transcriptionArray.map((entry) => entry.text).filter((t) => t).join(" ").trim();
+          resolveFx({
+            text: text || "",
+            rawResponse: trans
+          });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          resolveFx({
+            text: "",
+            error: `Failed to parse transcription result: ${errorMessage}`,
+            rawResponse: void 0
+          });
+        }
+      });
+      whisperThread.on("error", (err) => {
+        console.error("Whisper Error", { err, outTransPath, args });
+        resolveFx({
+          text: "",
+          error: `Whisper process error: ${err.message}`
+        });
+      });
+    }).catch((whisperError) => {
+      console.error("Uncaught Whisper Error", whisperError);
+      return {
+        text: "",
+        error: `Uncaught error: ${whisperError instanceof Error ? whisperError.message : String(whisperError)}`
+      };
+    });
+  }
+  async ensureRequestedModelIsCached(modelKey) {
+    if (!_WhisperProvider.DEFAULTS.MODEL_KEYS[modelKey])
+      throw new Error(`${modelKey} not known`);
+    const cachedModelsDirPath = `${this.cacheDir}/models`;
+    if (!fs.existsSync(cachedModelsDirPath)) {
+      fs.mkdirSync(cachedModelsDirPath, { recursive: true });
+    }
+    const modelPath = `${cachedModelsDirPath}/${_WhisperProvider.DEFAULTS.MODEL_KEYS[modelKey]}`;
+    const isModelExisting = fs.existsSync(modelPath);
+    if (!isModelExisting) {
+      const srcURL = _WhisperProvider.DEFAULTS.MODELS[modelKey];
+      console.log(`
+    requested model is missing
+    Fetching ${srcURL} into ${modelPath}
+  `);
+      const data = await fetch(srcURL);
+      if (!data?.body) throw new Error("fetch failed");
+      const streamPipeline = promisify(pipeline);
+      await streamPipeline(
+        data.body,
+        fs.createWriteStream(modelPath)
+      );
+    } else {
+      console.log(`Found ${modelPath} 
+`);
+    }
+    return modelPath;
+  }
+};
+var VOXTRAL_LIMITS = {
+  /** Maximum audio duration in seconds (3 hours for Voxtral Transcribe 2) */
+  maxAudioDurationSec: 3 * 60 * 60,
+  // 10800 seconds = 3 hours
+  /** Recommended max duration before splitting (for reliability) */
+  recommendedMaxDurationSec: 30 * 60,
+  // 30 minutes
+  /** Maximum context biasing words/phrases */
+  maxContextBiasingTerms: 100,
+  /** Maximum file size in bytes (1GB) */
+  maxFileSizeBytes: 1024 * 1024 * 1024
+};
+var MistralProvider = class {
+  name = "mistral";
+  maxAudioDurationSec = VOXTRAL_LIMITS.maxAudioDurationSec;
+  /**
+   * Check if audio duration exceeds recommended limits
+   */
+  static shouldSplit(durationSec) {
+    return durationSec > VOXTRAL_LIMITS.recommendedMaxDurationSec;
+  }
+  /**
+   * Get the recommended max segment duration for splitting
+   */
+  static getRecommendedMaxSegment() {
+    return VOXTRAL_LIMITS.recommendedMaxDurationSec;
+  }
+  async transcribe(params) {
+    const formData = new FormData();
+    if (params.audioUrl) {
+      formData.append("file_url", params.audioUrl);
+    } else {
+      let audioBuffer;
+      let mimeType;
+      if (params.audioBuffer) {
+        audioBuffer = params.audioBuffer;
+        mimeType = params.mimeType || detectAudioMimeType(audioBuffer);
+      } else if (params.audioPath) {
+        audioBuffer = fs.readFileSync(params.audioPath);
+        mimeType = detectAudioMimeType(audioBuffer);
+      } else {
+        return { text: "", error: "No audio input provided (audioPath, audioBuffer, or audioUrl required)" };
+      }
+      const extension = mimeType === "audio/mpeg" ? "mp3" : mimeType === "audio/wav" ? "wav" : mimeType === "audio/flac" ? "flac" : "ogg";
+      const audioBlob = new Blob([new Uint8Array(audioBuffer)], { type: mimeType });
+      formData.append("file", audioBlob, `audio.${extension}`);
+    }
+    const model = params.model || "voxtral-mini-latest";
+    formData.append("model", model);
+    if (params.language) {
+      formData.append("language", params.language);
+    }
+    const timestampGranularity = params.timestampGranularity ?? (params.language ? void 0 : "word");
+    if (timestampGranularity) {
+      formData.append("timestamp_granularities", timestampGranularity);
+    }
+    const diarize = params.diarize ?? true;
+    if (diarize) {
+      formData.append("diarize", "true");
+    }
+    const response = await fetch("https://api.mistral.ai/v1/audio/transcriptions", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${params.apiKey}`
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      return { text: "", error: `API returned ${response.status}: ${errorText}` };
+    }
+    const result = await response.json();
+    if (!result?.text) {
+      return { text: "", error: "No transcription returned", rawResponse: result };
+    }
+    const words = result.words || result.segments?.flatMap((seg) => seg.words || []);
+    const duration = result.usage?.prompt_audio_seconds;
+    return {
+      text: result.text,
+      language: result.language ?? params.language,
+      model: result.model,
+      duration,
+      words,
+      rawResponse: result
+    };
+  }
+};
+var GreenPTProvider = class {
+  name = "greenpt";
+  async transcribe(params) {
+    if (!params.apiKey) {
+      return { text: "", error: "API key is required for GreenPT provider" };
+    }
+    if (!params.audioPath) {
+      return { text: "", error: "Audio path is required" };
+    }
+    try {
+      const audioBuffer = fs.readFileSync(params.audioPath);
+      const mimeType = detectAudioMimeType(audioBuffer);
+      const formData = new FormData();
+      const extension = mimeType === "audio/mpeg" ? "mp3" : mimeType === "audio/wav" ? "wav" : mimeType === "audio/flac" ? "flac" : "ogg";
+      const audioBlob = new Blob([new Uint8Array(audioBuffer)], { type: mimeType });
+      formData.append("file", audioBlob, `audio.${extension}`);
+      const queryParams = new URLSearchParams();
+      const model = params.model || "green-s-pro";
+      queryParams.append("model", model);
+      if (params.language) {
+        queryParams.append("language", params.language);
+      }
+      if (params.diarize !== void 0) {
+        queryParams.append("diarize", String(params.diarize));
+      }
+      queryParams.append("punctuate", "true");
+      const url = `https://api.greenpt.ai/v1/listen?${queryParams.toString()}`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${params.apiKey}`
+        },
+        body: formData
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          text: "",
+          error: `API returned ${response.status}: ${errorText}`
+        };
+      }
+      const result = await response.json();
+      const transcript = result?.results?.channels?.[0]?.alternatives?.[0];
+      if (!transcript) {
+        return {
+          text: "",
+          error: "No transcription returned",
+          rawResponse: result
+        };
+      }
+      let text = transcript.transcript;
+      if (!text && transcript.words && transcript.words.length > 0) {
+        text = transcript.words.map((w) => w.word).join(" ");
+      }
+      return {
+        text: text || "",
+        confidence: transcript.confidence,
+        words: transcript.words,
+        duration: result?.metadata?.duration,
+        rawResponse: result
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        text: "",
+        error: `Transcription failed: ${errorMessage}`
+      };
+    }
+  }
+};
+
+// src/utils/transcription/transcribe.ts
+import * as fs3 from "fs";
+import * as os from "os";
+import * as path3 from "path";
+
+// src/utils/audio/split.ts
+import ffmpeg from "fluent-ffmpeg";
+import * as fs2 from "fs";
+import path2 from "path";
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_SPLIT_CONFIG = {
+  maxDurationSec: 600,
+  // 10 minutes
+  minSilenceDurSec: 1,
+  silenceThreshold: "-35dB",
+  preferLongerSilence: true,
+  silenceBuffer: 0.2
+};
+async function getAudioDuration(audioPath) {
+  return new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(audioPath, (err, metadata) => {
+      if (err) {
+        reject(new Error(`Failed to probe audio: ${err.message}`));
+        return;
+      }
+      const duration = metadata.format.duration;
+      if (typeof duration !== "number") {
+        reject(new Error("Could not determine audio duration"));
+        return;
+      }
+      resolve(duration);
+    });
+  });
+}
+async function detectSilenceRegions(audioPath, config = {}) {
+  const { minSilenceDurSec, silenceThreshold } = { ...DEFAULT_SPLIT_CONFIG, ...config };
+  return new Promise((resolve, reject) => {
+    const silenceRegions = [];
+    const args = [
+      "-i",
+      audioPath,
+      "-af",
+      `silencedetect=n=${silenceThreshold}:d=${minSilenceDurSec}`,
+      "-f",
+      "wav",
+      "-ac",
+      "1",
+      "-ar",
+      "8000",
+      "pipe:1"
+    ];
+    const proc = spawn2("ffmpeg", args);
+    proc.stdout.on("data", () => {
+    });
+    proc.stderr.on("data", (data) => {
+      const lines = data.toString().split("\n");
+      for (const line of lines) {
+        if (line.includes("silence_end:")) {
+          const match = line.match(/silence_end:\s*([\d.]+)\s*\|\s*silence_duration:\s*([\d.]+)/);
+          if (match) {
+            const endSec = parseFloat(match[1]);
+            const durationSec = parseFloat(match[2]);
+            if (!isNaN(endSec) && !isNaN(durationSec)) {
+              silenceRegions.push({
+                startSec: endSec - durationSec,
+                endSec,
+                durationSec
+              });
+            }
+          }
+        }
+      }
+    });
+    proc.on("close", (code) => {
+      if (code === 0 || silenceRegions.length > 0) {
+        resolve(silenceRegions);
+      } else {
+        reject(new Error(`FFmpeg exited with code ${code}`));
+      }
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Silence detection failed: ${err.message}`));
+    });
+  });
+}
+function findOptimalSplitPoints(silenceRegions, totalDuration, config = {}) {
+  const { maxDurationSec, preferLongerSilence, silenceBuffer } = {
+    ...DEFAULT_SPLIT_CONFIG,
+    ...config
+  };
+  if (totalDuration <= maxDurationSec) {
+    return [];
+  }
+  const numSegments = Math.ceil(totalDuration / maxDurationSec);
+  const idealSegmentDuration = totalDuration / numSegments;
+  const splitPoints = [];
+  for (let i = 1; i < numSegments; i++) {
+    const idealSplitTime = idealSegmentDuration * i;
+    const windowSize = idealSegmentDuration * 0.3;
+    const windowStart = idealSplitTime - windowSize;
+    const windowEnd = idealSplitTime + windowSize;
+    const candidateSilences = silenceRegions.filter((silence) => {
+      const silenceMid = (silence.startSec + silence.endSec) / 2;
+      return silenceMid >= windowStart && silenceMid <= windowEnd;
+    });
+    let bestSplitPoint;
+    if (candidateSilences.length > 0) {
+      let bestScore = -Infinity;
+      let bestSilence = candidateSilences[0];
+      for (const silence of candidateSilences) {
+        const silenceMid = (silence.startSec + silence.endSec) / 2;
+        const proximityScore = 1 - Math.abs(silenceMid - idealSplitTime) / windowSize;
+        const score = preferLongerSilence ? silence.durationSec * proximityScore : proximityScore;
+        if (score > bestScore) {
+          bestScore = score;
+          bestSilence = silence;
+        }
+      }
+      bestSplitPoint = {
+        timeSec: (bestSilence.startSec + bestSilence.endSec) / 2,
+        silenceDuration: bestSilence.durationSec
+      };
+    } else {
+      bestSplitPoint = {
+        timeSec: idealSplitTime,
+        silenceDuration: 0
+      };
+    }
+    splitPoints.push(bestSplitPoint);
+  }
+  return splitPoints.sort((a, b) => a.timeSec - b.timeSec);
+}
+async function splitAudioAtPoints(audioPath, splitPoints, totalDuration, outputDir, baseName) {
+  fs2.mkdirSync(outputDir, { recursive: true });
+  const segments = [];
+  const boundaries = [0, ...splitPoints.map((sp) => sp.timeSec), totalDuration];
+  const splitPromises = [];
+  for (let i = 0; i < boundaries.length - 1; i++) {
+    const startSec = boundaries[i];
+    const endSec = boundaries[i + 1];
+    const durationSec = endSec - startSec;
+    const outputPath = path2.join(outputDir, `${baseName}-segment-${i.toString().padStart(3, "0")}.wav`);
+    const segment = {
+      index: i,
+      startSec,
+      endSec,
+      durationSec,
+      outputPath
+    };
+    segments.push(segment);
+    const extractPromise = new Promise((resolve, reject) => {
+      ffmpeg(audioPath).setStartTime(startSec).setDuration(durationSec).audioFrequency(16e3).outputOptions(["-ac 1", "-c:a pcm_s16le"]).output(outputPath).on("error", (err) => reject(new Error(`Failed to extract segment ${i}: ${err.message}`))).on("end", () => resolve()).run();
+    });
+    splitPromises.push(extractPromise);
+  }
+  await Promise.all(splitPromises);
+  return segments;
+}
+async function autoSplitAudio(audioPath, outputDir, config = {}) {
+  const mergedConfig = { ...DEFAULT_SPLIT_CONFIG, ...config };
+  const totalDuration = await getAudioDuration(audioPath);
+  if (totalDuration <= mergedConfig.maxDurationSec) {
+    return [
+      {
+        index: 0,
+        startSec: 0,
+        endSec: totalDuration,
+        durationSec: totalDuration,
+        outputPath: audioPath
+      }
+    ];
+  }
+  const silenceRegions = await detectSilenceRegions(audioPath, mergedConfig);
+  const splitPoints = findOptimalSplitPoints(silenceRegions, totalDuration, mergedConfig);
+  const baseName = path2.basename(audioPath, path2.extname(audioPath));
+  const segments = await splitAudioAtPoints(
+    audioPath,
+    splitPoints,
+    totalDuration,
+    outputDir,
+    baseName
+  );
+  return segments;
+}
+
+// src/utils/audio/merge-results.ts
+function mergeTranscriptionResults(results, segments) {
+  if (results.length === 0) {
+    return {
+      text: "",
+      error: "No results to merge"
+    };
+  }
+  if (results.length === 1) {
+    return {
+      ...results[0],
+      totalSegments: 1
+    };
+  }
+  const errors = results.map((r, i) => r.error ? `Segment ${i}: ${r.error}` : null).filter(Boolean);
+  if (errors.length > 0) {
+    return {
+      text: "",
+      error: `Errors in segments: ${errors.join("; ")}`
+    };
+  }
+  const mergedText = results.map((r) => r.text.trim()).join("\n\n");
+  const mergedWords = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const segment = segments[i];
+    const words = result.words || result.rawResponse?.words || [];
+    for (const word of words) {
+      mergedWords.push({
+        word: word.word || word.text,
+        start: (word.start || 0) + segment.startSec,
+        end: (word.end || 0) + segment.startSec,
+        confidence: word.confidence,
+        speaker: word.speaker
+      });
+    }
+  }
+  const totalDuration = segments.reduce((sum, seg) => sum + seg.durationSec, 0);
+  const segmentMeta = results.map((r, i) => ({
+    index: i,
+    startSec: segments[i].startSec,
+    endSec: segments[i].endSec,
+    text: r.text.trim()
+  }));
+  const mergedRawResponse = {
+    merged: true,
+    segmentCount: results.length,
+    segments: results.map((r, i) => ({
+      index: i,
+      startSec: segments[i].startSec,
+      rawResponse: r.rawResponse
+    })),
+    words: mergedWords
+  };
+  const firstResult = results[0];
+  return {
+    text: mergedText,
+    words: mergedWords,
+    duration: totalDuration,
+    language: firstResult.language,
+    model: firstResult.model,
+    rawResponse: mergedRawResponse,
+    segments: segmentMeta,
+    totalSegments: results.length
+  };
+}
+
+// src/utils/transcription/transcribe.ts
+function createMistralTranscriber(config) {
+  const provider = new MistralProvider();
+  const defaultModel = config.model || "voxtral-mini-latest";
+  return {
+    /**
+     * Transcribe audio with auto-splitting for long files (file path only)
+     * Diarization and word timestamps enabled by default
+     */
+    async transcribe(options) {
+      const {
+        audioPath,
+        audioBuffer,
+        mimeType,
+        audioUrl,
+        language,
+        model = defaultModel,
+        diarize = true,
+        timestamps = language ? void 0 : "word",
+        autoSplit = true,
+        splitOutputDir
+      } = options;
+      if (audioUrl || audioBuffer) {
+        const result = await provider.transcribe({
+          audioUrl,
+          audioBuffer,
+          mimeType,
+          apiKey: config.apiKey,
+          model,
+          language,
+          diarize,
+          timestampGranularity: timestamps
+        });
+        return { ...result, totalSegments: 1 };
+      }
+      if (!audioPath) {
+        return { text: "", error: "No audio input provided (audioPath, audioBuffer, or audioUrl required)" };
+      }
+      const duration = await getAudioDuration(audioPath);
+      const needsSplit = autoSplit && duration > VOXTRAL_LIMITS.recommendedMaxDurationSec;
+      if (!needsSplit) {
+        const result = await provider.transcribe({
+          audioPath,
+          apiKey: config.apiKey,
+          model,
+          language,
+          diarize,
+          timestampGranularity: timestamps
+        });
+        return { ...result, totalSegments: 1 };
+      }
+      const outDir = splitOutputDir || path3.join(os.tmpdir(), `tranz-split-${Date.now()}`);
+      fs3.mkdirSync(outDir, { recursive: true });
+      const segments = await autoSplitAudio(audioPath, outDir, {
+        maxDurationSec: VOXTRAL_LIMITS.recommendedMaxDurationSec
+      });
+      const results = [];
+      for (const segment of segments) {
+        const result = await provider.transcribe({
+          audioPath: segment.outputPath,
+          apiKey: config.apiKey,
+          model,
+          language,
+          diarize,
+          timestampGranularity: timestamps
+        });
+        results.push(result);
+      }
+      return mergeTranscriptionResults(results, segments);
+    }
+  };
+}
+var transcribe = createMistralTranscriber;
+export {
+  GreenPTProvider,
+  MistralProvider,
+  VOXTRAL_LIMITS,
+  WhisperProvider,
+  createMistralTranscriber,
+  createProvider,
+  transcribe
+};

package/dist/utils/audio/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Audio utilities for tranz-cli
+ */
+export * from './split.js';
+export * from './merge-results.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/audio/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/audio/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA"}