@dexto/core 1.4.0 → 1.5.0

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

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

@@ -0,0 +1,176 @@
+import "../../../chunk-PTJYTZNU.js";
+import { LocalModelError } from "./errors.js";
+import { detectGPU } from "./gpu-detector.js";
+import { getDextoGlobalPath } from "../../../utils/path.js";
+import { createRequire } from "module";
+import * as path from "path";
+function getGlobalNodeLlamaCppPath() {
+  return path.join(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 = 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 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 LocalModelError.nodeLlamaNotInstalled();
+    }
+    try {
+      const gpuInfo = await 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 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;
+}
+export {
+  getLoadedModelCount,
+  isModelLoaded,
+  isNodeLlamaCppInstalled,
+  loadModel,
+  requireNodeLlamaCpp,
+  unloadAllModels,
+  unloadModel
+};