@dexto/core 1.4.0 → 1.5.0

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAMzE;;GAEG;AACH,eAAO,MAAM,eAAe;6BAEC,iBAAiB;kCAWZ,MAAM,GAAG,iBAAiB;qBAWvC,iBAAiB;4BAYV,MAAM,SAAS,MAAM,GAAG,iBAAiB;iCAWpC,MAAM,GAAG,iBAAiB;0BAWjC,MAAM,YAAY,MAAM,UAAU,MAAM,GAAG,iBAAiB;mCAWnD,MAAM,YAAY,MAAM,aAAa,MAAM,GAAG,iBAAiB;4BAatE,MAAM,GAAG,iBAAiB;2BAY3B,MAAM,GAAG,iBAAiB;gCAWrB,MAAM,GAAG,iBAAiB;6BAW7B,MAAM,SAAS,MAAM,GAAG,iBAAiB;0BAW5C,MAAM,YAAY,MAAM,GAAG,iBAAiB;6BAWzC,MAAM,aAAa,MAAM,gBAAgB,MAAM,GAAG,iBAAiB;uBAYzE,iBAAiB;8BAWV,MAAM,YAAY,MAAM,aAAa,MAAM,GAAG,iBAAiB;0BAWnE,MAAM,GAAG,iBAAiB;0BAY1B,MAAM,GAAG,iBAAiB;mCAWjB,MAAM,GAAG,iBAAiB;gCAW7B,MAAM,SAAS,MAAM,GAAG,iBAAiB;0BAW/C,MAAM,GAAG,iBAAiB;CAUnD,CAAC"}

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

@@ -0,0 +1,217 @@
+import "../../../chunk-PTJYTZNU.js";
+import { DextoRuntimeError } from "../../../errors/DextoRuntimeError.js";
+import { ErrorType } from "../../../errors/types.js";
+import { LocalModelErrorCode } from "./error-codes.js";
+const SCOPE = "local-models";
+const LocalModelError = {
+  // Installation errors
+  nodeLlamaNotInstalled() {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.NODE_LLAMA_NOT_INSTALLED,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.NODE_LLAMA_INSTALL_FAILED,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.CMAKE_NOT_FOUND,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.DOWNLOAD_FAILED,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Failed to download model '${modelId}': ${error}`,
+      { modelId, error },
+      "Check your internet connection and try again"
+    );
+  },
+  downloadInterrupted(modelId) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.DOWNLOAD_INTERRUPTED,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Download of model '${modelId}' was interrupted`,
+      { modelId },
+      "Run the download command again to resume"
+    );
+  },
+  hashMismatch(modelId, expected, actual) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.DOWNLOAD_HASH_MISMATCH,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.INSUFFICIENT_DISK_SPACE,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.HF_AUTH_REQUIRED,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.MODEL_NOT_FOUND,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.MODEL_NOT_DOWNLOADED,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.MODEL_LOAD_FAILED,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.MODEL_CORRUPT,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.CONTEXT_TOO_LARGE,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.GPU_NOT_AVAILABLE,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      "No GPU acceleration available. Running on CPU.",
+      {},
+      "For better performance, ensure GPU drivers are installed"
+    );
+  },
+  insufficientVRAM(modelId, required, available) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.INSUFFICIENT_VRAM,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.GPU_DRIVER_ERROR,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `GPU driver error: ${error}`,
+      { error },
+      "Update your GPU drivers"
+    );
+  },
+  // Ollama errors
+  ollamaNotRunning(url) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_NOT_RUNNING,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_MODEL_NOT_FOUND,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      `Model '${modelName}' not found on Ollama server`,
+      { modelName },
+      `Pull the model with \`ollama pull ${modelName}\``
+    );
+  },
+  ollamaPullFailed(modelName, error) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_PULL_FAILED,
+      SCOPE,
+      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 DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_API_ERROR,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Ollama API error: ${error}`,
+      { error },
+      "Check Ollama server logs for details"
+    );
+  }
+};
+export {
+  LocalModelError
+};