@storyteller-platform/ghost-story 0.0.1

package/dist/cli/config.js

@@ -0,0 +1,285 @@
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getAppDataDir } from "../utilities/FileSystem.js";
+const WHISPER_CPP_VERSION = "1.8.2";
+const WHISPER_MODEL_VERSION = "1.0.0";
+const SILERO_VAD_VERSION = "6.2.0";
+const GITLAB_PROJECT_PATH = "storyteller-platform/storyteller";
+const GITLAB_PROJECT_ID = "67994333";
+const GITLAB_WHIPSER_ML_ID = "2007349";
+const BUILD_VARIANTS = [
+  "darwin-arm64-coreml",
+  "darwin-arm64-cpu",
+  "darwin-x64-cpu",
+  "linux-x64-cuda-12.4.0",
+  "linux-x64-cuda-11.8.0",
+  "linux-x64-vulkan",
+  "linux-x64-rocm",
+  "linux-x64-cpu",
+  "linux-arm64-cpu",
+  "windows-x64-cpu",
+  "windows-x64-cuda-12.4.0",
+  "windows-x64-cuda-11.8.0",
+  "windows-x64-vulkan"
+];
+function getVariantPlatformInfo(variant) {
+  if (variant.startsWith("darwin-arm64")) {
+    return { platform: "darwin", arch: "arm64" };
+  }
+  if (variant.startsWith("darwin-x64")) {
+    return { platform: "darwin", arch: "x64" };
+  }
+  if (variant.startsWith("linux-arm64")) {
+    return { platform: "linux", arch: "arm64" };
+  }
+  if (variant.startsWith("linux-x64")) {
+    return { platform: "linux", arch: "x64" };
+  }
+  if (variant.startsWith("windows-arm64")) {
+    return { platform: "win32", arch: "arm64" };
+  }
+  if (variant.startsWith("windows-x64")) {
+    return { platform: "win32", arch: "x64" };
+  }
+  throw new Error(`Unknown variant: ${variant}`);
+}
+function isVariantCompatibleWithCurrentPlatform(variant) {
+  const currentPlatform = process.platform;
+  const currentArch = process.arch;
+  const variantInfo = getVariantPlatformInfo(variant);
+  return variantInfo.platform === currentPlatform && variantInfo.arch === currentArch;
+}
+function getCompatibleVariants() {
+  return BUILD_VARIANTS.filter(isVariantCompatibleWithCurrentPlatform);
+}
+const WHISPER_MODELS = [
+  "tiny",
+  "tiny.en",
+  "tiny-q5_1",
+  "tiny.en-q5_1",
+  "tiny-q8_0",
+  "base",
+  "base.en",
+  "base-q5_1",
+  "base.en-q5_1",
+  "base-q8_0",
+  "small",
+  "small.en",
+  "small-q5_1",
+  "small.en-q5_1",
+  "small-q8_0",
+  "medium",
+  "medium.en",
+  "medium-q5_0",
+  "medium.en-q5_0",
+  "medium-q8_0",
+  "large-v1",
+  "large-v2",
+  "large-v2-q5_0",
+  "large-v2-q8_0",
+  "large-v3",
+  "large-v3-q5_0",
+  "large-v3-turbo",
+  "large-v3-turbo-q5_0",
+  "large-v3-turbo-q8_0"
+];
+const MODEL_SIZES = {
+  tiny: 77691713,
+  "tiny-q5_1": 32152673,
+  "tiny.en": 77704715,
+  "tiny.en-q5_1": 32166155,
+  "tiny-q8_0": 43537433,
+  base: 147951465,
+  "base.en": 147964211,
+  "base-q5_1": 59707625,
+  "base.en-q5_1": 59721011,
+  "base-q8_0": 81768585,
+  small: 487601967,
+  "small.en": 487614201,
+  "small-q5_1": 190085487,
+  "small.en-q5_1": 190098681,
+  "small-q8_0": 264464607,
+  medium: 1533763059,
+  "medium.en": 1533774781,
+  "medium-q5_0": 539212467,
+  "medium.en-q5_0": 539225533,
+  "medium-q8_0": 823369779,
+  "large-v1": 3094623691,
+  "large-v2": 3094623691,
+  "large-v2-q5_0": 1080732091,
+  "large-v2-q8_0": 1656129691,
+  "large-v3": 3095033483,
+  "large-v3-q5_0": 1081140203,
+  "large-v3-turbo": 1624555275,
+  "large-v3-turbo-q5_0": 574041195,
+  "large-v3-turbo-q8_0": 874188075,
+  "silero-vad": 884595
+};
+function getBinaryDownloadUrl(variant) {
+  const filename = `whisper-cpp-${variant}.tar.gz`;
+  return `https://gitlab.com/api/v4/projects/${GITLAB_PROJECT_ID}/packages/generic/whisper-cpp/${WHISPER_CPP_VERSION}/${filename}`;
+}
+function getModelDownloadUrl(model) {
+  const filename = `ggml-${model}.bin`;
+  return `https://gitlab.com/api/v4/projects/${GITLAB_PROJECT_ID}/packages/ml_models/${GITLAB_WHIPSER_ML_ID}/files/${filename}`;
+}
+function getCoremlModelDownloadUrl(model) {
+  const filename = `ggml-${model}-encoder.mlmodelc.tar.gz`;
+  return `https://gitlab.com/api/v4/projects/${GITLAB_PROJECT_ID}/packages/ml_models/${GITLAB_WHIPSER_ML_ID}/files/coreml/${filename}`;
+}
+function getVadModelDownloadUrl() {
+  return `https://huggingface.co/ggml-org/whisper-vad/resolve/main/ggml-silero-v${SILERO_VAD_VERSION}.bin`;
+}
+function getWhisperBaseDir() {
+  return path.join(
+    getAppDataDir("ghost-story"),
+    "whisper-cpp",
+    WHISPER_CPP_VERSION
+  );
+}
+function getInstallDir(variant) {
+  const baseDir = getWhisperBaseDir();
+  if (variant) {
+    return path.join(baseDir, variant);
+  }
+  const installed = getInstalledVariant();
+  if (installed) {
+    return path.join(baseDir, installed);
+  }
+  return path.join(baseDir, detectPlatform());
+}
+function getInstalledVariant() {
+  const baseDir = getWhisperBaseDir();
+  if (!existsSync(baseDir)) {
+    return null;
+  }
+  const entries = readdirSync(baseDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const variant = entry.name;
+    if (!BUILD_VARIANTS.includes(variant)) continue;
+    const execPath = getWhisperExecutablePath(path.join(baseDir, variant));
+    if (existsSync(execPath)) {
+      return variant;
+    }
+  }
+  return null;
+}
+function getModelDir() {
+  return path.join(getAppDataDir("ghost-story"), "models");
+}
+function getWhisperExecutablePath(installDir) {
+  const dir = installDir ?? getInstallDir();
+  const isWindows = os.platform() === "win32";
+  const executable = isWindows ? "whisper-cli.exe" : "whisper-cli";
+  return path.join(dir, "bin", executable);
+}
+function getVadExecutablePath(installDir) {
+  const dir = installDir ?? getInstallDir();
+  const isWindows = os.platform() === "win32";
+  const executable = isWindows ? "vad-speech-segments.exe" : "vad-speech-segments";
+  return path.join(dir, "bin", executable);
+}
+function getWhisperServerExecutablePath(installDir) {
+  const dir = installDir ?? getInstallDir();
+  const isWindows = os.platform() === "win32";
+  const executable = isWindows ? "whisper-server.exe" : "whisper-server";
+  return path.join(dir, "bin", executable);
+}
+function getModelPath(model, modelDir) {
+  const dir = modelDir ?? getModelDir();
+  return path.join(dir, `ggml-${model}.bin`);
+}
+function getCoremlModelPath(model, modelDir) {
+  const dir = modelDir ?? getModelDir();
+  return path.join(dir, `ggml-${model}-encoder.mlmodelc`);
+}
+function needsCoremlModel(variant) {
+  const v = variant ?? getInstalledVariant() ?? detectPlatform();
+  return v.includes("coreml");
+}
+function getVadModelPath(modelDir) {
+  const dir = modelDir ?? getModelDir();
+  return path.join(dir, `ggml-silero-v${SILERO_VAD_VERSION}.bin`);
+}
+function hasCuda() {
+  try {
+    execSync("nvidia-smi", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasVulkan() {
+  try {
+    execSync("vulkaninfo --summary", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "darwin") {
+    return arch === "arm64" ? "darwin-arm64-coreml" : "darwin-x64-cpu";
+  }
+  if (platform === "linux") {
+    if (hasCuda()) {
+      return "linux-x64-cuda-12.4.0";
+    }
+    if (hasVulkan()) {
+      return "linux-x64-vulkan";
+    }
+    return arch === "arm64" ? "linux-arm64-cpu" : "linux-x64-cpu";
+  }
+  if (platform === "win32") {
+    if (hasCuda()) {
+      return "windows-x64-cuda-12.4.0";
+    }
+    if (hasVulkan()) {
+      return "windows-x64-vulkan";
+    }
+    return "windows-x64-cpu";
+  }
+  throw new Error(`Unsupported platform: ${platform}-${arch}`);
+}
+function isValidModel(model) {
+  return WHISPER_MODELS.includes(model);
+}
+function isValidVariant(variant) {
+  return BUILD_VARIANTS.includes(variant);
+}
+export {
+  BUILD_VARIANTS,
+  GITLAB_PROJECT_ID,
+  GITLAB_PROJECT_PATH,
+  GITLAB_WHIPSER_ML_ID,
+  MODEL_SIZES,
+  SILERO_VAD_VERSION,
+  WHISPER_CPP_VERSION,
+  WHISPER_MODELS,
+  WHISPER_MODEL_VERSION,
+  detectPlatform,
+  getBinaryDownloadUrl,
+  getCompatibleVariants,
+  getCoremlModelDownloadUrl,
+  getCoremlModelPath,
+  getInstallDir,
+  getInstalledVariant,
+  getModelDir,
+  getModelDownloadUrl,
+  getModelPath,
+  getVadExecutablePath,
+  getVadModelDownloadUrl,
+  getVadModelPath,
+  getWhisperBaseDir,
+  getWhisperExecutablePath,
+  getWhisperServerExecutablePath,
+  isValidModel,
+  isValidVariant,
+  isVariantCompatibleWithCurrentPlatform,
+  needsCoremlModel
+};

package/dist/cli/install.cjs

@@ -0,0 +1,334 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var install_exports = {};
+__export(install_exports, {
+  PlatformMismatchError: () => PlatformMismatchError,
+  downloadFile: () => downloadFile,
+  ensureWhisperInstalled: () => ensureWhisperInstalled,
+  installBinary: () => installBinary,
+  installCoremlModel: () => installCoremlModel,
+  installModel: () => installModel,
+  installVadModel: () => installVadModel
+});
+module.exports = __toCommonJS(install_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_promises2 = require("node:stream/promises");
+var import_node_zlib = require("node:zlib");
+var import_tar = require("tar");
+var import_config = require("./config.cjs");
+async function downloadFile(options) {
+  const {
+    url,
+    destPath,
+    expectedSize,
+    printOutput = true,
+    onProgress,
+    signal
+  } = options;
+  console.log(`Downloading file from ${url} to ${destPath}`);
+  const response = await fetch(url, { signal: signal ?? null });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download: ${response.status} ${response.statusText}`
+    );
+  }
+  const contentLength = response.headers.get("content-length");
+  const totalSize = contentLength ? parseInt(contentLength, 10) : expectedSize ?? 0;
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  await (0, import_promises.mkdir)(import_node_path.default.dirname(destPath), { recursive: true });
+  const fileStream = (0, import_node_fs.createWriteStream)(destPath);
+  const reader = response.body.getReader();
+  let downloaded = 0;
+  let lastPrinted = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      downloaded += value.length;
+      fileStream.write(value);
+      onProgress == null ? void 0 : onProgress(downloaded, totalSize);
+      if (printOutput && totalSize > 0) {
+        const shouldPrint = downloaded - lastPrinted > 10 * 1024 * 1024 || downloaded === totalSize;
+        if (shouldPrint) {
+          const percent = (downloaded / totalSize * 100).toFixed(1);
+          console.log(
+            `  ${(downloaded / 1024 / 1024).toFixed(1)} MB / ${(totalSize / 1024 / 1024).toFixed(1)} MB (${percent}%)`
+          );
+          lastPrinted = downloaded;
+        }
+      }
+    }
+  } finally {
+    fileStream.end();
+  }
+  await new Promise((resolve, reject) => {
+    fileStream.on("finish", resolve);
+    fileStream.on("error", reject);
+  });
+}
+class PlatformMismatchError extends Error {
+  constructor(variant, compatibleVariants) {
+    const compatible = compatibleVariants.join(", ");
+    super(
+      `Variant "${variant}" is not compatible with the current platform. Compatible variants: ${compatible}. Use --force to override.`
+    );
+    this.variant = variant;
+    this.compatibleVariants = compatibleVariants;
+    this.name = "PlatformMismatchError";
+  }
+}
+async function installBinary(options = {}) {
+  const {
+    variant = (0, import_config.getInstalledVariant)() ?? (0, import_config.detectPlatform)(),
+    printOutput = true,
+    force = false,
+    signal
+  } = options;
+  if (!force && !(0, import_config.isVariantCompatibleWithCurrentPlatform)(variant)) {
+    throw new PlatformMismatchError(variant, (0, import_config.getCompatibleVariants)());
+  }
+  const installDir = (0, import_config.getInstallDir)(variant);
+  const executablePath = (0, import_config.getWhisperExecutablePath)(installDir);
+  if (!force && (0, import_node_fs.existsSync)(executablePath)) {
+    if (printOutput) {
+      console.log(`whisper.cpp (${variant}) already installed at ${installDir}`);
+    }
+    return installDir;
+  }
+  if (force && (0, import_node_fs.existsSync)(installDir)) {
+    if (printOutput) {
+      console.log(`Removing existing installation at ${installDir}`);
+    }
+    await (0, import_promises.rm)(installDir, { recursive: true });
+  }
+  const url = (0, import_config.getBinaryDownloadUrl)(variant);
+  const tmpDir = import_node_path.default.join(import_node_os.default.tmpdir(), "ghost-story-whisper-install");
+  const tarballPath = import_node_path.default.join(tmpDir, `whisper-cpp-${variant}.tar.gz`);
+  if (printOutput) {
+    console.log(`Downloading whisper.cpp (${variant}) from ${url}`);
+  }
+  await downloadFile({
+    url,
+    destPath: tarballPath,
+    printOutput,
+    signal
+  });
+  if (printOutput) {
+    console.log(`Extracting to ${installDir}`);
+  }
+  await (0, import_promises.mkdir)(installDir, { recursive: true });
+  await (0, import_promises2.pipeline)(
+    (0, import_node_fs.createReadStream)(tarballPath),
+    (0, import_node_zlib.createGunzip)(),
+    (0, import_tar.extract)({ cwd: installDir, strip: 1 })
+  );
+  await (0, import_promises.rm)(tmpDir, { recursive: true }).catch(() => {
+  });
+  if (printOutput) {
+    console.log(`whisper.cpp (${variant}) installed successfully`);
+  }
+  return installDir;
+}
+async function installModel(options) {
+  const {
+    model,
+    modelDir = (0, import_config.getModelDir)(),
+    printOutput = true,
+    force = false,
+    onProgress,
+    signal
+  } = options;
+  const modelPath = (0, import_config.getModelPath)(model, modelDir);
+  const expectedSize = import_config.MODEL_SIZES[model];
+  if (!force && (0, import_node_fs.existsSync)(modelPath)) {
+    const stats = (0, import_node_fs.statSync)(modelPath);
+    if (stats.size === expectedSize) {
+      if (printOutput) {
+        console.log(`Model ${model} already exists at ${modelPath}`);
+      }
+      const installedVariant2 = (0, import_config.getInstalledVariant)();
+      if ((0, import_config.needsCoremlModel)(installedVariant2 ?? void 0)) {
+        await installCoremlModel({
+          model,
+          modelDir,
+          printOutput,
+          force,
+          signal
+        });
+      }
+      return modelPath;
+    }
+    if (printOutput) {
+      console.log(
+        `Model ${model} exists but has wrong size (${stats.size} vs ${expectedSize}), re-downloading`
+      );
+    }
+  }
+  const url = (0, import_config.getModelDownloadUrl)(model);
+  if (printOutput) {
+    console.log(`Downloading model ${model}`);
+  }
+  await downloadFile({
+    url,
+    destPath: modelPath,
+    expectedSize,
+    printOutput,
+    onProgress,
+    signal
+  });
+  const installedVariant = (0, import_config.getInstalledVariant)();
+  if ((0, import_config.needsCoremlModel)(installedVariant ?? void 0)) {
+    await installCoremlModel({ model, modelDir, printOutput, force, signal });
+  }
+  if (printOutput) {
+    console.log(`Model ${model} installed successfully`);
+  }
+  return modelPath;
+}
+async function installCoremlModel(options) {
+  const {
+    model,
+    modelDir = (0, import_config.getModelDir)(),
+    printOutput = true,
+    force = false,
+    signal
+  } = options;
+  const coremlPath = (0, import_config.getCoremlModelPath)(model, modelDir);
+  if (!force && (0, import_node_fs.existsSync)(coremlPath)) {
+    if (printOutput) {
+      console.log(`CoreML model ${model} already exists at ${coremlPath}`);
+    }
+    return coremlPath;
+  }
+  const url = (0, import_config.getCoremlModelDownloadUrl)(model);
+  const tmpDir = import_node_path.default.join(import_node_os.default.tmpdir(), "ghost-story-coreml-install");
+  const tarballPath = import_node_path.default.join(tmpDir, `ggml-${model}-encoder.mlmodelc.tar.gz`);
+  if (printOutput) {
+    console.log(`Downloading CoreML model ${model}`);
+  }
+  await downloadFile({
+    url,
+    destPath: tarballPath,
+    printOutput,
+    signal
+  });
+  if (printOutput) {
+    console.log(`Extracting CoreML model to ${modelDir}`);
+  }
+  await (0, import_promises.mkdir)(modelDir, { recursive: true });
+  await (0, import_promises2.pipeline)(
+    (0, import_node_fs.createReadStream)(tarballPath),
+    (0, import_node_zlib.createGunzip)(),
+    (0, import_tar.extract)({ cwd: modelDir })
+  );
+  await (0, import_promises.rm)(tmpDir, { recursive: true }).catch(() => {
+  });
+  if (printOutput) {
+    console.log(`CoreML model ${model} installed successfully`);
+  }
+  return coremlPath;
+}
+async function installVadModel(options = {}) {
+  const {
+    modelDir = (0, import_config.getModelDir)(),
+    printOutput = true,
+    force = false,
+    onProgress,
+    signal
+  } = options;
+  const modelPath = (0, import_config.getVadModelPath)(modelDir);
+  const expectedSize = import_config.MODEL_SIZES["silero-vad"];
+  if (!force && (0, import_node_fs.existsSync)(modelPath)) {
+    const stats = (0, import_node_fs.statSync)(modelPath);
+    if (stats.size === expectedSize) {
+      if (printOutput) {
+        console.log(`VAD model already exists at ${modelPath}`);
+      }
+      return modelPath;
+    }
+    if (printOutput) {
+      console.log(
+        `VAD model exists but has wrong size (${stats.size} vs ${expectedSize}), re-downloading`
+      );
+    }
+  }
+  const url = (0, import_config.getVadModelDownloadUrl)();
+  if (printOutput) {
+    console.log(`Downloading Silero VAD model`);
+  }
+  await downloadFile({
+    url,
+    destPath: modelPath,
+    expectedSize,
+    printOutput,
+    onProgress,
+    signal
+  });
+  if (printOutput) {
+    console.log(`VAD model installed successfully`);
+  }
+  return modelPath;
+}
+async function ensureWhisperInstalled(options = {}) {
+  const { model, variant, printOutput = false, force = false, signal } = options;
+  const installDir = await installBinary({
+    variant,
+    printOutput,
+    force,
+    signal
+  });
+  let modelPath = null;
+  if (model) {
+    modelPath = await installModel({
+      model,
+      modelDir: options.modelDir,
+      printOutput,
+      force,
+      signal
+    });
+  }
+  return { installDir, modelPath };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlatformMismatchError,
+  downloadFile,
+  ensureWhisperInstalled,
+  installBinary,
+  installCoremlModel,
+  installModel,
+  installVadModel
+});

package/dist/cli/install.d.cts

@@ -0,0 +1,62 @@
+import { BuildVariant, WhisperModel } from './config.cjs';
+
+interface DownloadOptions {
+    url: string;
+    destPath: string;
+    expectedSize?: number;
+    printOutput?: boolean;
+    onProgress?: ((downloaded: number, total: number) => void) | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function downloadFile(options: DownloadOptions): Promise<void>;
+declare class PlatformMismatchError extends Error {
+    readonly variant: BuildVariant;
+    readonly compatibleVariants: BuildVariant[];
+    constructor(variant: BuildVariant, compatibleVariants: BuildVariant[]);
+}
+interface InstallBinaryOptions {
+    variant?: BuildVariant | undefined;
+    printOutput?: boolean | undefined;
+    force?: boolean | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installBinary(options?: InstallBinaryOptions): Promise<string>;
+interface InstallModelOptions {
+    model: WhisperModel;
+    modelDir?: string | undefined;
+    printOutput?: boolean;
+    force?: boolean;
+    onProgress?: ((downloaded: number, total: number) => void) | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installModel(options: InstallModelOptions): Promise<string>;
+interface InstallCoremlModelOptions {
+    model: WhisperModel;
+    modelDir?: string;
+    printOutput?: boolean;
+    force?: boolean;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installCoremlModel(options: InstallCoremlModelOptions): Promise<string>;
+interface InstallVadModelOptions {
+    modelDir?: string;
+    printOutput?: boolean;
+    force?: boolean;
+    onProgress?: (downloaded: number, total: number) => void;
+    signal?: AbortSignal | null | undefined;
+}
+declare function installVadModel(options?: InstallVadModelOptions): Promise<string>;
+interface EnsureInstalledOptions {
+    model?: WhisperModel | undefined;
+    variant?: BuildVariant | undefined;
+    modelDir?: string | undefined;
+    printOutput?: boolean | undefined;
+    force?: boolean | undefined;
+    signal?: AbortSignal | null | undefined;
+}
+declare function ensureWhisperInstalled(options?: EnsureInstalledOptions): Promise<{
+    installDir: string;
+    modelPath: string | null;
+}>;
+
+export { type DownloadOptions, type EnsureInstalledOptions, type InstallBinaryOptions, type InstallCoremlModelOptions, type InstallModelOptions, type InstallVadModelOptions, PlatformMismatchError, downloadFile, ensureWhisperInstalled, installBinary, installCoremlModel, installModel, installVadModel };