@elizaos/plugin-ollama 2.0.0-alpha.4 → 2.0.0-alpha.537

package/LICENSE

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,161 @@
+# 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/plugin-ollama
+   ```
+
+2. Make sure Ollama is running:
+   ```bash
+   ollama serve
+   ```
+
+## Usage
+
+Add the plugin to your character configuration:
+
+```json
+"plugins": ["@elizaos/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/browser/index.browser.js

@@ -1,8 +1,8 @@
 // plugin.ts
-import { logger as logger5, ModelType } from "@elizaos/core";
+import { logger as logger5, ModelType as ModelType2 } from "@elizaos/core";
 
 // models/embedding.ts
-import { logger as logger2, MAX_EMBEDDING_TOKENS } from "@elizaos/core";
+import { logger as logger2 } from "@elizaos/core";
 import { embed } from "ai";
 import { createOllama } from "ollama-ai-provider";
 
@@ -39,9 +39,24 @@ function getApiBase(runtime) {
 function getSmallModel(runtime) {
   return getSetting(runtime, "OLLAMA_SMALL_MODEL") || getSetting(runtime, "SMALL_MODEL") || DEFAULT_SMALL_MODEL;
 }
+function getNanoModel(runtime) {
+  return getSetting(runtime, "OLLAMA_NANO_MODEL") || getSetting(runtime, "NANO_MODEL") || getSmallModel(runtime);
+}
+function getMediumModel(runtime) {
+  return getSetting(runtime, "OLLAMA_MEDIUM_MODEL") || getSetting(runtime, "MEDIUM_MODEL") || getSmallModel(runtime);
+}
 function getLargeModel(runtime) {
   return getSetting(runtime, "OLLAMA_LARGE_MODEL") || getSetting(runtime, "LARGE_MODEL") || DEFAULT_LARGE_MODEL;
 }
+function getMegaModel(runtime) {
+  return getSetting(runtime, "OLLAMA_MEGA_MODEL") || getSetting(runtime, "MEGA_MODEL") || getLargeModel(runtime);
+}
+function getResponseHandlerModel(runtime) {
+  return getSetting(runtime, "OLLAMA_RESPONSE_HANDLER_MODEL") || getSetting(runtime, "OLLAMA_SHOULD_RESPOND_MODEL") || getSetting(runtime, "RESPONSE_HANDLER_MODEL") || getSetting(runtime, "SHOULD_RESPOND_MODEL") || getNanoModel(runtime);
+}
+function getActionPlannerModel(runtime) {
+  return getSetting(runtime, "OLLAMA_ACTION_PLANNER_MODEL") || getSetting(runtime, "OLLAMA_PLANNER_MODEL") || getSetting(runtime, "ACTION_PLANNER_MODEL") || getSetting(runtime, "PLANNER_MODEL") || getMediumModel(runtime);
+}
 function getEmbeddingModel(runtime) {
   return getSetting(runtime, "OLLAMA_EMBEDDING_MODEL") || DEFAULT_EMBEDDING_MODEL;
 }
@@ -90,9 +105,9 @@ async function handleTextEmbedding(runtime, params) {
     logger2.log(`[Ollama] Using TEXT_EMBEDDING model: ${modelName}`);
     await ensureModelAvailable(modelName, baseURL, customFetch);
     let text = typeof params === "string" ? params : params ? params.text || "" : "";
-    const maxChars = MAX_EMBEDDING_TOKENS * 4;
+    const maxChars = 8000 * 4;
     if (text.length > maxChars) {
-      logger2.warn(`[Ollama] Embedding input too long (~${Math.ceil(text.length / 4)} tokens), truncating to ~${MAX_EMBEDDING_TOKENS} tokens`);
+      logger2.warn(`[Ollama] Embedding input too long (~${Math.ceil(text.length / 4)} tokens), truncating to ~8000 tokens`);
       text = text.slice(0, maxChars);
     }
     const embeddingText = text || "test";
@@ -168,9 +183,14 @@ async function handleObjectLarge(runtime, params) {
 }
 
 // models/text.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger4, ModelType } from "@elizaos/core";
 import { generateText } from "ai";
 import { createOllama as createOllama3 } from "ollama-ai-provider";
+var TEXT_NANO_MODEL_TYPE = ModelType.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE = ModelType.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE = ModelType.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE = ModelType.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE = ModelType.ACTION_PLANNER ?? "ACTION_PLANNER";
 async function generateOllamaText(ollama, model, params) {
   try {
     const generateParams = {
@@ -190,36 +210,27 @@ async function generateOllamaText(ollama, model, params) {
     return "Error generating text. Please try again later.";
   }
 }
-async function handleTextSmall(runtime, { prompt, stopSequences = [] }) {
-  try {
-    const temperature = 0.7;
-    const frequency_penalty = 0.7;
-    const presence_penalty = 0.7;
-    const max_response_length = 8000;
-    const baseURL = getBaseURL(runtime);
-    const customFetch = runtime.fetch ?? undefined;
-    const ollama = createOllama3({
-      fetch: customFetch,
-      baseURL
-    });
-    const model = getSmallModel(runtime);
-    logger4.log(`[Ollama] Using TEXT_SMALL model: ${model}`);
-    await ensureModelAvailable(model, baseURL, customFetch);
-    return await generateOllamaText(ollama, model, {
-      prompt,
-      system: runtime.character?.system ?? undefined,
-      temperature,
-      maxTokens: max_response_length,
-      frequencyPenalty: frequency_penalty,
-      presencePenalty: presence_penalty,
-      stopSequences
-    });
-  } catch (error) {
-    logger4.error({ error }, "Error in TEXT_SMALL model");
-    return "Error generating text. Please try again later.";
+function getModelNameForType(runtime, modelType) {
+  switch (modelType) {
+    case TEXT_NANO_MODEL_TYPE:
+      return getNanoModel(runtime);
+    case TEXT_MEDIUM_MODEL_TYPE:
+      return getMediumModel(runtime);
+    case ModelType.TEXT_SMALL:
+      return getSmallModel(runtime);
+    case ModelType.TEXT_LARGE:
+      return getLargeModel(runtime);
+    case TEXT_MEGA_MODEL_TYPE:
+      return getMegaModel(runtime);
+    case RESPONSE_HANDLER_MODEL_TYPE:
+      return getResponseHandlerModel(runtime);
+    case ACTION_PLANNER_MODEL_TYPE:
+      return getActionPlannerModel(runtime);
+    default:
+      return getLargeModel(runtime);
   }
 }
-async function handleTextLarge(runtime, {
+async function handleTextWithModelType(runtime, modelType, {
   prompt,
   stopSequences = [],
   maxTokens = 8192,
@@ -228,14 +239,14 @@ async function handleTextLarge(runtime, {
   presencePenalty = 0.7
 }) {
   try {
-    const model = getLargeModel(runtime);
     const baseURL = getBaseURL(runtime);
     const customFetch = runtime.fetch ?? undefined;
     const ollama = createOllama3({
       fetch: customFetch,
       baseURL
     });
-    logger4.log(`[Ollama] Using TEXT_LARGE model: ${model}`);
+    const model = getModelNameForType(runtime, modelType);
+    logger4.log(`[Ollama] Using ${modelType} model: ${model}`);
     await ensureModelAvailable(model, baseURL, customFetch);
     return await generateOllamaText(ollama, model, {
       prompt,
@@ -247,10 +258,31 @@ async function handleTextLarge(runtime, {
       stopSequences
     });
   } catch (error) {
-    logger4.error({ error }, "Error in TEXT_LARGE model");
+    logger4.error({ error }, `Error in ${modelType} model`);
     return "Error generating text. Please try again later.";
   }
 }
+async function handleTextSmall(runtime, params) {
+  return handleTextWithModelType(runtime, ModelType.TEXT_SMALL, params);
+}
+async function handleTextNano(runtime, params) {
+  return handleTextWithModelType(runtime, TEXT_NANO_MODEL_TYPE, params);
+}
+async function handleTextMedium(runtime, params) {
+  return handleTextWithModelType(runtime, TEXT_MEDIUM_MODEL_TYPE, params);
+}
+async function handleTextLarge(runtime, params) {
+  return handleTextWithModelType(runtime, ModelType.TEXT_LARGE, params);
+}
+async function handleTextMega(runtime, params) {
+  return handleTextWithModelType(runtime, TEXT_MEGA_MODEL_TYPE, params);
+}
+async function handleResponseHandler(runtime, params) {
+  return handleTextWithModelType(runtime, RESPONSE_HANDLER_MODEL_TYPE, params);
+}
+async function handleActionPlanner(runtime, params) {
+  return handleTextWithModelType(runtime, ACTION_PLANNER_MODEL_TYPE, params);
+}
 
 // plugin.ts
 var _globalThis = globalThis;
@@ -262,14 +294,34 @@ function getProcessEnv() {
   return process.env;
 }
 var env = getProcessEnv();
+var TEXT_NANO_MODEL_TYPE2 = ModelType2.TEXT_NANO ?? "TEXT_NANO";
+var TEXT_MEDIUM_MODEL_TYPE2 = ModelType2.TEXT_MEDIUM ?? "TEXT_MEDIUM";
+var TEXT_MEGA_MODEL_TYPE2 = ModelType2.TEXT_MEGA ?? "TEXT_MEGA";
+var RESPONSE_HANDLER_MODEL_TYPE2 = ModelType2.RESPONSE_HANDLER ?? "RESPONSE_HANDLER";
+var ACTION_PLANNER_MODEL_TYPE2 = ModelType2.ACTION_PLANNER ?? "ACTION_PLANNER";
 var ollamaPlugin = {
   name: "ollama",
   description: "Ollama plugin for local LLM inference",
   config: {
     OLLAMA_API_ENDPOINT: env.OLLAMA_API_ENDPOINT ?? null,
+    OLLAMA_NANO_MODEL: env.OLLAMA_NANO_MODEL ?? null,
     OLLAMA_SMALL_MODEL: env.OLLAMA_SMALL_MODEL ?? null,
     OLLAMA_MEDIUM_MODEL: env.OLLAMA_MEDIUM_MODEL ?? null,
     OLLAMA_LARGE_MODEL: env.OLLAMA_LARGE_MODEL ?? null,
+    OLLAMA_MEGA_MODEL: env.OLLAMA_MEGA_MODEL ?? null,
+    OLLAMA_RESPONSE_HANDLER_MODEL: env.OLLAMA_RESPONSE_HANDLER_MODEL ?? null,
+    OLLAMA_SHOULD_RESPOND_MODEL: env.OLLAMA_SHOULD_RESPOND_MODEL ?? null,
+    OLLAMA_ACTION_PLANNER_MODEL: env.OLLAMA_ACTION_PLANNER_MODEL ?? null,
+    OLLAMA_PLANNER_MODEL: env.OLLAMA_PLANNER_MODEL ?? null,
+    NANO_MODEL: env.NANO_MODEL ?? null,
+    MEDIUM_MODEL: env.MEDIUM_MODEL ?? null,
+    SMALL_MODEL: env.SMALL_MODEL ?? null,
+    LARGE_MODEL: env.LARGE_MODEL ?? null,
+    MEGA_MODEL: env.MEGA_MODEL ?? null,
+    RESPONSE_HANDLER_MODEL: env.RESPONSE_HANDLER_MODEL ?? null,
+    SHOULD_RESPOND_MODEL: env.SHOULD_RESPOND_MODEL ?? null,
+    ACTION_PLANNER_MODEL: env.ACTION_PLANNER_MODEL ?? null,
+    PLANNER_MODEL: env.PLANNER_MODEL ?? null,
     OLLAMA_EMBEDDING_MODEL: env.OLLAMA_EMBEDDING_MODEL ?? null
   },
   async init(_config, runtime) {
@@ -295,19 +347,34 @@ var ollamaPlugin = {
     }
   },
   models: {
-    [ModelType.TEXT_EMBEDDING]: async (runtime, params) => {
+    [ModelType2.TEXT_EMBEDDING]: async (runtime, params) => {
       return handleTextEmbedding(runtime, params);
     },
-    [ModelType.TEXT_SMALL]: async (runtime, params) => {
+    [TEXT_NANO_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextNano(runtime, params);
+    },
+    [ModelType2.TEXT_SMALL]: async (runtime, params) => {
       return handleTextSmall(runtime, params);
     },
-    [ModelType.TEXT_LARGE]: async (runtime, params) => {
+    [TEXT_MEDIUM_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMedium(runtime, params);
+    },
+    [ModelType2.TEXT_LARGE]: async (runtime, params) => {
       return handleTextLarge(runtime, params);
     },
-    [ModelType.OBJECT_SMALL]: async (runtime, params) => {
+    [TEXT_MEGA_MODEL_TYPE2]: async (runtime, params) => {
+      return handleTextMega(runtime, params);
+    },
+    [RESPONSE_HANDLER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleResponseHandler(runtime, params);
+    },
+    [ACTION_PLANNER_MODEL_TYPE2]: async (runtime, params) => {
+      return handleActionPlanner(runtime, params);
+    },
+    [ModelType2.OBJECT_SMALL]: async (runtime, params) => {
       return handleObjectSmall(runtime, params);
     },
-    [ModelType.OBJECT_LARGE]: async (runtime, params) => {
+    [ModelType2.OBJECT_LARGE]: async (runtime, params) => {
       return handleObjectLarge(runtime, params);
     }
   },
@@ -333,7 +400,8 @@ var ollamaPlugin = {
           name: "ollama_test_text_embedding",
           fn: async (runtime) => {
             try {
-              const embedding = await runtime.useModel(ModelType.TEXT_EMBEDDING, {
+              const runModel = runtime.useModel.bind(runtime);
+              const embedding = await runModel(ModelType2.TEXT_EMBEDDING, {
                 text: "Hello, world!"
               });
               logger5.log({ embedding }, "Generated embedding");
@@ -346,7 +414,8 @@ var ollamaPlugin = {
           name: "ollama_test_text_large",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(ModelType.TEXT_LARGE, {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType2.TEXT_LARGE, {
                 prompt: "What is the nature of reality in 10 words?"
               });
               if (text.length === 0) {
@@ -363,7 +432,8 @@ var ollamaPlugin = {
           name: "ollama_test_text_small",
           fn: async (runtime) => {
             try {
-              const text = await runtime.useModel(ModelType.TEXT_SMALL, {
+              const runModel = runtime.useModel.bind(runtime);
+              const text = await runModel(ModelType2.TEXT_SMALL, {
                 prompt: "What is the nature of reality in 10 words?"
               });
               if (text.length === 0) {
@@ -380,7 +450,8 @@ var ollamaPlugin = {
           name: "ollama_test_object_small",
           fn: async (runtime) => {
             try {
-              const object = await runtime.useModel(ModelType.OBJECT_SMALL, {
+              const runModel = runtime.useModel.bind(runtime);
+              const object = await runModel(ModelType2.OBJECT_SMALL, {
                 prompt: "Generate a JSON object representing a user profile with name, age, and hobbies",
                 temperature: 0.7,
                 schema: undefined
@@ -395,7 +466,8 @@ var ollamaPlugin = {
           name: "ollama_test_object_large",
           fn: async (runtime) => {
             try {
-              const object = await runtime.useModel(ModelType.OBJECT_LARGE, {
+              const runModel = runtime.useModel.bind(runtime);
+              const object = await runModel(ModelType2.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: undefined
@@ -410,20 +482,28 @@ var ollamaPlugin = {
     }
   ]
 };
+// index.browser.ts
+var defaultOllamaPlugin = ollamaPlugin;
+var index_browser_default = defaultOllamaPlugin;
 export {
   ollamaPlugin,
   getSmallModel,
   getSetting,
+  getResponseHandlerModel,
+  getNanoModel,
+  getMegaModel,
+  getMediumModel,
   getLargeModel,
   getEmbeddingModel,
   getBaseURL,
   getApiBase,
-  ollamaPlugin as default,
+  getActionPlannerModel,
+  index_browser_default as default,
   DEFAULT_SMALL_MODEL,
   DEFAULT_OLLAMA_URL,
   DEFAULT_LARGE_MODEL,
   DEFAULT_EMBEDDING_MODEL
 };
 
-//# debugId=721B0B6B2A794CB964756E2164756E21
+//# debugId=2C63C4D5DEE6210E64756E2164756E21
 //# sourceMappingURL=index.browser.js.map