@dexto/core 1.4.0 → 1.5.1

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
+});

package/dist/llm/providers/local/error-codes.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Error codes for local model operations.
+ * Format: LOCAL_XXX where XXX groups by category:
+ * - 001-009: Installation errors
+ * - 010-019: Download errors
+ * - 020-029: Model errors
+ * - 030-039: GPU errors
+ * - 040-049: Ollama errors
+ */
+export declare enum LocalModelErrorCode {
+    /** node-llama-cpp package is not installed */
+    NODE_LLAMA_NOT_INSTALLED = "LOCAL_001",
+    /** Failed to install node-llama-cpp */
+    NODE_LLAMA_INSTALL_FAILED = "LOCAL_002",
+    /** CMake not found (required for building from source) */
+    CMAKE_NOT_FOUND = "LOCAL_003",
+    /** Build from source failed */
+    BUILD_FAILED = "LOCAL_004",
+    /** Model download failed */
+    DOWNLOAD_FAILED = "LOCAL_010",
+    /** Download was interrupted */
+    DOWNLOAD_INTERRUPTED = "LOCAL_011",
+    /** Downloaded file hash doesn't match expected */
+    DOWNLOAD_HASH_MISMATCH = "LOCAL_012",
+    /** Insufficient disk space for download */
+    INSUFFICIENT_DISK_SPACE = "LOCAL_013",
+    /** HuggingFace authentication required for gated model */
+    HF_AUTH_REQUIRED = "LOCAL_014",
+    /** Network error during download */
+    NETWORK_ERROR = "LOCAL_015",
+    /** Model not found in registry */
+    MODEL_NOT_FOUND = "LOCAL_020",
+    /** Model not downloaded locally */
+    MODEL_NOT_DOWNLOADED = "LOCAL_021",
+    /** Failed to load model */
+    MODEL_LOAD_FAILED = "LOCAL_022",
+    /** Model file is corrupted */
+    MODEL_CORRUPT = "LOCAL_023",
+    /** Invalid GGUF format */
+    INVALID_GGUF = "LOCAL_024",
+    /** Model context too large for available memory */
+    CONTEXT_TOO_LARGE = "LOCAL_025",
+    /** No GPU acceleration available */
+    GPU_NOT_AVAILABLE = "LOCAL_030",
+    /** Insufficient VRAM for model */
+    INSUFFICIENT_VRAM = "LOCAL_031",
+    /** GPU driver error */
+    GPU_DRIVER_ERROR = "LOCAL_032",
+    /** Metal not available (macOS only) */
+    METAL_NOT_AVAILABLE = "LOCAL_033",
+    /** CUDA not available */
+    CUDA_NOT_AVAILABLE = "LOCAL_034",
+    /** Vulkan not available */
+    VULKAN_NOT_AVAILABLE = "LOCAL_035",
+    /** Ollama server is not running */
+    OLLAMA_NOT_RUNNING = "LOCAL_040",
+    /** Model not found on Ollama server */
+    OLLAMA_MODEL_NOT_FOUND = "LOCAL_041",
+    /** Failed to pull model from Ollama */
+    OLLAMA_PULL_FAILED = "LOCAL_042",
+    /** Ollama API error */
+    OLLAMA_API_ERROR = "LOCAL_043",
+    /** Ollama version incompatible */
+    OLLAMA_VERSION_INCOMPATIBLE = "LOCAL_044"
+}
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/llm/providers/local/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/error-codes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,oBAAY,mBAAmB;IAE3B,8CAA8C;IAC9C,wBAAwB,cAAc;IACtC,uCAAuC;IACvC,yBAAyB,cAAc;IACvC,0DAA0D;IAC1D,eAAe,cAAc;IAC7B,+BAA+B;IAC/B,YAAY,cAAc;IAG1B,4BAA4B;IAC5B,eAAe,cAAc;IAC7B,+BAA+B;IAC/B,oBAAoB,cAAc;IAClC,kDAAkD;IAClD,sBAAsB,cAAc;IACpC,2CAA2C;IAC3C,uBAAuB,cAAc;IACrC,0DAA0D;IAC1D,gBAAgB,cAAc;IAC9B,oCAAoC;IACpC,aAAa,cAAc;IAG3B,kCAAkC;IAClC,eAAe,cAAc;IAC7B,mCAAmC;IACnC,oBAAoB,cAAc;IAClC,2BAA2B;IAC3B,iBAAiB,cAAc;IAC/B,8BAA8B;IAC9B,aAAa,cAAc;IAC3B,0BAA0B;IAC1B,YAAY,cAAc;IAC1B,mDAAmD;IACnD,iBAAiB,cAAc;IAG/B,oCAAoC;IACpC,iBAAiB,cAAc;IAC/B,kCAAkC;IAClC,iBAAiB,cAAc;IAC/B,uBAAuB;IACvB,gBAAgB,cAAc;IAC9B,uCAAuC;IACvC,mBAAmB,cAAc;IACjC,yBAAyB;IACzB,kBAAkB,cAAc;IAChC,2BAA2B;IAC3B,oBAAoB,cAAc;IAGlC,mCAAmC;IACnC,kBAAkB,cAAc;IAChC,uCAAuC;IACvC,sBAAsB,cAAc;IACpC,uCAAuC;IACvC,kBAAkB,cAAc;IAChC,uBAAuB;IACvB,gBAAgB,cAAc;IAC9B,kCAAkC;IAClC,2BAA2B,cAAc;CAC5C"}

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

@@ -0,0 +1,34 @@
+import "../../../chunk-PTJYTZNU.js";
+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 || {});
+export {
+  LocalModelErrorCode
+};

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

@@ -0,0 +1,240 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  LocalModelError: () => LocalModelError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_DextoRuntimeError = require("../../../errors/DextoRuntimeError.js");
+var import_types = require("../../../errors/types.js");
+var import_error_codes = require("./error-codes.js");
+const SCOPE = "local-models";
+const LocalModelError = {
+  // Installation errors
+  nodeLlamaNotInstalled() {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.NODE_LLAMA_NOT_INSTALLED,
+      SCOPE,
+      import_types.ErrorType.NOT_FOUND,
+      'node-llama-cpp is not installed. Run `dexto setup` and select "local" provider to install it.',
+      {},
+      'Run `dexto setup` and select "local" provider to install local model support'
+    );
+  },
+  nodeLlamaInstallFailed(error) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.NODE_LLAMA_INSTALL_FAILED,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Failed to install node-llama-cpp: ${error}`,
+      { error },
+      "Check your Node.js version and try again. CMake may be required for your platform."
+    );
+  },
+  cmakeNotFound() {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.CMAKE_NOT_FOUND,
+      SCOPE,
+      import_types.ErrorType.NOT_FOUND,
+      "CMake is required to build node-llama-cpp from source but was not found.",
+      {},
+      "Install CMake: brew install cmake (macOS), apt install cmake (Linux), or download from cmake.org (Windows)"
+    );
+  },
+  // Download errors
+  downloadFailed(modelId, error) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.DOWNLOAD_FAILED,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Failed to download model '${modelId}': ${error}`,
+      { modelId, error },
+      "Check your internet connection and try again"
+    );
+  },
+  downloadInterrupted(modelId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.DOWNLOAD_INTERRUPTED,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Download of model '${modelId}' was interrupted`,
+      { modelId },
+      "Run the download command again to resume"
+    );
+  },
+  hashMismatch(modelId, expected, actual) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.DOWNLOAD_HASH_MISMATCH,
+      SCOPE,
+      import_types.ErrorType.USER,
+      `Downloaded model '${modelId}' has invalid hash. Expected: ${expected}, Got: ${actual}`,
+      { modelId, expected, actual },
+      "Delete the file and download again"
+    );
+  },
+  insufficientDiskSpace(modelId, required, available) {
+    const requiredGB = (required / (1024 * 1024 * 1024)).toFixed(1);
+    const availableGB = (available / (1024 * 1024 * 1024)).toFixed(1);
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.INSUFFICIENT_DISK_SPACE,
+      SCOPE,
+      import_types.ErrorType.USER,
+      `Insufficient disk space to download '${modelId}'. Required: ${requiredGB}GB, Available: ${availableGB}GB`,
+      { modelId, required, available },
+      "Free up disk space or choose a smaller model"
+    );
+  },
+  hfAuthRequired(modelId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.HF_AUTH_REQUIRED,
+      SCOPE,
+      import_types.ErrorType.FORBIDDEN,
+      `Model '${modelId}' is a gated model and requires HuggingFace authentication`,
+      { modelId },
+      "Set HF_TOKEN environment variable or run `huggingface-cli login`"
+    );
+  },
+  // Model errors
+  modelNotFound(modelId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.MODEL_NOT_FOUND,
+      SCOPE,
+      import_types.ErrorType.NOT_FOUND,
+      `Model '${modelId}' not found in local model registry`,
+      { modelId },
+      'Run `dexto setup` and select "local" to see available models'
+    );
+  },
+  modelNotDownloaded(modelId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.MODEL_NOT_DOWNLOADED,
+      SCOPE,
+      import_types.ErrorType.NOT_FOUND,
+      `Model '${modelId}' is not downloaded. Download it first.`,
+      { modelId },
+      'Run `dexto setup` and select "local" to download models'
+    );
+  },
+  modelLoadFailed(modelId, error) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.MODEL_LOAD_FAILED,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Failed to load model '${modelId}': ${error}`,
+      { modelId, error },
+      "The model file may be corrupted. Try re-downloading it."
+    );
+  },
+  modelCorrupt(modelId, filePath) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.MODEL_CORRUPT,
+      SCOPE,
+      import_types.ErrorType.USER,
+      `Model file for '${modelId}' appears to be corrupted`,
+      { modelId, filePath },
+      `Delete ${filePath} and download the model again`
+    );
+  },
+  contextTooLarge(modelId, requested, maxSupported) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.CONTEXT_TOO_LARGE,
+      SCOPE,
+      import_types.ErrorType.USER,
+      `Requested context size ${requested} exceeds model's maximum of ${maxSupported}`,
+      { modelId, requested, maxSupported },
+      `Use a context size of ${maxSupported} or less`
+    );
+  },
+  // GPU errors
+  gpuNotAvailable() {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.GPU_NOT_AVAILABLE,
+      SCOPE,
+      import_types.ErrorType.NOT_FOUND,
+      "No GPU acceleration available. Running on CPU.",
+      {},
+      "For better performance, ensure GPU drivers are installed"
+    );
+  },
+  insufficientVRAM(modelId, required, available) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.INSUFFICIENT_VRAM,
+      SCOPE,
+      import_types.ErrorType.USER,
+      `Model '${modelId}' requires ${required}GB VRAM but only ${available}GB available`,
+      { modelId, required, available },
+      "Use a smaller quantization or reduce GPU layers"
+    );
+  },
+  gpuDriverError(error) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.GPU_DRIVER_ERROR,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `GPU driver error: ${error}`,
+      { error },
+      "Update your GPU drivers"
+    );
+  },
+  // Ollama errors
+  ollamaNotRunning(url) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.OLLAMA_NOT_RUNNING,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Ollama server is not running at ${url}`,
+      { url },
+      "Start Ollama with `ollama serve` or ensure it is running"
+    );
+  },
+  ollamaModelNotFound(modelName) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.OLLAMA_MODEL_NOT_FOUND,
+      SCOPE,
+      import_types.ErrorType.NOT_FOUND,
+      `Model '${modelName}' not found on Ollama server`,
+      { modelName },
+      `Pull the model with \`ollama pull ${modelName}\``
+    );
+  },
+  ollamaPullFailed(modelName, error) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.OLLAMA_PULL_FAILED,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Failed to pull model '${modelName}' from Ollama: ${error}`,
+      { modelName, error },
+      "Check your internet connection and Ollama server status"
+    );
+  },
+  ollamaApiError(error) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.LocalModelErrorCode.OLLAMA_API_ERROR,
+      SCOPE,
+      import_types.ErrorType.THIRD_PARTY,
+      `Ollama API error: ${error}`,
+      { error },
+      "Check Ollama server logs for details"
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalModelError
+});

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

@@ -0,0 +1,31 @@
+/**
+ * Error factory for local model errors.
+ * Follows the project's error factory pattern.
+ */
+import { DextoRuntimeError } from '../../../errors/DextoRuntimeError.js';
+/**
+ * Error factory for local model operations.
+ */
+export declare const LocalModelError: {
+    nodeLlamaNotInstalled(): DextoRuntimeError;
+    nodeLlamaInstallFailed(error: string): DextoRuntimeError;
+    cmakeNotFound(): DextoRuntimeError;
+    downloadFailed(modelId: string, error: string): DextoRuntimeError;
+    downloadInterrupted(modelId: string): DextoRuntimeError;
+    hashMismatch(modelId: string, expected: string, actual: string): DextoRuntimeError;
+    insufficientDiskSpace(modelId: string, required: number, available: number): DextoRuntimeError;
+    hfAuthRequired(modelId: string): DextoRuntimeError;
+    modelNotFound(modelId: string): DextoRuntimeError;
+    modelNotDownloaded(modelId: string): DextoRuntimeError;
+    modelLoadFailed(modelId: string, error: string): DextoRuntimeError;
+    modelCorrupt(modelId: string, filePath: string): DextoRuntimeError;
+    contextTooLarge(modelId: string, requested: number, maxSupported: number): DextoRuntimeError;
+    gpuNotAvailable(): DextoRuntimeError;
+    insufficientVRAM(modelId: string, required: number, available: number): DextoRuntimeError;
+    gpuDriverError(error: string): DextoRuntimeError;
+    ollamaNotRunning(url: string): DextoRuntimeError;
+    ollamaModelNotFound(modelName: string): DextoRuntimeError;
+    ollamaPullFailed(modelName: string, error: string): DextoRuntimeError;
+    ollamaApiError(error: string): DextoRuntimeError;
+};
+//# sourceMappingURL=errors.d.ts.map