@dexto/core 1.4.0 → 1.5.1

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

package/dist/llm/providers/local/ollama-provider.cjs

@@ -0,0 +1,230 @@
+"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 ollama_provider_exports = {};
+__export(ollama_provider_exports, {
+  DEFAULT_OLLAMA_URL: () => DEFAULT_OLLAMA_URL,
+  checkOllamaStatus: () => checkOllamaStatus,
+  createOllamaModel: () => createOllamaModel,
+  createValidatedOllamaModel: () => createValidatedOllamaModel,
+  deleteOllamaModel: () => deleteOllamaModel,
+  generateOllamaEmbeddings: () => generateOllamaEmbeddings,
+  getOllamaModelInfo: () => getOllamaModelInfo,
+  isOllamaModelAvailable: () => isOllamaModelAvailable,
+  listOllamaModels: () => listOllamaModels,
+  pullOllamaModel: () => pullOllamaModel
+});
+module.exports = __toCommonJS(ollama_provider_exports);
+var import_openai = require("@ai-sdk/openai");
+var import_errors = require("./errors.js");
+const DEFAULT_OLLAMA_URL = "http://localhost:11434";
+async function checkOllamaStatus(baseURL = DEFAULT_OLLAMA_URL) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`${baseURL}/api/version`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return {
+        running: false,
+        url: baseURL,
+        error: `HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    const data = await response.json();
+    const models = await listOllamaModels(baseURL);
+    const status = {
+      running: true,
+      url: baseURL,
+      models
+    };
+    if (data.version) {
+      status.version = data.version;
+    }
+    return status;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.name === "AbortError" ? "Connection timed out" : error.message : "Unknown error";
+    return {
+      running: false,
+      url: baseURL,
+      error: errorMessage
+    };
+  }
+}
+async function listOllamaModels(baseURL = DEFAULT_OLLAMA_URL) {
+  try {
+    const response = await fetch(`${baseURL}/api/tags`);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return (data.models ?? []).map((model) => {
+      const modelInfo = {
+        name: model.name,
+        size: model.size,
+        digest: model.digest,
+        modifiedAt: model.modified_at
+      };
+      if (model.details) {
+        const details = {};
+        if (model.details.family) {
+          details.family = model.details.family;
+        }
+        if (model.details.parameter_size) {
+          details.parameterSize = model.details.parameter_size;
+        }
+        if (model.details.quantization_level) {
+          details.quantizationLevel = model.details.quantization_level;
+        }
+        if (Object.keys(details).length > 0) {
+          modelInfo.details = details;
+        }
+      }
+      return modelInfo;
+    });
+  } catch {
+    return [];
+  }
+}
+async function isOllamaModelAvailable(modelName, baseURL = DEFAULT_OLLAMA_URL) {
+  const models = await listOllamaModels(baseURL);
+  return models.some(
+    (m) => m.name === modelName || m.name.startsWith(`${modelName}:`) || modelName.startsWith(`${m.name}:`)
+  );
+}
+async function pullOllamaModel(modelName, baseURL = DEFAULT_OLLAMA_URL, onProgress, signal) {
+  try {
+    const fetchOptions = {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: modelName })
+    };
+    if (signal) {
+      fetchOptions.signal = signal;
+    }
+    const response = await fetch(`${baseURL}/api/pull`, fetchOptions);
+    if (!response.ok) {
+      throw import_errors.LocalModelError.ollamaPullFailed(
+        modelName,
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw import_errors.LocalModelError.ollamaPullFailed(modelName, "No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const progress = JSON.parse(line);
+          if (progress.error) {
+            throw import_errors.LocalModelError.ollamaPullFailed(modelName, progress.error);
+          }
+          onProgress?.(progress);
+        } catch (e) {
+          if (e instanceof Error && e.message.includes("ollamaPullFailed")) {
+            throw e;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("ECONNREFUSED")) {
+      throw import_errors.LocalModelError.ollamaNotRunning(baseURL);
+    }
+    throw error;
+  }
+}
+function createOllamaModel(modelName, config = {}) {
+  const { baseURL = DEFAULT_OLLAMA_URL } = config;
+  const openai = (0, import_openai.createOpenAI)({
+    baseURL: `${baseURL}/v1`,
+    apiKey: "ollama"
+    // Ollama doesn't require an API key, but the SDK requires a non-empty string
+  });
+  return openai(modelName);
+}
+async function createValidatedOllamaModel(modelName, config = {}) {
+  const { baseURL = DEFAULT_OLLAMA_URL } = config;
+  const status = await checkOllamaStatus(baseURL);
+  if (!status.running) {
+    throw import_errors.LocalModelError.ollamaNotRunning(baseURL);
+  }
+  const isAvailable = await isOllamaModelAvailable(modelName, baseURL);
+  if (!isAvailable) {
+    throw import_errors.LocalModelError.ollamaModelNotFound(modelName);
+  }
+  return createOllamaModel(modelName, config);
+}
+async function getOllamaModelInfo(modelName, baseURL = DEFAULT_OLLAMA_URL) {
+  const models = await listOllamaModels(baseURL);
+  return models.find(
+    (m) => m.name === modelName || m.name.startsWith(`${modelName}:`) || modelName.startsWith(`${m.name}:`)
+  ) ?? null;
+}
+async function deleteOllamaModel(modelName, baseURL = DEFAULT_OLLAMA_URL) {
+  try {
+    const response = await fetch(`${baseURL}/api/delete`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: modelName })
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function generateOllamaEmbeddings(modelName, input, baseURL = DEFAULT_OLLAMA_URL) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const response = await fetch(`${baseURL}/api/embed`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: modelName,
+      input: inputs
+    })
+  });
+  if (!response.ok) {
+    throw import_errors.LocalModelError.ollamaApiError(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.embeddings;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OLLAMA_URL,
+  checkOllamaStatus,
+  createOllamaModel,
+  createValidatedOllamaModel,
+  deleteOllamaModel,
+  generateOllamaEmbeddings,
+  getOllamaModelInfo,
+  isOllamaModelAvailable,
+  listOllamaModels,
+  pullOllamaModel
+});

package/dist/llm/providers/local/ollama-provider.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Ollama provider for local model inference.
+ *
+ * Uses Ollama's OpenAI-compatible API for seamless integration
+ * with the Vercel AI SDK.
+ */
+import type { LanguageModel } from 'ai';
+import type { OllamaModelInfo, OllamaStatus } from './types.js';
+/**
+ * Default Ollama server URL.
+ */
+export declare const DEFAULT_OLLAMA_URL = "http://localhost:11434";
+/**
+ * Ollama configuration options.
+ */
+export interface OllamaConfig {
+    /** Ollama server base URL (default: http://localhost:11434) */
+    baseURL?: string;
+}
+/**
+ * Check if the Ollama server is running.
+ */
+export declare function checkOllamaStatus(baseURL?: string): Promise<OllamaStatus>;
+/**
+ * List available models on the Ollama server.
+ */
+export declare function listOllamaModels(baseURL?: string): Promise<OllamaModelInfo[]>;
+/**
+ * Check if a specific model is available on Ollama.
+ */
+export declare function isOllamaModelAvailable(modelName: string, baseURL?: string): Promise<boolean>;
+/**
+ * Pull a model from the Ollama registry.
+ * Returns a stream of progress events.
+ *
+ * @param modelName - Name of the model to pull
+ * @param baseURL - Ollama server URL (default: http://localhost:11434)
+ * @param onProgress - Optional callback for progress updates
+ * @param signal - Optional AbortSignal for cancellation
+ */
+export declare function pullOllamaModel(modelName: string, baseURL?: string, onProgress?: (progress: {
+    status: string;
+    completed?: number;
+    total?: number;
+}) => void, signal?: AbortSignal): Promise<void>;
+/**
+ * Create an Ollama language model using the OpenAI-compatible API.
+ */
+export declare function createOllamaModel(modelName: string, config?: OllamaConfig): LanguageModel;
+/**
+ * Create an Ollama model with status validation.
+ * Throws if Ollama is not running or model is not available.
+ */
+export declare function createValidatedOllamaModel(modelName: string, config?: OllamaConfig): Promise<LanguageModel>;
+/**
+ * Get information about a specific Ollama model.
+ */
+export declare function getOllamaModelInfo(modelName: string, baseURL?: string): Promise<OllamaModelInfo | null>;
+/**
+ * Delete a model from Ollama.
+ */
+export declare function deleteOllamaModel(modelName: string, baseURL?: string): Promise<boolean>;
+/**
+ * Generate embeddings using Ollama.
+ * Uses the /api/embed endpoint which supports batch processing.
+ *
+ * Note: Reserved for future RAG/vector search functionality.
+ */
+export declare function generateOllamaEmbeddings(modelName: string, input: string | string[], baseURL?: string): Promise<number[][]>;
+//# sourceMappingURL=ollama-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ollama-provider.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/ollama-provider.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACxC,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGhE;;GAEG;AACH,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,OAAO,GAAE,MAA2B,GACrC,OAAO,CAAC,YAAY,CAAC,CAiDvB;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAClC,OAAO,GAAE,MAA2B,GACrC,OAAO,CAAC,eAAe,EAAE,CAAC,CAmD5B;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CACxC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,MAA2B,GACrC,OAAO,CAAC,OAAO,CAAC,CAQlB;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACjC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,MAA2B,EACpC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,EACvF,MAAM,CAAC,EAAE,WAAW,GACrB,OAAO,CAAC,IAAI,CAAC,CAkEf;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,YAAiB,GAAG,aAAa,CAU7F;AAED;;;GAGG;AACH,wBAAsB,0BAA0B,CAC5C,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,YAAiB,GAC1B,OAAO,CAAC,aAAa,CAAC,CAgBxB;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACpC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,MAA2B,GACrC,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAUjC;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,MAA2B,GACrC,OAAO,CAAC,OAAO,CAAC,CAYlB;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC1C,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EACxB,OAAO,GAAE,MAA2B,GACrC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAmBrB"}

package/dist/llm/providers/local/ollama-provider.js

@@ -0,0 +1,198 @@
+import "../../../chunk-PTJYTZNU.js";
+import { createOpenAI } from "@ai-sdk/openai";
+import { LocalModelError } from "./errors.js";
+const DEFAULT_OLLAMA_URL = "http://localhost:11434";
+async function checkOllamaStatus(baseURL = DEFAULT_OLLAMA_URL) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(`${baseURL}/api/version`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return {
+        running: false,
+        url: baseURL,
+        error: `HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    const data = await response.json();
+    const models = await listOllamaModels(baseURL);
+    const status = {
+      running: true,
+      url: baseURL,
+      models
+    };
+    if (data.version) {
+      status.version = data.version;
+    }
+    return status;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.name === "AbortError" ? "Connection timed out" : error.message : "Unknown error";
+    return {
+      running: false,
+      url: baseURL,
+      error: errorMessage
+    };
+  }
+}
+async function listOllamaModels(baseURL = DEFAULT_OLLAMA_URL) {
+  try {
+    const response = await fetch(`${baseURL}/api/tags`);
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return (data.models ?? []).map((model) => {
+      const modelInfo = {
+        name: model.name,
+        size: model.size,
+        digest: model.digest,
+        modifiedAt: model.modified_at
+      };
+      if (model.details) {
+        const details = {};
+        if (model.details.family) {
+          details.family = model.details.family;
+        }
+        if (model.details.parameter_size) {
+          details.parameterSize = model.details.parameter_size;
+        }
+        if (model.details.quantization_level) {
+          details.quantizationLevel = model.details.quantization_level;
+        }
+        if (Object.keys(details).length > 0) {
+          modelInfo.details = details;
+        }
+      }
+      return modelInfo;
+    });
+  } catch {
+    return [];
+  }
+}
+async function isOllamaModelAvailable(modelName, baseURL = DEFAULT_OLLAMA_URL) {
+  const models = await listOllamaModels(baseURL);
+  return models.some(
+    (m) => m.name === modelName || m.name.startsWith(`${modelName}:`) || modelName.startsWith(`${m.name}:`)
+  );
+}
+async function pullOllamaModel(modelName, baseURL = DEFAULT_OLLAMA_URL, onProgress, signal) {
+  try {
+    const fetchOptions = {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: modelName })
+    };
+    if (signal) {
+      fetchOptions.signal = signal;
+    }
+    const response = await fetch(`${baseURL}/api/pull`, fetchOptions);
+    if (!response.ok) {
+      throw LocalModelError.ollamaPullFailed(
+        modelName,
+        `HTTP ${response.status}: ${response.statusText}`
+      );
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw LocalModelError.ollamaPullFailed(modelName, "No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const progress = JSON.parse(line);
+          if (progress.error) {
+            throw LocalModelError.ollamaPullFailed(modelName, progress.error);
+          }
+          onProgress?.(progress);
+        } catch (e) {
+          if (e instanceof Error && e.message.includes("ollamaPullFailed")) {
+            throw e;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("ECONNREFUSED")) {
+      throw LocalModelError.ollamaNotRunning(baseURL);
+    }
+    throw error;
+  }
+}
+function createOllamaModel(modelName, config = {}) {
+  const { baseURL = DEFAULT_OLLAMA_URL } = config;
+  const openai = createOpenAI({
+    baseURL: `${baseURL}/v1`,
+    apiKey: "ollama"
+    // Ollama doesn't require an API key, but the SDK requires a non-empty string
+  });
+  return openai(modelName);
+}
+async function createValidatedOllamaModel(modelName, config = {}) {
+  const { baseURL = DEFAULT_OLLAMA_URL } = config;
+  const status = await checkOllamaStatus(baseURL);
+  if (!status.running) {
+    throw LocalModelError.ollamaNotRunning(baseURL);
+  }
+  const isAvailable = await isOllamaModelAvailable(modelName, baseURL);
+  if (!isAvailable) {
+    throw LocalModelError.ollamaModelNotFound(modelName);
+  }
+  return createOllamaModel(modelName, config);
+}
+async function getOllamaModelInfo(modelName, baseURL = DEFAULT_OLLAMA_URL) {
+  const models = await listOllamaModels(baseURL);
+  return models.find(
+    (m) => m.name === modelName || m.name.startsWith(`${modelName}:`) || modelName.startsWith(`${m.name}:`)
+  ) ?? null;
+}
+async function deleteOllamaModel(modelName, baseURL = DEFAULT_OLLAMA_URL) {
+  try {
+    const response = await fetch(`${baseURL}/api/delete`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: modelName })
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function generateOllamaEmbeddings(modelName, input, baseURL = DEFAULT_OLLAMA_URL) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const response = await fetch(`${baseURL}/api/embed`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: modelName,
+      input: inputs
+    })
+  });
+  if (!response.ok) {
+    throw LocalModelError.ollamaApiError(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.embeddings;
+}
+export {
+  DEFAULT_OLLAMA_URL,
+  checkOllamaStatus,
+  createOllamaModel,
+  createValidatedOllamaModel,
+  deleteOllamaModel,
+  generateOllamaEmbeddings,
+  getOllamaModelInfo,
+  isOllamaModelAvailable,
+  listOllamaModels,
+  pullOllamaModel
+};