@dexto/core 1.4.0 → 1.5.0

package/dist/llm/providers/local/downloader.cjs

@@ -0,0 +1,291 @@
+"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 downloader_exports = {};
+__export(downloader_exports, {
+  calculateFileHash: () => calculateFileHash,
+  checkDiskSpace: () => checkDiskSpace,
+  cleanupPartialDownload: () => cleanupPartialDownload,
+  downloadModel: () => downloadModel,
+  downloadModelFromUrl: () => downloadModelFromUrl,
+  getPartialDownloadProgress: () => getPartialDownloadProgress,
+  isDownloadInProgress: () => isDownloadInProgress,
+  validateDiskSpace: () => validateDiskSpace
+});
+module.exports = __toCommonJS(downloader_exports);
+var import_fs = require("fs");
+var import_crypto = require("crypto");
+var path = __toESM(require("path"), 1);
+var import_errors = require("./errors.js");
+var import_registry = require("./registry.js");
+function buildHuggingFaceUrl(huggingfaceId, filename) {
+  return `https://huggingface.co/${huggingfaceId}/resolve/main/${filename}`;
+}
+async function getPartialSize(filePath) {
+  try {
+    const stats = await import_fs.promises.stat(filePath);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+async function calculateFileHash(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = (0, import_crypto.createHash)("sha256");
+    const stream = (0, import_fs.createReadStream)(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+function createProgressEvent(modelId, status, bytesDownloaded, totalBytes, speed, eta, error) {
+  const progress = {
+    modelId,
+    status,
+    bytesDownloaded,
+    totalBytes,
+    percentage: totalBytes > 0 ? bytesDownloaded / totalBytes * 100 : 0
+  };
+  if (speed !== void 0) {
+    progress.speed = speed;
+  }
+  if (eta !== void 0) {
+    progress.eta = eta;
+  }
+  if (error !== void 0) {
+    progress.error = error;
+  }
+  return progress;
+}
+async function downloadFromHuggingFace(url, targetPath, options, modelId, expectedSize) {
+  const { events, hfToken, signal } = options;
+  const tempPath = `${targetPath}.download`;
+  const partialSize = await getPartialSize(tempPath);
+  const resumed = partialSize > 0;
+  const headers = {
+    "User-Agent": "Dexto/1.0"
+  };
+  if (hfToken) {
+    headers["Authorization"] = `Bearer ${hfToken}`;
+  }
+  if (partialSize > 0) {
+    headers["Range"] = `bytes=${partialSize}-`;
+  }
+  try {
+    const fetchOptions = { headers };
+    if (signal) {
+      fetchOptions.signal = signal;
+    }
+    const response = await fetch(url, fetchOptions);
+    if (response.status === 401 || response.status === 403) {
+      throw import_errors.LocalModelError.hfAuthRequired(modelId);
+    }
+    if (!response.ok && response.status !== 206) {
+      throw import_errors.LocalModelError.downloadFailed(
+        modelId,
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
+    const totalSize = partialSize + contentLength;
+    await import_fs.promises.mkdir(path.dirname(tempPath), { recursive: true });
+    const writeStream = (0, import_fs.createWriteStream)(tempPath, {
+      flags: resumed ? "a" : "w"
+    });
+    let bytesDownloaded = partialSize;
+    const startTime = Date.now();
+    let lastProgressUpdate = startTime;
+    const reader = response.body?.getReader();
+    if (!reader) {
+      writeStream.destroy();
+      throw import_errors.LocalModelError.downloadFailed(modelId, "No response body");
+    }
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        writeStream.write(value);
+        bytesDownloaded += value.length;
+        const now = Date.now();
+        if (now - lastProgressUpdate > 100 || done) {
+          lastProgressUpdate = now;
+          const elapsedSeconds = (now - startTime) / 1e3;
+          const speed = elapsedSeconds > 0 ? (bytesDownloaded - partialSize) / elapsedSeconds : 0;
+          const remainingBytes = totalSize - bytesDownloaded;
+          const eta = speed > 0 ? remainingBytes / speed : 0;
+          const progress = createProgressEvent(
+            modelId,
+            "downloading",
+            bytesDownloaded,
+            totalSize || expectedSize,
+            speed,
+            eta
+          );
+          events?.onProgress?.(progress);
+        }
+      }
+      await new Promise((resolve, reject) => {
+        writeStream.end((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    } catch (error) {
+      writeStream.destroy();
+      throw error;
+    }
+    events?.onProgress?.(createProgressEvent(modelId, "verifying", bytesDownloaded, totalSize));
+    await import_fs.promises.rename(tempPath, targetPath);
+    const stats = await import_fs.promises.stat(targetPath);
+    events?.onProgress?.(createProgressEvent(modelId, "complete", stats.size, stats.size));
+    return {
+      success: true,
+      filePath: targetPath,
+      sizeBytes: stats.size,
+      resumed
+    };
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw import_errors.LocalModelError.downloadInterrupted(modelId);
+    }
+    throw error;
+  }
+}
+async function downloadModel(modelId, options) {
+  const modelInfo = (0, import_registry.getLocalModelById)(modelId);
+  if (!modelInfo) {
+    throw import_errors.LocalModelError.modelNotFound(modelId);
+  }
+  const targetPath = path.join(options.targetDir, modelInfo.filename);
+  const url = buildHuggingFaceUrl(modelInfo.huggingfaceId, modelInfo.filename);
+  if ((0, import_fs.existsSync)(targetPath)) {
+    const stats = await import_fs.promises.stat(targetPath);
+    if (stats.size === modelInfo.sizeBytes) {
+      return {
+        success: true,
+        filePath: targetPath,
+        sizeBytes: stats.size,
+        resumed: false
+      };
+    }
+    await import_fs.promises.unlink(targetPath);
+  }
+  try {
+    options.events?.onProgress?.(
+      createProgressEvent(modelId, "pending", 0, modelInfo.sizeBytes)
+    );
+    const result = await downloadFromHuggingFace(
+      url,
+      targetPath,
+      options,
+      modelId,
+      modelInfo.sizeBytes
+    );
+    if (options.verifyHash && options.expectedHash) {
+      const actualHash = await calculateFileHash(targetPath);
+      if (actualHash !== options.expectedHash) {
+        await import_fs.promises.unlink(targetPath);
+        throw import_errors.LocalModelError.hashMismatch(modelId, options.expectedHash, actualHash);
+      }
+      result.sha256 = actualHash;
+    }
+    options.events?.onComplete?.(modelId, targetPath);
+    return result;
+  } catch (error) {
+    options.events?.onError?.(modelId, error);
+    throw error;
+  }
+}
+async function downloadModelFromUrl(modelId, url, filename, options) {
+  const targetPath = path.join(options.targetDir, filename);
+  try {
+    options.events?.onProgress?.(createProgressEvent(modelId, "pending", 0, 0));
+    const result = await downloadFromHuggingFace(url, targetPath, options, modelId, 0);
+    options.events?.onComplete?.(modelId, targetPath);
+    return result;
+  } catch (error) {
+    options.events?.onError?.(modelId, error);
+    throw error;
+  }
+}
+async function checkDiskSpace(targetDir) {
+  try {
+    await import_fs.promises.access(targetDir);
+    return Number.MAX_SAFE_INTEGER;
+  } catch {
+    try {
+      await import_fs.promises.mkdir(targetDir, { recursive: true });
+      return Number.MAX_SAFE_INTEGER;
+    } catch {
+      return 0;
+    }
+  }
+}
+async function validateDiskSpace(modelId, requiredBytes, targetDir) {
+  const available = await checkDiskSpace(targetDir);
+  if (available < requiredBytes) {
+    throw import_errors.LocalModelError.insufficientDiskSpace(modelId, requiredBytes, available);
+  }
+}
+async function cleanupPartialDownload(targetDir, filename) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    await import_fs.promises.unlink(tempPath);
+  } catch {
+  }
+}
+async function isDownloadInProgress(targetDir, filename) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    await import_fs.promises.access(tempPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getPartialDownloadProgress(modelId, targetDir, filename, totalBytes) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    const stats = await import_fs.promises.stat(tempPath);
+    return createProgressEvent(modelId, "downloading", stats.size, totalBytes);
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateFileHash,
+  checkDiskSpace,
+  cleanupPartialDownload,
+  downloadModel,
+  downloadModelFromUrl,
+  getPartialDownloadProgress,
+  isDownloadInProgress,
+  validateDiskSpace
+});

package/dist/llm/providers/local/downloader.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Model downloader for local GGUF models.
+ *
+ * Downloads models from HuggingFace with:
+ * - Progress tracking via events
+ * - Resume support for interrupted downloads
+ * - Hash verification after download
+ */
+import type { ModelDownloadProgress } from './types.js';
+/**
+ * Event emitter interface for download progress.
+ */
+export interface DownloadEvents {
+    onProgress?: (progress: ModelDownloadProgress) => void;
+    onComplete?: (modelId: string, filePath: string) => void;
+    onError?: (modelId: string, error: Error) => void;
+}
+/**
+ * Download options.
+ */
+export interface DownloadOptions {
+    /** Directory to save the model */
+    targetDir: string;
+    /** Events for progress tracking */
+    events?: DownloadEvents;
+    /** HuggingFace token for gated models */
+    hfToken?: string;
+    /** Whether to verify hash after download */
+    verifyHash?: boolean;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Expected SHA-256 hash for verification */
+    expectedHash?: string;
+}
+/**
+ * Download result.
+ */
+export interface DownloadResult {
+    /** Whether download succeeded */
+    success: boolean;
+    /** Full path to downloaded file */
+    filePath: string;
+    /** File size in bytes */
+    sizeBytes: number;
+    /** SHA-256 hash of the file */
+    sha256?: string;
+    /** Whether download was resumed from partial */
+    resumed: boolean;
+}
+/**
+ * Calculate SHA-256 hash of a file.
+ */
+export declare function calculateFileHash(filePath: string): Promise<string>;
+/**
+ * Download a local model by ID.
+ */
+export declare function downloadModel(modelId: string, options: DownloadOptions): Promise<DownloadResult>;
+/**
+ * Download a model directly from a URL (for custom models).
+ */
+export declare function downloadModelFromUrl(modelId: string, url: string, filename: string, options: DownloadOptions): Promise<DownloadResult>;
+/**
+ * Check available disk space at a path.
+ */
+export declare function checkDiskSpace(targetDir: string): Promise<number>;
+/**
+ * Validate that there's enough disk space for a model.
+ */
+export declare function validateDiskSpace(modelId: string, requiredBytes: number, targetDir: string): Promise<void>;
+/**
+ * Clean up partial download files.
+ */
+export declare function cleanupPartialDownload(targetDir: string, filename: string): Promise<void>;
+/**
+ * Check if a download is in progress (partial file exists).
+ */
+export declare function isDownloadInProgress(targetDir: string, filename: string): Promise<boolean>;
+/**
+ * Get the progress of a partial download.
+ */
+export declare function getPartialDownloadProgress(modelId: string, targetDir: string, filename: string, totalBytes: number): Promise<ModelDownloadProgress | null>;
+//# sourceMappingURL=downloader.d.ts.map

package/dist/llm/providers/local/downloader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloader.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/downloader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,YAAY,CAAC;AAI7E;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACvD,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B,iCAAiC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,OAAO,EAAE,OAAO,CAAC;CACpB;AAsBD;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASzE;AAqLD;;GAEG;AACH,wBAAsB,aAAa,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,GACzB,OAAO,CAAC,cAAc,CAAC,CAwDzB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,eAAe,GACzB,OAAO,CAAC,cAAc,CAAC,CAczB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAevE;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/F;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQhG;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACnB,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAQvC"}

package/dist/llm/providers/local/downloader.js

@@ -0,0 +1,251 @@
+import "../../../chunk-PTJYTZNU.js";
+import { createWriteStream, promises as fs, existsSync, createReadStream } from "fs";
+import { createHash } from "crypto";
+import * as path from "path";
+import { LocalModelError } from "./errors.js";
+import { getLocalModelById } from "./registry.js";
+function buildHuggingFaceUrl(huggingfaceId, filename) {
+  return `https://huggingface.co/${huggingfaceId}/resolve/main/${filename}`;
+}
+async function getPartialSize(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+async function calculateFileHash(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+function createProgressEvent(modelId, status, bytesDownloaded, totalBytes, speed, eta, error) {
+  const progress = {
+    modelId,
+    status,
+    bytesDownloaded,
+    totalBytes,
+    percentage: totalBytes > 0 ? bytesDownloaded / totalBytes * 100 : 0
+  };
+  if (speed !== void 0) {
+    progress.speed = speed;
+  }
+  if (eta !== void 0) {
+    progress.eta = eta;
+  }
+  if (error !== void 0) {
+    progress.error = error;
+  }
+  return progress;
+}
+async function downloadFromHuggingFace(url, targetPath, options, modelId, expectedSize) {
+  const { events, hfToken, signal } = options;
+  const tempPath = `${targetPath}.download`;
+  const partialSize = await getPartialSize(tempPath);
+  const resumed = partialSize > 0;
+  const headers = {
+    "User-Agent": "Dexto/1.0"
+  };
+  if (hfToken) {
+    headers["Authorization"] = `Bearer ${hfToken}`;
+  }
+  if (partialSize > 0) {
+    headers["Range"] = `bytes=${partialSize}-`;
+  }
+  try {
+    const fetchOptions = { headers };
+    if (signal) {
+      fetchOptions.signal = signal;
+    }
+    const response = await fetch(url, fetchOptions);
+    if (response.status === 401 || response.status === 403) {
+      throw LocalModelError.hfAuthRequired(modelId);
+    }
+    if (!response.ok && response.status !== 206) {
+      throw LocalModelError.downloadFailed(
+        modelId,
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
+    const totalSize = partialSize + contentLength;
+    await fs.mkdir(path.dirname(tempPath), { recursive: true });
+    const writeStream = createWriteStream(tempPath, {
+      flags: resumed ? "a" : "w"
+    });
+    let bytesDownloaded = partialSize;
+    const startTime = Date.now();
+    let lastProgressUpdate = startTime;
+    const reader = response.body?.getReader();
+    if (!reader) {
+      writeStream.destroy();
+      throw LocalModelError.downloadFailed(modelId, "No response body");
+    }
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        writeStream.write(value);
+        bytesDownloaded += value.length;
+        const now = Date.now();
+        if (now - lastProgressUpdate > 100 || done) {
+          lastProgressUpdate = now;
+          const elapsedSeconds = (now - startTime) / 1e3;
+          const speed = elapsedSeconds > 0 ? (bytesDownloaded - partialSize) / elapsedSeconds : 0;
+          const remainingBytes = totalSize - bytesDownloaded;
+          const eta = speed > 0 ? remainingBytes / speed : 0;
+          const progress = createProgressEvent(
+            modelId,
+            "downloading",
+            bytesDownloaded,
+            totalSize || expectedSize,
+            speed,
+            eta
+          );
+          events?.onProgress?.(progress);
+        }
+      }
+      await new Promise((resolve, reject) => {
+        writeStream.end((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    } catch (error) {
+      writeStream.destroy();
+      throw error;
+    }
+    events?.onProgress?.(createProgressEvent(modelId, "verifying", bytesDownloaded, totalSize));
+    await fs.rename(tempPath, targetPath);
+    const stats = await fs.stat(targetPath);
+    events?.onProgress?.(createProgressEvent(modelId, "complete", stats.size, stats.size));
+    return {
+      success: true,
+      filePath: targetPath,
+      sizeBytes: stats.size,
+      resumed
+    };
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw LocalModelError.downloadInterrupted(modelId);
+    }
+    throw error;
+  }
+}
+async function downloadModel(modelId, options) {
+  const modelInfo = getLocalModelById(modelId);
+  if (!modelInfo) {
+    throw LocalModelError.modelNotFound(modelId);
+  }
+  const targetPath = path.join(options.targetDir, modelInfo.filename);
+  const url = buildHuggingFaceUrl(modelInfo.huggingfaceId, modelInfo.filename);
+  if (existsSync(targetPath)) {
+    const stats = await fs.stat(targetPath);
+    if (stats.size === modelInfo.sizeBytes) {
+      return {
+        success: true,
+        filePath: targetPath,
+        sizeBytes: stats.size,
+        resumed: false
+      };
+    }
+    await fs.unlink(targetPath);
+  }
+  try {
+    options.events?.onProgress?.(
+      createProgressEvent(modelId, "pending", 0, modelInfo.sizeBytes)
+    );
+    const result = await downloadFromHuggingFace(
+      url,
+      targetPath,
+      options,
+      modelId,
+      modelInfo.sizeBytes
+    );
+    if (options.verifyHash && options.expectedHash) {
+      const actualHash = await calculateFileHash(targetPath);
+      if (actualHash !== options.expectedHash) {
+        await fs.unlink(targetPath);
+        throw LocalModelError.hashMismatch(modelId, options.expectedHash, actualHash);
+      }
+      result.sha256 = actualHash;
+    }
+    options.events?.onComplete?.(modelId, targetPath);
+    return result;
+  } catch (error) {
+    options.events?.onError?.(modelId, error);
+    throw error;
+  }
+}
+async function downloadModelFromUrl(modelId, url, filename, options) {
+  const targetPath = path.join(options.targetDir, filename);
+  try {
+    options.events?.onProgress?.(createProgressEvent(modelId, "pending", 0, 0));
+    const result = await downloadFromHuggingFace(url, targetPath, options, modelId, 0);
+    options.events?.onComplete?.(modelId, targetPath);
+    return result;
+  } catch (error) {
+    options.events?.onError?.(modelId, error);
+    throw error;
+  }
+}
+async function checkDiskSpace(targetDir) {
+  try {
+    await fs.access(targetDir);
+    return Number.MAX_SAFE_INTEGER;
+  } catch {
+    try {
+      await fs.mkdir(targetDir, { recursive: true });
+      return Number.MAX_SAFE_INTEGER;
+    } catch {
+      return 0;
+    }
+  }
+}
+async function validateDiskSpace(modelId, requiredBytes, targetDir) {
+  const available = await checkDiskSpace(targetDir);
+  if (available < requiredBytes) {
+    throw LocalModelError.insufficientDiskSpace(modelId, requiredBytes, available);
+  }
+}
+async function cleanupPartialDownload(targetDir, filename) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    await fs.unlink(tempPath);
+  } catch {
+  }
+}
+async function isDownloadInProgress(targetDir, filename) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    await fs.access(tempPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getPartialDownloadProgress(modelId, targetDir, filename, totalBytes) {
+  const tempPath = path.join(targetDir, `${filename}.download`);
+  try {
+    const stats = await fs.stat(tempPath);
+    return createProgressEvent(modelId, "downloading", stats.size, totalBytes);
+  } catch {
+    return null;
+  }
+}
+export {
+  calculateFileHash,
+  checkDiskSpace,
+  cleanupPartialDownload,
+  downloadModel,
+  downloadModelFromUrl,
+  getPartialDownloadProgress,
+  isDownloadInProgress,
+  validateDiskSpace
+};

package/dist/llm/providers/local/error-codes.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_codes_exports = {};
+__export(error_codes_exports, {
+  LocalModelErrorCode: () => LocalModelErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var LocalModelErrorCode = /* @__PURE__ */ ((LocalModelErrorCode2) => {
+  LocalModelErrorCode2["NODE_LLAMA_NOT_INSTALLED"] = "LOCAL_001";
+  LocalModelErrorCode2["NODE_LLAMA_INSTALL_FAILED"] = "LOCAL_002";
+  LocalModelErrorCode2["CMAKE_NOT_FOUND"] = "LOCAL_003";
+  LocalModelErrorCode2["BUILD_FAILED"] = "LOCAL_004";
+  LocalModelErrorCode2["DOWNLOAD_FAILED"] = "LOCAL_010";
+  LocalModelErrorCode2["DOWNLOAD_INTERRUPTED"] = "LOCAL_011";
+  LocalModelErrorCode2["DOWNLOAD_HASH_MISMATCH"] = "LOCAL_012";
+  LocalModelErrorCode2["INSUFFICIENT_DISK_SPACE"] = "LOCAL_013";
+  LocalModelErrorCode2["HF_AUTH_REQUIRED"] = "LOCAL_014";
+  LocalModelErrorCode2["NETWORK_ERROR"] = "LOCAL_015";
+  LocalModelErrorCode2["MODEL_NOT_FOUND"] = "LOCAL_020";
+  LocalModelErrorCode2["MODEL_NOT_DOWNLOADED"] = "LOCAL_021";
+  LocalModelErrorCode2["MODEL_LOAD_FAILED"] = "LOCAL_022";
+  LocalModelErrorCode2["MODEL_CORRUPT"] = "LOCAL_023";
+  LocalModelErrorCode2["INVALID_GGUF"] = "LOCAL_024";
+  LocalModelErrorCode2["CONTEXT_TOO_LARGE"] = "LOCAL_025";
+  LocalModelErrorCode2["GPU_NOT_AVAILABLE"] = "LOCAL_030";
+  LocalModelErrorCode2["INSUFFICIENT_VRAM"] = "LOCAL_031";
+  LocalModelErrorCode2["GPU_DRIVER_ERROR"] = "LOCAL_032";
+  LocalModelErrorCode2["METAL_NOT_AVAILABLE"] = "LOCAL_033";
+  LocalModelErrorCode2["CUDA_NOT_AVAILABLE"] = "LOCAL_034";
+  LocalModelErrorCode2["VULKAN_NOT_AVAILABLE"] = "LOCAL_035";
+  LocalModelErrorCode2["OLLAMA_NOT_RUNNING"] = "LOCAL_040";
+  LocalModelErrorCode2["OLLAMA_MODEL_NOT_FOUND"] = "LOCAL_041";
+  LocalModelErrorCode2["OLLAMA_PULL_FAILED"] = "LOCAL_042";
+  LocalModelErrorCode2["OLLAMA_API_ERROR"] = "LOCAL_043";
+  LocalModelErrorCode2["OLLAMA_VERSION_INCOMPATIBLE"] = "LOCAL_044";
+  return LocalModelErrorCode2;
+})(LocalModelErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalModelErrorCode
+});