@dexto/core 1.4.0 → 1.5.1

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"}

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

@@ -0,0 +1,126 @@
+import "../../../chunk-PTJYTZNU.js";
+export * from "./types.js";
+import { LocalModelErrorCode } from "./error-codes.js";
+import { LocalModelError } from "./errors.js";
+import {
+  GPUBackendSchema,
+  QuantizationTypeSchema,
+  LocalModelCategorySchema,
+  ModelSourceSchema,
+  ModelDownloadStatusSchema,
+  LocalModelInfoSchema,
+  ModelDownloadProgressSchema,
+  GPUInfoSchema,
+  LocalLLMConfigSchema,
+  InstalledModelSchema,
+  ModelStateSchema,
+  ModelDownloadOptionsSchema,
+  OllamaModelInfoSchema,
+  OllamaStatusSchema
+} from "./schemas.js";
+import {
+  LOCAL_MODEL_REGISTRY,
+  getAllLocalModels,
+  getLocalModelById,
+  getLocalModelsByCategory,
+  getRecommendedLocalModels,
+  getModelsForVRAM,
+  getModelsForRAM,
+  searchLocalModels,
+  getDefaultLocalModelId
+} from "./registry.js";
+import {
+  detectGPU,
+  formatGPUInfo,
+  isBackendAvailable,
+  getAvailableBackends
+} from "./gpu-detector.js";
+import {
+  downloadModel,
+  downloadModelFromUrl,
+  calculateFileHash,
+  checkDiskSpace,
+  validateDiskSpace,
+  cleanupPartialDownload,
+  isDownloadInProgress,
+  getPartialDownloadProgress
+} from "./downloader.js";
+import {
+  DEFAULT_OLLAMA_URL,
+  checkOllamaStatus,
+  listOllamaModels,
+  isOllamaModelAvailable,
+  pullOllamaModel,
+  createOllamaModel,
+  createValidatedOllamaModel,
+  getOllamaModelInfo,
+  deleteOllamaModel,
+  generateOllamaEmbeddings
+} from "./ollama-provider.js";
+import {
+  isNodeLlamaCppInstalled,
+  requireNodeLlamaCpp,
+  loadModel,
+  unloadModel,
+  unloadAllModels,
+  isModelLoaded,
+  getLoadedModelCount
+} from "./node-llama-provider.js";
+import { createLocalLanguageModel } from "./ai-sdk-adapter.js";
+export {
+  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
+};

package/dist/llm/providers/local/node-llama-provider.cjs

@@ -0,0 +1,216 @@
+"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 node_llama_provider_exports = {};
+__export(node_llama_provider_exports, {
+  getLoadedModelCount: () => getLoadedModelCount,
+  isModelLoaded: () => isModelLoaded,
+  isNodeLlamaCppInstalled: () => isNodeLlamaCppInstalled,
+  loadModel: () => loadModel,
+  requireNodeLlamaCpp: () => requireNodeLlamaCpp,
+  unloadAllModels: () => unloadAllModels,
+  unloadModel: () => unloadModel
+});
+module.exports = __toCommonJS(node_llama_provider_exports);
+var import_errors = require("./errors.js");
+var import_gpu_detector = require("./gpu-detector.js");
+var import_path = require("../../../utils/path.js");
+var import_module = require("module");
+var path = __toESM(require("path"), 1);
+const import_meta = {};
+function getGlobalNodeLlamaCppPath() {
+  return path.join((0, import_path.getDextoGlobalPath)("deps"), "node_modules", "node-llama-cpp");
+}
+async function isNodeLlamaCppInstalled() {
+  try {
+    await import("node-llama-cpp");
+    return true;
+  } catch {
+  }
+  try {
+    const globalPath = getGlobalNodeLlamaCppPath();
+    const require2 = (0, import_module.createRequire)(import_meta.url);
+    require2.resolve(globalPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function importNodeLlamaCpp() {
+  try {
+    return await import("node-llama-cpp");
+  } catch {
+  }
+  try {
+    const globalPath = getGlobalNodeLlamaCppPath();
+    const entryPoint = path.join(globalPath, "dist", "index.js");
+    return await import(entryPoint);
+  } catch {
+    return null;
+  }
+}
+function requireNodeLlamaCpp() {
+  throw import_errors.LocalModelError.nodeLlamaNotInstalled();
+}
+const modelCache = /* @__PURE__ */ new Map();
+async function loadModel(config) {
+  const { modelPath, gpuLayers = -1, contextSize, threads, batchSize = 512 } = config;
+  const cacheKey = `${modelPath}:${gpuLayers}:${contextSize}`;
+  const cached = modelCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const loadPromise = (async () => {
+    const nodeLlama = await importNodeLlamaCpp();
+    if (!nodeLlama) {
+      throw import_errors.LocalModelError.nodeLlamaNotInstalled();
+    }
+    try {
+      const gpuInfo = await (0, import_gpu_detector.detectGPU)();
+      const getLlama = nodeLlama["getLlama"];
+      const LlamaLogLevel = nodeLlama["LlamaLogLevel"];
+      const LlamaChatSession = nodeLlama["LlamaChatSession"];
+      const llama = await getLlama({
+        logLevel: LlamaLogLevel.warn,
+        gpu: gpuInfo.backend === "cpu" ? false : "auto"
+      });
+      const model = await llama.loadModel({
+        modelPath,
+        gpuLayers: gpuLayers === -1 ? "auto" : gpuLayers
+      });
+      const contextOptions = {
+        batchSize
+      };
+      if (contextSize !== void 0) {
+        contextOptions.contextSize = contextSize;
+      }
+      if (threads !== void 0) {
+        contextOptions.threads = threads;
+      }
+      const context = await model.createContext(contextOptions);
+      return {
+        modelPath,
+        gpuInfo,
+        async createSession() {
+          const session = new LlamaChatSession({
+            contextSequence: context.getSequence()
+          });
+          return {
+            async prompt(text, options = {}) {
+              const {
+                maxTokens = 1024,
+                temperature = 0.7,
+                topP = 0.9,
+                signal,
+                onToken
+              } = options;
+              const promptOptions = {
+                maxTokens,
+                temperature,
+                topP,
+                stopOnAbortSignal: true,
+                trimWhitespaceSuffix: true
+              };
+              if (signal) {
+                promptOptions.signal = signal;
+              }
+              if (onToken) {
+                promptOptions.onTextChunk = onToken;
+              }
+              const response = await session.prompt(text, promptOptions);
+              return response;
+            },
+            async dispose() {
+            }
+          };
+        },
+        async dispose() {
+          await context.dispose();
+          await model.dispose();
+          modelCache.delete(cacheKey);
+        }
+      };
+    } catch (error) {
+      modelCache.delete(cacheKey);
+      if (error instanceof Error && "code" in error) {
+        throw error;
+      }
+      throw import_errors.LocalModelError.modelLoadFailed(
+        modelPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  })();
+  modelCache.set(cacheKey, loadPromise);
+  return loadPromise;
+}
+async function unloadModel(modelPath) {
+  for (const [key, loadPromise] of modelCache.entries()) {
+    const keyModelPath = key.split(":")[0];
+    if (keyModelPath === modelPath) {
+      try {
+        const loaded = await loadPromise;
+        await loaded.dispose();
+      } catch {
+      }
+      modelCache.delete(key);
+    }
+  }
+}
+async function unloadAllModels() {
+  for (const [key, loadPromise] of modelCache.entries()) {
+    try {
+      const loaded = await loadPromise;
+      await loaded.dispose();
+    } catch {
+    }
+    modelCache.delete(key);
+  }
+}
+function isModelLoaded(modelPath) {
+  for (const key of modelCache.keys()) {
+    const keyModelPath = key.split(":")[0];
+    if (keyModelPath === modelPath) {
+      return true;
+    }
+  }
+  return false;
+}
+function getLoadedModelCount() {
+  return modelCache.size;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLoadedModelCount,
+  isModelLoaded,
+  isNodeLlamaCppInstalled,
+  loadModel,
+  requireNodeLlamaCpp,
+  unloadAllModels,
+  unloadModel
+});

package/dist/llm/providers/local/node-llama-provider.d.ts

@@ -0,0 +1,90 @@
+/**
+ * node-llama-cpp provider for native local model execution.
+ *
+ * This module provides utilities for loading and using GGUF models via node-llama-cpp.
+ * Since node-llama-cpp is an optional dependency, all functions handle the case
+ * where it's not installed gracefully.
+ *
+ * For Vercel AI SDK integration, we recommend using Ollama which provides
+ * an OpenAI-compatible API that works seamlessly with the SDK.
+ */
+import type { GPUInfo } from './types.js';
+/**
+ * Check if node-llama-cpp is installed.
+ * Checks both standard node resolution (for dev/projects) and global deps (~/.dexto/deps).
+ */
+export declare function isNodeLlamaCppInstalled(): Promise<boolean>;
+/**
+ * Throws an error indicating node-llama-cpp needs to be installed.
+ */
+export declare function requireNodeLlamaCpp(): never;
+/**
+ * Configuration for the node-llama-cpp model.
+ */
+export interface NodeLlamaConfig {
+    /** Path to the .gguf model file */
+    modelPath: string;
+    /** Number of GPU layers to offload (-1 = all, 0 = CPU only) */
+    gpuLayers?: number;
+    /** Context window size */
+    contextSize?: number;
+    /** Number of CPU threads */
+    threads?: number;
+    /** Batch size for inference */
+    batchSize?: number;
+    /** Whether to use Flash Attention (if available) */
+    flashAttention?: boolean;
+}
+/**
+ * Model session interface for node-llama-cpp.
+ * This provides a simplified interface for text generation.
+ */
+export interface ModelSession {
+    /** Generate a response from a prompt */
+    prompt(text: string, options?: {
+        maxTokens?: number;
+        temperature?: number;
+        topP?: number;
+        signal?: AbortSignal;
+        onToken?: (token: string) => void;
+    }): Promise<string>;
+    /** Dispose the session and free resources */
+    dispose(): Promise<void>;
+}
+/**
+ * Loaded model interface.
+ */
+export interface LoadedModel {
+    /** Model file path */
+    modelPath: string;
+    /** GPU info used for loading */
+    gpuInfo: GPUInfo;
+    /** Create a new chat session */
+    createSession(): Promise<ModelSession>;
+    /** Dispose the model and free resources */
+    dispose(): Promise<void>;
+}
+/**
+ * Load a GGUF model using node-llama-cpp.
+ *
+ * @throws {DextoRuntimeError} If node-llama-cpp is not installed
+ */
+export declare function loadModel(config: NodeLlamaConfig): Promise<LoadedModel>;
+/**
+ * Unload a model and free resources.
+ * Removes all cache entries for the given model path (across different configs).
+ */
+export declare function unloadModel(modelPath: string): Promise<void>;
+/**
+ * Unload all models and free resources.
+ */
+export declare function unloadAllModels(): Promise<void>;
+/**
+ * Check if a model is currently loaded.
+ */
+export declare function isModelLoaded(modelPath: string): boolean;
+/**
+ * Get the number of currently loaded models.
+ */
+export declare function getLoadedModelCount(): number;
+//# sourceMappingURL=node-llama-provider.d.ts.map

package/dist/llm/providers/local/node-llama-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-llama-provider.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/node-llama-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAc1C;;;GAGG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC,CAmBhE;AA6BD;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,KAAK,CAE3C;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IACzB,wCAAwC;IACxC,MAAM,CACF,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QACN,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;KACrC,GACF,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB,6CAA6C;IAC7C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,aAAa,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IACvC,2CAA2C;IAC3C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAKD;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAuJ7E;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAclE;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAUrD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CASxD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}