@dexto/core 1.4.0 → 1.5.0

package/dist/llm/providers/local/gpu-detector.cjs

@@ -0,0 +1,214 @@
+"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 gpu_detector_exports = {};
+__export(gpu_detector_exports, {
+  detectGPU: () => detectGPU,
+  formatGPUInfo: () => formatGPUInfo,
+  getAvailableBackends: () => getAvailableBackends,
+  isBackendAvailable: () => isBackendAvailable
+});
+module.exports = __toCommonJS(gpu_detector_exports);
+var import_child_process = require("child_process");
+var import_util = require("util");
+var os = __toESM(require("os"), 1);
+const execAsync = (0, import_util.promisify)(import_child_process.exec);
+async function detectGPU() {
+  const platform = os.platform();
+  if (platform === "darwin") {
+    const metalInfo = await detectMetal();
+    if (metalInfo.available) {
+      return metalInfo;
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    const cudaInfo = await detectCUDA();
+    if (cudaInfo.available) {
+      return cudaInfo;
+    }
+    const vulkanInfo = await detectVulkan();
+    if (vulkanInfo.available) {
+      return vulkanInfo;
+    }
+  }
+  return {
+    backend: "cpu",
+    available: true,
+    deviceName: `${os.cpus()[0]?.model ?? "Unknown CPU"}`
+  };
+}
+async function detectMetal() {
+  try {
+    const { stdout } = await execAsync("system_profiler SPDisplaysDataType -json 2>/dev/null");
+    const data = JSON.parse(stdout);
+    const gpuData = data?.SPDisplaysDataType?.[0];
+    if (gpuData) {
+      const chipName = gpuData.sppci_model ?? gpuData._name ?? "Apple GPU";
+      const isAppleSilicon = chipName.toLowerCase().includes("apple") || chipName.toLowerCase().includes("m1") || chipName.toLowerCase().includes("m2") || chipName.toLowerCase().includes("m3") || chipName.toLowerCase().includes("m4");
+      const result = {
+        backend: "metal",
+        available: true,
+        deviceName: chipName
+      };
+      if (isAppleSilicon) {
+        result.vramMB = Math.round(os.totalmem() / (1024 * 1024));
+      } else if (gpuData.sppci_vram) {
+        const vramMatch = gpuData.sppci_vram.match(/(\d+)\s*(GB|MB)/i);
+        if (vramMatch) {
+          result.vramMB = parseInt(vramMatch[1]) * (vramMatch[2].toUpperCase() === "GB" ? 1024 : 1);
+        }
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "metal",
+    available: false
+  };
+}
+async function detectCUDA() {
+  try {
+    const { stdout } = await execAsync(
+      "nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits 2>/dev/null"
+    );
+    const lines = stdout.trim().split("\n");
+    if (lines.length > 0 && lines[0]) {
+      const [name, memoryMB, driverVersion] = lines[0].split(", ").map((s) => s.trim());
+      const result = {
+        backend: "cuda",
+        available: true
+      };
+      if (name) {
+        result.deviceName = name;
+      }
+      if (memoryMB) {
+        result.vramMB = parseInt(memoryMB);
+      }
+      if (driverVersion) {
+        result.driverVersion = driverVersion;
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "cuda",
+    available: false
+  };
+}
+async function detectVulkan() {
+  try {
+    const { stdout } = await execAsync("vulkaninfo --summary 2>/dev/null");
+    const deviceMatch = stdout.match(/deviceName\s*=\s*(.+)/);
+    const deviceName = deviceMatch?.[1]?.trim() ?? "Vulkan GPU";
+    const result = {
+      backend: "vulkan",
+      available: true,
+      deviceName
+    };
+    const heapMatch = stdout.match(/heapSize\s*=\s*(\d+)/);
+    if (heapMatch) {
+      result.vramMB = Math.round(parseInt(heapMatch[1]) / (1024 * 1024));
+    }
+    return result;
+  } catch {
+  }
+  if (os.platform() === "linux") {
+    try {
+      const { stdout } = await execAsync('lspci | grep -i "vga\\|3d\\|display" 2>/dev/null');
+      if (stdout.includes("AMD") || stdout.includes("Intel") || stdout.includes("Radeon")) {
+        const deviceMatch = stdout.match(/: (.+)/);
+        return {
+          backend: "vulkan",
+          available: true,
+          deviceName: deviceMatch?.[1]?.trim() ?? "GPU (Vulkan)"
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    backend: "vulkan",
+    available: false
+  };
+}
+function formatGPUInfo(info) {
+  if (!info.available) {
+    return `${info.backend.toUpperCase()} not available`;
+  }
+  const parts = [info.deviceName ?? info.backend.toUpperCase()];
+  if (info.vramMB) {
+    const vramGB = (info.vramMB / 1024).toFixed(1);
+    parts.push(`${vramGB}GB`);
+  }
+  if (info.driverVersion) {
+    parts.push(`Driver: ${info.driverVersion}`);
+  }
+  return parts.join(" \u2022 ");
+}
+async function isBackendAvailable(backend) {
+  switch (backend) {
+    case "metal":
+      return (await detectMetal()).available;
+    case "cuda":
+      return (await detectCUDA()).available;
+    case "vulkan":
+      return (await detectVulkan()).available;
+    case "cpu":
+      return true;
+    default:
+      return false;
+  }
+}
+async function getAvailableBackends() {
+  const backends = [];
+  const platform = os.platform();
+  if (platform === "darwin") {
+    if ((await detectMetal()).available) {
+      backends.push("metal");
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    if ((await detectCUDA()).available) {
+      backends.push("cuda");
+    }
+    if ((await detectVulkan()).available) {
+      backends.push("vulkan");
+    }
+  }
+  backends.push("cpu");
+  return backends;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectGPU,
+  formatGPUInfo,
+  getAvailableBackends,
+  isBackendAvailable
+});

package/dist/llm/providers/local/gpu-detector.d.ts

@@ -0,0 +1,28 @@
+/**
+ * GPU detection for local model acceleration.
+ *
+ * Detects available GPU backends:
+ * - Metal: Apple Silicon (M1/M2/M3/M4 series)
+ * - CUDA: NVIDIA GPUs on Linux/Windows
+ * - Vulkan: Cross-platform fallback for AMD/Intel GPUs
+ * - CPU: Fallback when no GPU is available
+ */
+import type { GPUBackend, GPUInfo } from './types.js';
+/**
+ * Detect available GPU backend for the current system.
+ * Returns the best available option.
+ */
+export declare function detectGPU(): Promise<GPUInfo>;
+/**
+ * Get a human-readable summary of GPU detection results.
+ */
+export declare function formatGPUInfo(info: GPUInfo): string;
+/**
+ * Check if a specific backend is available.
+ */
+export declare function isBackendAvailable(backend: GPUBackend): Promise<boolean>;
+/**
+ * Get all available backends on the current system.
+ */
+export declare function getAvailableBackends(): Promise<GPUBackend[]>;
+//# sourceMappingURL=gpu-detector.d.ts.map

package/dist/llm/providers/local/gpu-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-detector.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/gpu-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAItD;;;GAGG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC,CA+BlD;AAmJD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAiBnD;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAa9E;AAED;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAuBlE"}

package/dist/llm/providers/local/gpu-detector.js

@@ -0,0 +1,178 @@
+import "../../../chunk-PTJYTZNU.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as os from "os";
+const execAsync = promisify(exec);
+async function detectGPU() {
+  const platform = os.platform();
+  if (platform === "darwin") {
+    const metalInfo = await detectMetal();
+    if (metalInfo.available) {
+      return metalInfo;
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    const cudaInfo = await detectCUDA();
+    if (cudaInfo.available) {
+      return cudaInfo;
+    }
+    const vulkanInfo = await detectVulkan();
+    if (vulkanInfo.available) {
+      return vulkanInfo;
+    }
+  }
+  return {
+    backend: "cpu",
+    available: true,
+    deviceName: `${os.cpus()[0]?.model ?? "Unknown CPU"}`
+  };
+}
+async function detectMetal() {
+  try {
+    const { stdout } = await execAsync("system_profiler SPDisplaysDataType -json 2>/dev/null");
+    const data = JSON.parse(stdout);
+    const gpuData = data?.SPDisplaysDataType?.[0];
+    if (gpuData) {
+      const chipName = gpuData.sppci_model ?? gpuData._name ?? "Apple GPU";
+      const isAppleSilicon = chipName.toLowerCase().includes("apple") || chipName.toLowerCase().includes("m1") || chipName.toLowerCase().includes("m2") || chipName.toLowerCase().includes("m3") || chipName.toLowerCase().includes("m4");
+      const result = {
+        backend: "metal",
+        available: true,
+        deviceName: chipName
+      };
+      if (isAppleSilicon) {
+        result.vramMB = Math.round(os.totalmem() / (1024 * 1024));
+      } else if (gpuData.sppci_vram) {
+        const vramMatch = gpuData.sppci_vram.match(/(\d+)\s*(GB|MB)/i);
+        if (vramMatch) {
+          result.vramMB = parseInt(vramMatch[1]) * (vramMatch[2].toUpperCase() === "GB" ? 1024 : 1);
+        }
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "metal",
+    available: false
+  };
+}
+async function detectCUDA() {
+  try {
+    const { stdout } = await execAsync(
+      "nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits 2>/dev/null"
+    );
+    const lines = stdout.trim().split("\n");
+    if (lines.length > 0 && lines[0]) {
+      const [name, memoryMB, driverVersion] = lines[0].split(", ").map((s) => s.trim());
+      const result = {
+        backend: "cuda",
+        available: true
+      };
+      if (name) {
+        result.deviceName = name;
+      }
+      if (memoryMB) {
+        result.vramMB = parseInt(memoryMB);
+      }
+      if (driverVersion) {
+        result.driverVersion = driverVersion;
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "cuda",
+    available: false
+  };
+}
+async function detectVulkan() {
+  try {
+    const { stdout } = await execAsync("vulkaninfo --summary 2>/dev/null");
+    const deviceMatch = stdout.match(/deviceName\s*=\s*(.+)/);
+    const deviceName = deviceMatch?.[1]?.trim() ?? "Vulkan GPU";
+    const result = {
+      backend: "vulkan",
+      available: true,
+      deviceName
+    };
+    const heapMatch = stdout.match(/heapSize\s*=\s*(\d+)/);
+    if (heapMatch) {
+      result.vramMB = Math.round(parseInt(heapMatch[1]) / (1024 * 1024));
+    }
+    return result;
+  } catch {
+  }
+  if (os.platform() === "linux") {
+    try {
+      const { stdout } = await execAsync('lspci | grep -i "vga\\|3d\\|display" 2>/dev/null');
+      if (stdout.includes("AMD") || stdout.includes("Intel") || stdout.includes("Radeon")) {
+        const deviceMatch = stdout.match(/: (.+)/);
+        return {
+          backend: "vulkan",
+          available: true,
+          deviceName: deviceMatch?.[1]?.trim() ?? "GPU (Vulkan)"
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    backend: "vulkan",
+    available: false
+  };
+}
+function formatGPUInfo(info) {
+  if (!info.available) {
+    return `${info.backend.toUpperCase()} not available`;
+  }
+  const parts = [info.deviceName ?? info.backend.toUpperCase()];
+  if (info.vramMB) {
+    const vramGB = (info.vramMB / 1024).toFixed(1);
+    parts.push(`${vramGB}GB`);
+  }
+  if (info.driverVersion) {
+    parts.push(`Driver: ${info.driverVersion}`);
+  }
+  return parts.join(" \u2022 ");
+}
+async function isBackendAvailable(backend) {
+  switch (backend) {
+    case "metal":
+      return (await detectMetal()).available;
+    case "cuda":
+      return (await detectCUDA()).available;
+    case "vulkan":
+      return (await detectVulkan()).available;
+    case "cpu":
+      return true;
+    default:
+      return false;
+  }
+}
+async function getAvailableBackends() {
+  const backends = [];
+  const platform = os.platform();
+  if (platform === "darwin") {
+    if ((await detectMetal()).available) {
+      backends.push("metal");
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    if ((await detectCUDA()).available) {
+      backends.push("cuda");
+    }
+    if ((await detectVulkan()).available) {
+      backends.push("vulkan");
+    }
+  }
+  backends.push("cpu");
+  return backends;
+}
+export {
+  detectGPU,
+  formatGPUInfo,
+  getAvailableBackends,
+  isBackendAvailable
+};

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

@@ -0,0 +1,147 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var local_exports = {};
+__export(local_exports, {
+  DEFAULT_OLLAMA_URL: () => import_ollama_provider.DEFAULT_OLLAMA_URL,
+  GPUBackendSchema: () => import_schemas.GPUBackendSchema,
+  GPUInfoSchema: () => import_schemas.GPUInfoSchema,
+  InstalledModelSchema: () => import_schemas.InstalledModelSchema,
+  LOCAL_MODEL_REGISTRY: () => import_registry.LOCAL_MODEL_REGISTRY,
+  LocalLLMConfigSchema: () => import_schemas.LocalLLMConfigSchema,
+  LocalModelCategorySchema: () => import_schemas.LocalModelCategorySchema,
+  LocalModelError: () => import_errors.LocalModelError,
+  LocalModelErrorCode: () => import_error_codes.LocalModelErrorCode,
+  LocalModelInfoSchema: () => import_schemas.LocalModelInfoSchema,
+  ModelDownloadOptionsSchema: () => import_schemas.ModelDownloadOptionsSchema,
+  ModelDownloadProgressSchema: () => import_schemas.ModelDownloadProgressSchema,
+  ModelDownloadStatusSchema: () => import_schemas.ModelDownloadStatusSchema,
+  ModelSourceSchema: () => import_schemas.ModelSourceSchema,
+  ModelStateSchema: () => import_schemas.ModelStateSchema,
+  OllamaModelInfoSchema: () => import_schemas.OllamaModelInfoSchema,
+  OllamaStatusSchema: () => import_schemas.OllamaStatusSchema,
+  QuantizationTypeSchema: () => import_schemas.QuantizationTypeSchema,
+  calculateFileHash: () => import_downloader.calculateFileHash,
+  checkDiskSpace: () => import_downloader.checkDiskSpace,
+  checkOllamaStatus: () => import_ollama_provider.checkOllamaStatus,
+  cleanupPartialDownload: () => import_downloader.cleanupPartialDownload,
+  createLocalLanguageModel: () => import_ai_sdk_adapter.createLocalLanguageModel,
+  createOllamaModel: () => import_ollama_provider.createOllamaModel,
+  createValidatedOllamaModel: () => import_ollama_provider.createValidatedOllamaModel,
+  deleteOllamaModel: () => import_ollama_provider.deleteOllamaModel,
+  detectGPU: () => import_gpu_detector.detectGPU,
+  downloadModel: () => import_downloader.downloadModel,
+  downloadModelFromUrl: () => import_downloader.downloadModelFromUrl,
+  formatGPUInfo: () => import_gpu_detector.formatGPUInfo,
+  generateOllamaEmbeddings: () => import_ollama_provider.generateOllamaEmbeddings,
+  getAllLocalModels: () => import_registry.getAllLocalModels,
+  getAvailableBackends: () => import_gpu_detector.getAvailableBackends,
+  getDefaultLocalModelId: () => import_registry.getDefaultLocalModelId,
+  getLoadedModelCount: () => import_node_llama_provider.getLoadedModelCount,
+  getLocalModelById: () => import_registry.getLocalModelById,
+  getLocalModelsByCategory: () => import_registry.getLocalModelsByCategory,
+  getModelsForRAM: () => import_registry.getModelsForRAM,
+  getModelsForVRAM: () => import_registry.getModelsForVRAM,
+  getOllamaModelInfo: () => import_ollama_provider.getOllamaModelInfo,
+  getPartialDownloadProgress: () => import_downloader.getPartialDownloadProgress,
+  getRecommendedLocalModels: () => import_registry.getRecommendedLocalModels,
+  isBackendAvailable: () => import_gpu_detector.isBackendAvailable,
+  isDownloadInProgress: () => import_downloader.isDownloadInProgress,
+  isModelLoaded: () => import_node_llama_provider.isModelLoaded,
+  isNodeLlamaCppInstalled: () => import_node_llama_provider.isNodeLlamaCppInstalled,
+  isOllamaModelAvailable: () => import_ollama_provider.isOllamaModelAvailable,
+  listOllamaModels: () => import_ollama_provider.listOllamaModels,
+  loadModel: () => import_node_llama_provider.loadModel,
+  pullOllamaModel: () => import_ollama_provider.pullOllamaModel,
+  requireNodeLlamaCpp: () => import_node_llama_provider.requireNodeLlamaCpp,
+  searchLocalModels: () => import_registry.searchLocalModels,
+  unloadAllModels: () => import_node_llama_provider.unloadAllModels,
+  unloadModel: () => import_node_llama_provider.unloadModel,
+  validateDiskSpace: () => import_downloader.validateDiskSpace
+});
+module.exports = __toCommonJS(local_exports);
+__reExport(local_exports, require("./types.js"), module.exports);
+var import_error_codes = require("./error-codes.js");
+var import_errors = require("./errors.js");
+var import_schemas = require("./schemas.js");
+var import_registry = require("./registry.js");
+var import_gpu_detector = require("./gpu-detector.js");
+var import_downloader = require("./downloader.js");
+var import_ollama_provider = require("./ollama-provider.js");
+var import_node_llama_provider = require("./node-llama-provider.js");
+var import_ai_sdk_adapter = require("./ai-sdk-adapter.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OLLAMA_URL,
+  GPUBackendSchema,
+  GPUInfoSchema,
+  InstalledModelSchema,
+  LOCAL_MODEL_REGISTRY,
+  LocalLLMConfigSchema,
+  LocalModelCategorySchema,
+  LocalModelError,
+  LocalModelErrorCode,
+  LocalModelInfoSchema,
+  ModelDownloadOptionsSchema,
+  ModelDownloadProgressSchema,
+  ModelDownloadStatusSchema,
+  ModelSourceSchema,
+  ModelStateSchema,
+  OllamaModelInfoSchema,
+  OllamaStatusSchema,
+  QuantizationTypeSchema,
+  calculateFileHash,
+  checkDiskSpace,
+  checkOllamaStatus,
+  cleanupPartialDownload,
+  createLocalLanguageModel,
+  createOllamaModel,
+  createValidatedOllamaModel,
+  deleteOllamaModel,
+  detectGPU,
+  downloadModel,
+  downloadModelFromUrl,
+  formatGPUInfo,
+  generateOllamaEmbeddings,
+  getAllLocalModels,
+  getAvailableBackends,
+  getDefaultLocalModelId,
+  getLoadedModelCount,
+  getLocalModelById,
+  getLocalModelsByCategory,
+  getModelsForRAM,
+  getModelsForVRAM,
+  getOllamaModelInfo,
+  getPartialDownloadProgress,
+  getRecommendedLocalModels,
+  isBackendAvailable,
+  isDownloadInProgress,
+  isModelLoaded,
+  isNodeLlamaCppInstalled,
+  isOllamaModelAvailable,
+  listOllamaModels,
+  loadModel,
+  pullOllamaModel,
+  requireNodeLlamaCpp,
+  searchLocalModels,
+  unloadAllModels,
+  unloadModel,
+  validateDiskSpace,
+  ...require("./types.js")
+});

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

@@ -0,0 +1,21 @@
+/**
+ * Native local model support via node-llama-cpp and Ollama.
+ *
+ * This module provides:
+ * - Local model registry with curated GGUF models
+ * - GPU detection (Metal/CUDA/Vulkan)
+ * - Model downloading with progress
+ * - node-llama-cpp provider for native GGUF execution
+ * - Ollama provider for Ollama server integration
+ */
+export * from './types.js';
+export { LocalModelErrorCode } from './error-codes.js';
+export { LocalModelError } from './errors.js';
+export { GPUBackendSchema, QuantizationTypeSchema, LocalModelCategorySchema, ModelSourceSchema, ModelDownloadStatusSchema, LocalModelInfoSchema, ModelDownloadProgressSchema, GPUInfoSchema, LocalLLMConfigSchema, InstalledModelSchema, ModelStateSchema, ModelDownloadOptionsSchema, OllamaModelInfoSchema, OllamaStatusSchema, } from './schemas.js';
+export { LOCAL_MODEL_REGISTRY, getAllLocalModels, getLocalModelById, getLocalModelsByCategory, getRecommendedLocalModels, getModelsForVRAM, getModelsForRAM, searchLocalModels, getDefaultLocalModelId, } from './registry.js';
+export { detectGPU, formatGPUInfo, isBackendAvailable, getAvailableBackends, } from './gpu-detector.js';
+export { downloadModel, downloadModelFromUrl, calculateFileHash, checkDiskSpace, validateDiskSpace, cleanupPartialDownload, isDownloadInProgress, getPartialDownloadProgress, type DownloadEvents, type DownloadOptions, type DownloadResult, } from './downloader.js';
+export { DEFAULT_OLLAMA_URL, checkOllamaStatus, listOllamaModels, isOllamaModelAvailable, pullOllamaModel, createOllamaModel, createValidatedOllamaModel, getOllamaModelInfo, deleteOllamaModel, generateOllamaEmbeddings, type OllamaConfig, } from './ollama-provider.js';
+export { isNodeLlamaCppInstalled, requireNodeLlamaCpp, loadModel, unloadModel, unloadAllModels, isModelLoaded, getLoadedModelCount, type NodeLlamaConfig, type ModelSession, type LoadedModel, } from './node-llama-provider.js';
+export { createLocalLanguageModel, type LocalModelAdapterConfig } from './ai-sdk-adapter.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,EACH,gBAAgB,EAChB,sBAAsB,EACtB,wBAAwB,EACxB,iBAAiB,EACjB,yBAAyB,EACzB,oBAAoB,EACpB,2BAA2B,EAC3B,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,0BAA0B,EAC1B,qBAAqB,EACrB,kBAAkB,GACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACH,oBAAoB,EACpB,iBAAiB,EACjB,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,sBAAsB,GACzB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACH,SAAS,EACT,aAAa,EACb,kBAAkB,EAClB,oBAAoB,GACvB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACH,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,EACpB,0BAA0B,EAC1B,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,cAAc,GACtB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACH,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,iBAAiB,EACjB,0BAA0B,EAC1B,kBAAkB,EAClB,iBAAiB,EACjB,wBAAwB,EACxB,KAAK,YAAY,GACpB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACnB,SAAS,EACT,WAAW,EACX,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,WAAW,GACnB,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,wBAAwB,EAAE,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC"}