@elizaos/plugin-ollama 1.2.3 → 2.0.0-alpha.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@elizaos/plugin-ollama",
-  "version": "1.2.3",
+  "version": "2.0.0-alpha.1",
   "type": "module",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/node/index.node.js",
+  "module": "dist/node/index.node.js",
+  "types": "dist/node/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/elizaos-plugins/plugin-ollama.git"
@@ -12,32 +12,54 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/node/index.d.ts",
+      "browser": {
+        "types": "./dist/browser/index.d.ts",
+        "import": "./dist/browser/index.browser.js",
+        "default": "./dist/browser/index.browser.js"
+      },
+      "node": {
+        "types": "./dist/node/index.d.ts",
+        "import": "./dist/node/index.node.js",
+        "default": "./dist/node/index.node.js"
+      },
+      "bun": {
+        "types": "./dist/node/index.d.ts",
+        "default": "./dist/node/index.node.js"
+      },
+      "require": "./dist/cjs/index.node.cjs",
+      "default": "./dist/node/index.node.js"
     }
   },
   "files": [
     "dist"
   ],
+  "sideEffects": false,
   "dependencies": {
     "@ai-sdk/ui-utils": "^1.2.8",
-    "@elizaos/core": "^1.0.0",
+    "@elizaos/core": "workspace:*",
     "ai": "^4.3.9",
     "js-tiktoken": "^1.0.18",
-    "ollama-ai-provider": "^1.2.0",
-    "tsup": "8.4.0"
+    "ollama-ai-provider": "^1.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3",
+    "@biomejs/biome": "^2.3.11"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "lint": "prettier --write ./src",
+    "dev": "bun run build.ts --watch",
+    "lint": "bunx @biomejs/biome check --write --unsafe .",
     "clean": "rm -rf dist .turbo node_modules .turbo-tsconfig.json tsconfig.tsbuildinfo",
-    "format": "prettier --write ./src",
-    "format:check": "prettier --check ./src",
-    "test": "bun test",
-    "postinstall": "bun scripts/install-ollama.js"
+    "format": "bunx @biomejs/biome format --write .",
+    "format:check": "bunx @biomejs/biome format .",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "test:unit": "vitest run __tests__/",
+    "postinstall": "bun scripts/install-ollama.js",
+    "lint:check": "bunx @biomejs/biome check .",
+    "build": "bun run build.ts",
+    "build:ts": "bun run build.ts"
   },
   "publishConfig": {
     "access": "public"
@@ -95,10 +117,5 @@
       }
     }
   },
-  "gitHead": "646c632924826e2b75c2304a75ee56959fe4a460",
-  "devDependencies": {
-    "@types/node": "^24.0.4",
-    "prettier": "3.5.3",
-    "typescript": "^5.8.2"
-  }
+  "gitHead": "646c632924826e2b75c2304a75ee56959fe4a460"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Shaw Walters and elizaOS Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,160 +0,0 @@
-# Ollama Plugin
-
-This plugin provides integration with [Ollama](https://ollama.com/)'s local models through the ElizaOS platform. It allows you to leverage locally running LLMs for text generation, embeddings, and object generation.
-
-## Overview
-
-Ollama enables running large language models locally on your machine. This plugin connects ElizaOS with your local Ollama installation, giving your characters access to powerful language models running on your own hardware.
-
-## Requirements
-
-- [Ollama](https://ollama.com/) installed and running on your system
-- ElizaOS platform
-- At least one Ollama model pulled and available (e.g., `llama3`, `gemma3:latest`)
-
-## Installation
-
-1. Install this plugin in your ElizaOS project:
-   ```bash
-   bun add @elizaos-plugins/plugin-ollama
-   ```
-
-2. Make sure Ollama is running:
-   ```bash
-   ollama serve
-   ```
-
-## Usage
-
-Add the plugin to your character configuration:
-
-```json
-"plugins": ["@elizaos-plugins/plugin-ollama"]
-```
-
-## Configuration
-
-The plugin requires these environment variables (can be set in .env file or character settings):
-
-```json
-"settings": {
-  "OLLAMA_API_ENDPOINT": "http://localhost:11434/api",
-  "OLLAMA_SMALL_MODEL": "gemma3:latest",
-  "OLLAMA_MEDIUM_MODEL": "gemma3:latest",
-  "OLLAMA_LARGE_MODEL": "gemma3:latest",
-  "OLLAMA_EMBEDDING_MODEL": "nomic-embed-text:latest"
-}
-```
-
-Or in `.env` file:
-
-```
-OLLAMA_API_ENDPOINT=http://localhost:11434/api
-OLLAMA_SMALL_MODEL=gemma3:latest
-OLLAMA_MEDIUM_MODEL=gemma3:latest
-OLLAMA_LARGE_MODEL=gemma3:latest
-OLLAMA_EMBEDDING_MODEL=nomic-embed-text:latest
-```
-
-### Configuration Options
-
-- `OLLAMA_API_ENDPOINT`: Ollama API endpoint (default: http://localhost:11434/api)
-- `OLLAMA_SMALL_MODEL`: Model for simpler tasks (default: gemma3:latest)
-- `OLLAMA_MEDIUM_MODEL`: Medium-complexity model (default: gemma3:latest)
-- `OLLAMA_LARGE_MODEL`: Model for complex tasks (default: gemma3:latest)
-- `OLLAMA_EMBEDDING_MODEL`: Model for text embeddings (default: nomic-embed-text:latest)
-
-The plugin provides these model classes:
-
-- `TEXT_SMALL`: Optimized for fast responses with simpler prompts
-- `TEXT_LARGE`: For complex tasks requiring deeper reasoning
-- `TEXT_EMBEDDING`: Text embedding model
-- `OBJECT_SMALL`: JSON object generation with simpler models
-- `OBJECT_LARGE`: JSON object generation with more complex models
-
-## API Reference
-
-For detailed information about the Ollama API used by this plugin, refer to the [official Ollama API documentation](https://github.com/ollama/ollama/blob/main/docs/api.md).
-
-
-
-## Features
-
-### Text Generation (Small Model)
-
-Generate text using smaller, faster models optimized for quick responses:
-
-```js
-const text = await runtime.useModel(ModelType.TEXT_SMALL, {
-  prompt: 'What is the nature of reality?',
-  stopSequences: [], // optional
-});
-```
-
-### Text Generation (Large Model)
-
-Generate comprehensive text responses using more powerful models for complex tasks:
-
-```js
-const text = await runtime.useModel(ModelType.TEXT_LARGE, {
-  prompt: 'Write a detailed explanation of quantum physics',
-  stopSequences: [], // optional
-  maxTokens: 8192, // optional (default: 8192)
-  temperature: 0.7, // optional (default: 0.7)
-  frequencyPenalty: 0.7, // optional (default: 0.7)
-  presencePenalty: 0.7, // optional (default: 0.7)
-});
-```
-
-### Text Embeddings
-
-Generate vector embeddings for text, which can be used for semantic search or other vector operations:
-
-```js
-const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
-  text: 'Text to embed',
-});
-// or
-const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, 'Text to embed');
-```
-
-### Object Generation (Small Model)
-
-Generate structured JSON objects using faster models:
-
-```js
-const object = await runtime.useModel(ModelType.OBJECT_SMALL, {
-  prompt: 'Generate a JSON object representing a user profile',
-  temperature: 0.7, // optional
-});
-```
-
-### Object Generation (Large Model)
-
-Generate complex, detailed JSON objects using more powerful models:
-
-```js
-const object = await runtime.useModel(ModelType.OBJECT_LARGE, {
-  prompt: 'Generate a detailed JSON object representing a restaurant',
-  temperature: 0.7, // optional
-});
-```
-
-## Troubleshooting
-
-### Connection Issues
-
-- Ensure Ollama is running by testing the `OLLAMA_API_ENDPOINT`
-- Verify the `OLLAMA_API_ENDPOINT` points to the correct host and port
-- Check firewall settings if connecting to a remote Ollama instance
-
-### Model Availability
-
-- The plugin will attempt to download models automatically if they're not found
-- You can pre-download models using `ollama pull modelname`
-- Check model availability with `ollama list`
-
-
-## License
-
-See LICENSE file for details.

package/dist/index.js

@@ -1,367 +0,0 @@
-// src/index.ts
-import { ModelType, logger } from "@elizaos/core";
-import { generateObject, generateText, embed } from "ai";
-import { createOllama } from "ollama-ai-provider";
-var OLLAMA_API_URL = "http://localhost:11434/api";
-function getBaseURL(runtime) {
-  const apiEndpoint = runtime.getSetting("OLLAMA_API_ENDPOINT") || runtime.getSetting("OLLAMA_API_URL") || OLLAMA_API_URL;
-  if (!apiEndpoint.endsWith("/api")) {
-    return apiEndpoint.endsWith("/") ? `${apiEndpoint}api` : `${apiEndpoint}/api`;
-  }
-  return apiEndpoint;
-}
-async function ensureModelAvailable(runtime, model, providedBaseURL) {
-  const baseURL = providedBaseURL || getBaseURL(runtime);
-  const apiBase = baseURL.endsWith("/api") ? baseURL.slice(0, -4) : baseURL;
-  try {
-    const showRes = await fetch(`${apiBase}/api/show`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ model })
-    });
-    if (showRes.ok) return;
-    logger.info(`[Ollama] Model ${model} not found locally. Downloading...`);
-    const pullRes = await fetch(`${apiBase}/api/pull`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ model, stream: false })
-    });
-    if (!pullRes.ok) {
-      logger.error(`Failed to pull model ${model}: ${pullRes.statusText}`);
-    } else {
-      logger.info(`[Ollama] Downloaded model ${model}`);
-    }
-  } catch (err) {
-    logger.error("Error ensuring model availability:", err);
-  }
-}
-async function generateOllamaText(ollama, model, params) {
-  try {
-    const { text: ollamaResponse } = await generateText({
-      model: ollama(model),
-      prompt: params.prompt,
-      system: params.system,
-      temperature: params.temperature,
-      maxTokens: params.maxTokens,
-      frequencyPenalty: params.frequencyPenalty,
-      presencePenalty: params.presencePenalty,
-      stopSequences: params.stopSequences
-    });
-    return ollamaResponse;
-  } catch (error) {
-    logger.error("Error in generateOllamaText:", error);
-    return "Error generating text. Please try again later.";
-  }
-}
-async function generateOllamaObject(ollama, model, params) {
-  try {
-    const { object } = await generateObject({
-      model: ollama(model),
-      output: "no-schema",
-      prompt: params.prompt,
-      temperature: params.temperature
-    });
-    return object;
-  } catch (error) {
-    logger.error("Error generating object:", error);
-    return {};
-  }
-}
-var ollamaPlugin = {
-  name: "ollama",
-  description: "Ollama plugin",
-  config: {
-    OLLAMA_API_ENDPOINT: process.env.OLLAMA_API_ENDPOINT,
-    OLLAMA_SMALL_MODEL: process.env.OLLAMA_SMALL_MODEL,
-    OLLAMA_MEDIUM_MODEL: process.env.OLLAMA_MEDIUM_MODEL,
-    OLLAMA_LARGE_MODEL: process.env.OLLAMA_LARGE_MODEL,
-    OLLAMA_EMBEDDING_MODEL: process.env.OLLAMA_EMBEDDING_MODEL
-  },
-  async init(_config, runtime) {
-    const baseURL = getBaseURL(runtime);
-    if (!baseURL || baseURL === "http://localhost:11434/api") {
-      const endpoint = runtime.getSetting("OLLAMA_API_ENDPOINT");
-      if (!endpoint) {
-        logger.warn(
-          "OLLAMA_API_ENDPOINT is not set in environment - Ollama functionality will use default localhost:11434"
-        );
-      }
-    }
-    try {
-      const apiBase = baseURL.endsWith("/api") ? baseURL.slice(0, -4) : baseURL;
-      const response = await fetch(`${apiBase}/api/tags`, {
-        method: "GET",
-        headers: { "Content-Type": "application/json" }
-      });
-      if (!response.ok) {
-        logger.warn(
-          `Ollama API endpoint validation failed: ${response.statusText}`
-        );
-        logger.warn(
-          "Ollama functionality will be limited until a valid endpoint is provided"
-        );
-      } else {
-        const data = await response.json();
-        const modelCount = data?.models?.length || 0;
-        logger.log(
-          `Ollama API endpoint validated successfully. Found ${modelCount} models available.`
-        );
-      }
-    } catch (fetchError) {
-      const message = fetchError instanceof Error ? fetchError.message : String(fetchError);
-      logger.warn(`Error validating Ollama API endpoint: ${message}`);
-      logger.warn(
-        "Ollama functionality will be limited until a valid endpoint is provided - Make sure Ollama is running at ${baseURL}"
-      );
-    }
-  },
-  models: {
-    [ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
-      try {
-        const baseURL = getBaseURL(runtime);
-        const ollama = createOllama({
-          fetch: runtime.fetch,
-          baseURL
-        });
-        const modelName = runtime.getSetting("OLLAMA_EMBEDDING_MODEL") || "nomic-embed-text:latest";
-        logger.log(`[Ollama] Using TEXT_EMBEDDING model: ${modelName}`);
-        await ensureModelAvailable(runtime, modelName, baseURL);
-        const text = typeof params === "string" ? params : params ? params.text || "" : "";
-        const embeddingText = text || "test";
-        if (!text) {
-          logger.debug(
-            "No text provided for embedding, using default text for dimension detection"
-          );
-        }
-        try {
-          const { embedding } = await embed({
-            model: ollama.embedding(modelName),
-            value: embeddingText
-          });
-          return embedding;
-        } catch (embeddingError) {
-          logger.error("Error generating embedding:", embeddingError);
-          return Array(1536).fill(0);
-        }
-      } catch (error) {
-        logger.error("Error in TEXT_EMBEDDING model:", error);
-        return Array(1536).fill(0);
-      }
-    },
-    [ModelType.TEXT_SMALL]: async (runtime, { prompt, stopSequences = [] }) => {
-      try {
-        const temperature = 0.7;
-        const frequency_penalty = 0.7;
-        const presence_penalty = 0.7;
-        const max_response_length = 8e3;
-        const baseURL = getBaseURL(runtime);
-        const ollama = createOllama({
-          fetch: runtime.fetch,
-          baseURL
-        });
-        const model = runtime.getSetting("OLLAMA_SMALL_MODEL") || runtime.getSetting("SMALL_MODEL") || "gemma3:latest";
-        logger.log(`[Ollama] Using TEXT_SMALL model: ${model}`);
-        await ensureModelAvailable(runtime, model, baseURL);
-        logger.log("generating text");
-        logger.log(prompt);
-        return await generateOllamaText(ollama, model, {
-          prompt,
-          system: runtime.character?.system || void 0,
-          temperature,
-          maxTokens: max_response_length,
-          frequencyPenalty: frequency_penalty,
-          presencePenalty: presence_penalty,
-          stopSequences
-        });
-      } catch (error) {
-        logger.error("Error in TEXT_SMALL model:", error);
-        return "Error generating text. Please try again later.";
-      }
-    },
-    [ModelType.TEXT_LARGE]: async (runtime, {
-      prompt,
-      stopSequences = [],
-      maxTokens = 8192,
-      temperature = 0.7,
-      frequencyPenalty = 0.7,
-      presencePenalty = 0.7
-    }) => {
-      try {
-        const model = runtime.getSetting("OLLAMA_LARGE_MODEL") || runtime.getSetting("LARGE_MODEL") || "gemma3:latest";
-        const baseURL = getBaseURL(runtime);
-        const ollama = createOllama({
-          fetch: runtime.fetch,
-          baseURL
-        });
-        logger.log(`[Ollama] Using TEXT_LARGE model: ${model}`);
-        await ensureModelAvailable(runtime, model, baseURL);
-        return await generateOllamaText(ollama, model, {
-          prompt,
-          system: runtime.character?.system || void 0,
-          temperature,
-          maxTokens,
-          frequencyPenalty,
-          presencePenalty,
-          stopSequences
-        });
-      } catch (error) {
-        logger.error("Error in TEXT_LARGE model:", error);
-        return "Error generating text. Please try again later.";
-      }
-    },
-    [ModelType.OBJECT_SMALL]: async (runtime, params) => {
-      try {
-        const baseURL = getBaseURL(runtime);
-        const ollama = createOllama({
-          fetch: runtime.fetch,
-          baseURL
-        });
-        const model = runtime.getSetting("OLLAMA_SMALL_MODEL") || runtime.getSetting("SMALL_MODEL") || "gemma3:latest";
-        logger.log(`[Ollama] Using OBJECT_SMALL model: ${model}`);
-        await ensureModelAvailable(runtime, model, baseURL);
-        if (params.schema) {
-          logger.info("Using OBJECT_SMALL without schema validation");
-        }
-        return await generateOllamaObject(ollama, model, params);
-      } catch (error) {
-        logger.error("Error in OBJECT_SMALL model:", error);
-        return {};
-      }
-    },
-    [ModelType.OBJECT_LARGE]: async (runtime, params) => {
-      try {
-        const baseURL = getBaseURL(runtime);
-        const ollama = createOllama({
-          fetch: runtime.fetch,
-          baseURL
-        });
-        const model = runtime.getSetting("OLLAMA_LARGE_MODEL") || runtime.getSetting("LARGE_MODEL") || "gemma3:latest";
-        logger.log(`[Ollama] Using OBJECT_LARGE model: ${model}`);
-        await ensureModelAvailable(runtime, model, baseURL);
-        if (params.schema) {
-          logger.info("Using OBJECT_LARGE without schema validation");
-        }
-        return await generateOllamaObject(ollama, model, params);
-      } catch (error) {
-        logger.error("Error in OBJECT_LARGE model:", error);
-        return {};
-      }
-    }
-  },
-  tests: [
-    {
-      name: "ollama_plugin_tests",
-      tests: [
-        {
-          name: "ollama_test_url_validation",
-          fn: async (runtime) => {
-            try {
-              const baseURL = getBaseURL(runtime);
-              const apiBase = baseURL.endsWith("/api") ? baseURL.slice(0, -4) : baseURL;
-              const response = await fetch(`${apiBase}/api/tags`);
-              const data = await response.json();
-              logger.log(
-                "Models Available:",
-                data && typeof data === "object" && "models" in data && Array.isArray(data.models) ? data.models.length : 0
-              );
-              if (!response.ok) {
-                logger.error(
-                  `Failed to validate Ollama API: ${response.statusText}`
-                );
-                return;
-              }
-            } catch (error) {
-              logger.error("Error in ollama_test_url_validation:", error);
-            }
-          }
-        },
-        {
-          name: "ollama_test_text_embedding",
-          fn: async (runtime) => {
-            try {
-              const embedding = await runtime.useModel(
-                ModelType.TEXT_EMBEDDING,
-                {
-                  text: "Hello, world!"
-                }
-              );
-              logger.log("embedding", embedding);
-            } catch (error) {
-              logger.error("Error in test_text_embedding:", error);
-            }
-          }
-        },
-        {
-          name: "ollama_test_text_large",
-          fn: async (runtime) => {
-            try {
-              const text = await runtime.useModel(ModelType.TEXT_LARGE, {
-                prompt: "What is the nature of reality in 10 words?"
-              });
-              if (text.length === 0) {
-                logger.error("Failed to generate text");
-                return;
-              }
-              logger.log("generated with test_text_large:", text);
-            } catch (error) {
-              logger.error("Error in test_text_large:", error);
-            }
-          }
-        },
-        {
-          name: "ollama_test_text_small",
-          fn: async (runtime) => {
-            try {
-              const text = await runtime.useModel(ModelType.TEXT_SMALL, {
-                prompt: "What is the nature of reality in 10 words?"
-              });
-              if (text.length === 0) {
-                logger.error("Failed to generate text");
-                return;
-              }
-              logger.log("generated with test_text_small:", text);
-            } catch (error) {
-              logger.error("Error in test_text_small:", error);
-            }
-          }
-        },
-        {
-          name: "ollama_test_object_small",
-          fn: async (runtime) => {
-            try {
-              const object = await runtime.useModel(ModelType.OBJECT_SMALL, {
-                prompt: "Generate a JSON object representing a user profile with name, age, and hobbies",
-                temperature: 0.7,
-                schema: void 0
-              });
-              logger.log("Generated object:", object);
-            } catch (error) {
-              logger.error("Error in test_object_small:", error);
-            }
-          }
-        },
-        {
-          name: "ollama_test_object_large",
-          fn: async (runtime) => {
-            try {
-              const object = await runtime.useModel(ModelType.OBJECT_LARGE, {
-                prompt: "Generate a detailed JSON object representing a restaurant with name, cuisine type, menu items with prices, and customer reviews",
-                temperature: 0.7,
-                schema: void 0
-              });
-              logger.log("Generated object:", object);
-            } catch (error) {
-              logger.error("Error in test_object_large:", error);
-            }
-          }
-        }
-      ]
-    }
-  ]
-};
-var index_default = ollamaPlugin;
-export {
-  index_default as default,
-  ollamaPlugin
-};
-//# sourceMappingURL=index.js.map