@agentionai/agents 0.11.1 → 0.12.0

package/dist/agents/Agent.d.ts

@@ -4,7 +4,8 @@ import { BaseAgentConfig } from "./BaseAgent";
 import { OpenAiAgent } from "./openai/OpenAiAgent";
 import { GeminiAgent } from "./google/GeminiAgent";
 import { MistralAgent } from "./mistral/MistralAgent";
-import { ClaudeModel, OpenAIModel, GeminiModel, MistralModel } from "./model-types";
+import { OllamaAgent } from "./ollama/OllamaAgent";
+import { ClaudeModel, OpenAIModel, GeminiModel, MistralModel, OllamaModel } from "./model-types";
 type ClaudeAgentConfig = Omit<BaseAgentConfig, "vendor" | "model"> & {
     vendor: "anthropic";
     model?: ClaudeModel;
@@ -21,9 +22,14 @@ type MistralAgentConfig = Omit<BaseAgentConfig, "vendor" | "model"> & {
     vendor: "mistral";
     model?: MistralModel;
 };
-type AgentConfig = ClaudeAgentConfig | OpenAIAgentConfig | GeminiAgentConfig | MistralAgentConfig;
+type OllamaAgentConfig = Omit<BaseAgentConfig, "vendor" | "model"> & {
+    vendor: "ollama";
+    model?: OllamaModel;
+    host?: string;
+};
+type AgentConfig = ClaudeAgentConfig | OpenAIAgentConfig | GeminiAgentConfig | MistralAgentConfig | OllamaAgentConfig;
 export declare class Agent {
-    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | OpenAiAgent | MistralAgent;
+    static create(config: AgentConfig, history?: History): ClaudeAgent | GeminiAgent | OpenAiAgent | MistralAgent | OllamaAgent;
 }
 export {};
 //# sourceMappingURL=Agent.d.ts.map

package/dist/agents/Agent.js

@@ -5,6 +5,7 @@ const ClaudeAgent_1 = require("./anthropic/ClaudeAgent");
 const OpenAiAgent_1 = require("./openai/OpenAiAgent");
 const GeminiAgent_1 = require("./google/GeminiAgent");
 const MistralAgent_1 = require("./mistral/MistralAgent");
+const OllamaAgent_1 = require("./ollama/OllamaAgent");
 class Agent {
     static create(config, history) {
         if (config.vendor === "anthropic") {
@@ -19,6 +20,9 @@ class Agent {
         else if (config.vendor === "mistral") {
             return new MistralAgent_1.MistralAgent(config, history);
         }
+        else if (config.vendor === "ollama") {
+            return new OllamaAgent_1.OllamaAgent(config, history);
+        }
         else {
             throw new Error("No vendor defined");
         }

package/dist/agents/AgentConfig.d.ts

@@ -1,7 +1,7 @@
 import { Tool } from "../tools/Tool";
 import { BaseAgent } from "./BaseAgent";
 /** Supported LLM vendors */
-export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini";
+export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini" | "ollama";
 /**
  * Common configuration shared by all agents
  */
@@ -86,6 +86,13 @@ export interface GeminiSpecificConfig {
     responseMimeType?: string;
     responseSchema?: any;
 }
+/**
+ * Vendor-specific configuration for Ollama (local)
+ */
+export interface OllamaSpecificConfig {
+    /** Ollama server URL (default: http://localhost:11434) */
+    host?: string;
+}
 /**
  * Generic vendor-specific configuration container
  * This allows any vendor to add custom config without modifying base types
@@ -95,6 +102,7 @@ export interface VendorSpecificConfig {
     openai?: OpenAISpecificConfig;
     mistral?: MistralSpecificConfig;
     gemini?: GeminiSpecificConfig;
+    ollama?: OllamaSpecificConfig;
 }
 /**
  * Complete agent configuration with vendor-specific extensions
@@ -134,10 +142,12 @@ export type TypedAgentConfig<V extends AgentVendor> = CommonAgentConfig & {
         mistral?: MistralSpecificConfig;
     } : V extends "gemini" ? {
         gemini?: GeminiSpecificConfig;
+    } : V extends "ollama" ? {
+        ollama?: OllamaSpecificConfig;
     } : never;
 };
 /**
  * Helper type to extract vendor-specific config for a given vendor
  */
-export type VendorConfigFor<V extends AgentVendor> = V extends "anthropic" ? ClaudeSpecificConfig : V extends "openai" ? OpenAISpecificConfig : V extends "mistral" ? MistralSpecificConfig : V extends "gemini" ? GeminiSpecificConfig : never;
+export type VendorConfigFor<V extends AgentVendor> = V extends "anthropic" ? ClaudeSpecificConfig : V extends "openai" ? OpenAISpecificConfig : V extends "mistral" ? MistralSpecificConfig : V extends "gemini" ? GeminiSpecificConfig : V extends "ollama" ? OllamaSpecificConfig : never;
 //# sourceMappingURL=AgentConfig.d.ts.map

package/dist/agents/model-types.d.ts

@@ -21,6 +21,12 @@ export type GeminiModel = "gemini-flash-latest" | "gemini-flash-lite-latest" | "
  * @see https://docs.mistral.ai/getting-started/models/
  */
 export type MistralModel = "mistral-large-latest" | "mistral-small-latest" | "ministral-8b-latest" | "ministral-8b-2410" | "ministral-3b-latest" | "ministral-3b-2410" | "codestral-latest" | "codestral-2405" | "mistral-embed" | "mistral-moderation-latest" | "mistral-moderation-2411" | (string & {});
+/**
+ * Popular Ollama models (locally hosted).
+ * You can also provide any custom string for models you have pulled.
+ * @see https://ollama.com/library
+ */
+export type OllamaModel = "llama3.2" | "llama3.2:1b" | "llama3.1" | "llama3.1:70b" | "llama3" | "mistral" | "mistral-nemo" | "mixtral" | "qwen2.5" | "qwen2.5:7b" | "qwen2.5:72b" | "qwen2.5-coder" | "gemma2" | "gemma2:27b" | "phi3" | "phi4" | "deepseek-r1" | "deepseek-r1:7b" | "deepseek-r1:14b" | "deepseek-r1:70b" | "codellama" | (string & {});
 /**
  * Supported OpenAI models.
  * You can also provide any custom string for newer models not yet listed.

package/dist/agents/ollama/OllamaAgent.d.ts

@@ -0,0 +1,69 @@
+import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { History, MessageContent } from "../../history/History";
+import { OllamaModel } from "../model-types";
+type AgentConfig = BaseAgentConfig & {
+    /** Ollama server URL (default: http://localhost:11434) */
+    host?: string;
+    model?: OllamaModel;
+    maxTokens?: number;
+    think?: boolean;
+};
+type OllamaToolDefinition = {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: object;
+    };
+};
+/**
+ * Agent for locally-hosted Ollama models.
+ *
+ * Requires the `ollama` package as a peer dependency and Ollama running locally.
+ *
+ * @example
+ * ```typescript
+ * const agent = new OllamaAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   model: "llama3.2",
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ *
+ * @example With tools
+ * ```typescript
+ * const agent = new OllamaAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   model: "qwen2.5",  // Qwen models have strong tool-use support
+ *   tools: [myTool],
+ * });
+ * ```
+ */
+export declare class OllamaAgent extends BaseAgent {
+    protected config: Partial<AgentConfig>;
+    /** Token usage from the last execution (for metrics tracking) */
+    lastTokenUsage?: TokenUsage;
+    /** Current visualization event ID */
+    private vizEventId?;
+    /** Count of tool calls in current execution */
+    private currentToolCallCount;
+    /** Cached Ollama client instance */
+    private _client;
+    constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    private getClient;
+    protected getToolDefinitions(): OllamaToolDefinition[];
+    protected process(_input: string): Promise<string>;
+    execute(input: string | MessageContent[]): Promise<string>;
+    private buildOptions;
+    private callOllama;
+    protected handleResponse(response: unknown): Promise<string>;
+    private handleToolCalls;
+    protected parseUsage(input: unknown): TokenUsage;
+}
+export {};
+//# sourceMappingURL=OllamaAgent.d.ts.map

package/dist/agents/ollama/OllamaAgent.js

@@ -0,0 +1,304 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaAgent = void 0;
+const BaseAgent_1 = require("../BaseAgent");
+const AgentEvent_1 = require("../AgentEvent");
+const AgentError_1 = require("../errors/AgentError");
+const transformers_1 = require("../../history/transformers");
+const VizReporter_1 = require("../../viz/VizReporter");
+const VizConfig_1 = require("../../viz/VizConfig");
+/**
+ * Agent for locally-hosted Ollama models.
+ *
+ * Requires the `ollama` package as a peer dependency and Ollama running locally.
+ *
+ * @example
+ * ```typescript
+ * const agent = new OllamaAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   model: "llama3.2",
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ *
+ * @example With tools
+ * ```typescript
+ * const agent = new OllamaAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   model: "qwen2.5",  // Qwen models have strong tool-use support
+ *   tools: [myTool],
+ * });
+ * ```
+ */
+class OllamaAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        super({ ...config, vendor: "ollama" }, history);
+        /** Count of tool calls in current execution */
+        this.currentToolCallCount = 0;
+        /** Cached Ollama client instance */
+        this._client = null;
+        const vendorConfig = config.vendorConfig?.ollama || {};
+        const host = config.host ?? vendorConfig.host;
+        this.config = {
+            model: config.model || "llama3.2",
+            host,
+            maxTokens: config.maxTokens,
+            temperature: config.temperature,
+            topP: config.topP,
+            topK: config.topK,
+            stopSequences: config.stopSequences,
+            seed: config.seed,
+            think: config.think,
+        };
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    async getClient() {
+        if (!this._client) {
+            const pkg = "ollama";
+            try {
+                const mod = (await Promise.resolve(`${pkg}`).then(s => __importStar(require(s))));
+                const OllamaClass = mod.Ollama ?? mod.default?.Ollama;
+                if (!OllamaClass) {
+                    throw new Error("Could not find Ollama class in ollama package");
+                }
+                this._client = new OllamaClass({ host: this.config.host });
+            }
+            catch (err) {
+                throw new AgentError_1.ExecutionError(`Failed to load 'ollama' package. Install it with: npm install ollama\n${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return this._client;
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.getPrompt().name,
+                description: tool.getPrompt().description,
+                parameters: tool.getPrompt().input_schema,
+            },
+        }));
+    }
+    async process(_input) {
+        return "";
+    }
+    async execute(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        this.lastTokenUsage = undefined;
+        this.currentToolCallCount = 0;
+        const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, "ollama", inputPreview);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        if (typeof input === "string") {
+            this.addTextToHistory("user", input);
+        }
+        else {
+            this.addMessageToHistory("user", input);
+        }
+        this.history.setSessionAnchor();
+        this.history.beginExecution();
+        try {
+            await this.getClient(); // ensure client is cached before handleResponse loop
+            const response = await this.callOllama();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
+            return await this.handleResponse(response);
+        }
+        catch (error) {
+            if (error instanceof AgentError_1.ExecutionError || error instanceof AgentError_1.ApiError) {
+                this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, error.constructor.name, error.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw error;
+            }
+            const executionError = new AgentError_1.ExecutionError(`Ollama error: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
+                this.vizEventId = undefined;
+            }
+            throw executionError;
+        }
+        finally {
+            this.history.endExecution();
+        }
+    }
+    buildOptions() {
+        const opts = {};
+        if (this.config.temperature !== undefined)
+            opts.temperature = this.config.temperature;
+        if (this.config.topP !== undefined)
+            opts.top_p = this.config.topP;
+        if (this.config.topK !== undefined)
+            opts.top_k = this.config.topK;
+        if (this.config.seed !== undefined)
+            opts.seed = this.config.seed;
+        if (this.config.maxTokens !== undefined)
+            opts.num_predict = this.config.maxTokens;
+        if (this.config.stopSequences?.length)
+            opts.stop = this.config.stopSequences;
+        if (this.config.think)
+            opts.think = this.config.think;
+        return opts;
+    }
+    async callOllama() {
+        const client = await this.getClient();
+        const messages = transformers_1.ollamaTransformer.toProvider(this.history.getEntries());
+        const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        const options = this.buildOptions();
+        return client.chat({
+            model: this.config.model,
+            messages,
+            tools,
+            stream: false,
+            think: this.config.think,
+            options: Object.keys(options).length > 0 ? options : undefined,
+        });
+    }
+    async handleResponse(response) {
+        const ollamaResponse = response;
+        const usage = this.parseUsage(ollamaResponse);
+        if (this.lastTokenUsage) {
+            this.lastTokenUsage.input_tokens += usage.input_tokens;
+            this.lastTokenUsage.output_tokens += usage.output_tokens;
+            this.lastTokenUsage.total_tokens += usage.total_tokens;
+        }
+        else {
+            this.lastTokenUsage = { ...usage };
+        }
+        if (ollamaResponse.done_reason === "length") {
+            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 2048);
+            this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
+                this.vizEventId = undefined;
+            }
+            throw error;
+        }
+        const message = ollamaResponse.message;
+        const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
+        if (!hasToolCalls) {
+            const textContent = message.content || "";
+            const entry = transformers_1.ollamaTransformer.fromProviderMessage(message, []);
+            this.addToHistory(entry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, message, usage);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+                    input: this.lastTokenUsage?.input_tokens || 0,
+                    output: this.lastTokenUsage?.output_tokens || 0,
+                    total: this.lastTokenUsage?.total_tokens || 0,
+                }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+                this.vizEventId = undefined;
+            }
+            return textContent;
+        }
+        // Tool calls detected
+        const toolCalls = message.tool_calls;
+        this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+        this.currentToolCallCount += toolCalls.length;
+        // Generate IDs — Ollama doesn't provide tool call IDs
+        const generatedIds = toolCalls.map((_, i) => `ollama_${Date.now()}_${i}`);
+        const assistantEntry = transformers_1.ollamaTransformer.fromProviderMessage(message, generatedIds);
+        this.addToHistory(assistantEntry);
+        const toolResults = await this.handleToolCalls(toolCalls, generatedIds);
+        for (const result of toolResults) {
+            const resultEntry = transformers_1.ollamaTransformer.toolResultEntry(result.toolCallId, result.content);
+            this.addToHistory(resultEntry);
+        }
+        // Continue conversation with tool results
+        try {
+            const newResponse = await this.callOllama();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
+            return this.handleResponse(newResponse);
+        }
+        catch (error) {
+            const executionError = new AgentError_1.ExecutionError(`Ollama error during tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            throw executionError;
+        }
+    }
+    async handleToolCalls(toolCalls, generatedIds) {
+        return Promise.all(toolCalls.map(async (toolCall, idx) => {
+            const toolName = toolCall.function.name;
+            const tool = this.tools.get(toolName);
+            const toolCallId = generatedIds[idx];
+            if (!tool) {
+                const errorMessage = `Tool '${toolName}' not found`;
+                const error = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.function.arguments);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, error);
+                return { toolCallId, content: errorMessage };
+            }
+            try {
+                const args = typeof toolCall.function.arguments === "string"
+                    ? JSON.parse(toolCall.function.arguments)
+                    : toolCall.function.arguments;
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "ollama");
+                return { toolCallId, content: JSON.stringify(result) };
+            }
+            catch (error) {
+                const errorMessage = `Error executing tool '${toolName}': ${error instanceof Error ? error.message : "Unknown error"}`;
+                if (this.debug) {
+                    console.error(errorMessage);
+                }
+                const toolError = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.function.arguments);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, toolError);
+                return { toolCallId, content: errorMessage };
+            }
+        }));
+    }
+    parseUsage(input) {
+        const response = input;
+        return {
+            input_tokens: response.prompt_eval_count ?? 0,
+            output_tokens: response.eval_count ?? 0,
+            total_tokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
+        };
+    }
+}
+exports.OllamaAgent = OllamaAgent;
+//# sourceMappingURL=OllamaAgent.js.map

package/dist/history/transformers.d.ts

@@ -98,5 +98,41 @@ export declare const geminiTransformer: {
      */
     getSystemMessage(entries: HistoryEntry[]): string | undefined;
 };
+type OllamaMessage = {
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    tool_calls?: Array<{
+        function: {
+            name: string;
+            arguments: Record<string, unknown>;
+        };
+    }>;
+};
+type OllamaResponseMessage = {
+    role: string;
+    content: string;
+    tool_calls?: Array<{
+        function: {
+            name: string;
+            arguments: Record<string, unknown> | string;
+        };
+    }>;
+};
+export declare const ollamaTransformer: {
+    /**
+     * Convert normalized entries to Ollama message format.
+     * Tool results become role:"tool" messages; tool calls are embedded in assistant messages.
+     */
+    toProvider(entries: HistoryEntry[]): OllamaMessage[];
+    /**
+     * Convert Ollama response message to normalized HistoryEntry.
+     * generatedIds must supply one ID per tool call (Ollama doesn't return IDs).
+     */
+    fromProviderMessage(message: OllamaResponseMessage, generatedIds: string[]): HistoryEntry;
+    /**
+     * Create a normalized tool result entry for Ollama
+     */
+    toolResultEntry(tool_call_id: string, output: string): HistoryEntry;
+};
 export {};
 //# sourceMappingURL=transformers.d.ts.map

package/dist/history/transformers.js

@@ -5,7 +5,7 @@
  * Transform between normalized HistoryEntry format and provider-specific formats.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = void 0;
+exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = void 0;
 const types_1 = require("./types");
 // =============================================================================
 // Anthropic Transformer
@@ -499,4 +499,81 @@ exports.geminiTransformer = {
             .join("\n");
     },
 };
+exports.ollamaTransformer = {
+    /**
+     * Convert normalized entries to Ollama message format.
+     * Tool results become role:"tool" messages; tool calls are embedded in assistant messages.
+     */
+    toProvider(entries) {
+        const messages = [];
+        for (const entry of entries) {
+            const textBlocks = entry.content.filter(types_1.isTextContent);
+            const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
+            const toolResultBlocks = entry.content.filter(types_1.isToolResultContent);
+            if (entry.role === "system") {
+                messages.push({ role: "system", content: textBlocks.map((c) => c.text).join("\n") });
+                continue;
+            }
+            if (entry.role === "assistant") {
+                const msg = {
+                    role: "assistant",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                };
+                if (toolUseBlocks.length > 0) {
+                    msg.tool_calls = toolUseBlocks.map((block) => ({
+                        function: {
+                            name: block.name,
+                            arguments: block.input,
+                        },
+                    }));
+                }
+                messages.push(msg);
+                continue;
+            }
+            // User role — could be text or tool results
+            if (toolResultBlocks.length > 0) {
+                for (const result of toolResultBlocks) {
+                    messages.push({ role: "tool", content: result.content });
+                }
+            }
+            else if (textBlocks.length > 0) {
+                messages.push({ role: "user", content: textBlocks.map((c) => c.text).join("\n") });
+            }
+        }
+        return messages;
+    },
+    /**
+     * Convert Ollama response message to normalized HistoryEntry.
+     * generatedIds must supply one ID per tool call (Ollama doesn't return IDs).
+     */
+    fromProviderMessage(message, generatedIds) {
+        const content = [];
+        if (typeof message.content === "string" && message.content) {
+            content.push((0, types_1.text)(message.content));
+        }
+        if (message.tool_calls) {
+            message.tool_calls.forEach((call, idx) => {
+                const args = typeof call.function.arguments === "string"
+                    ? JSON.parse(call.function.arguments)
+                    : call.function.arguments;
+                content.push((0, types_1.toolUse)(generatedIds[idx] ?? `ollama_tool_${idx}`, call.function.name, args));
+            });
+        }
+        return {
+            role: "assistant",
+            content,
+            meta: { provider: "ollama" },
+        };
+    },
+    /**
+     * Create a normalized tool result entry for Ollama
+     */
+    toolResultEntry(tool_call_id, output) {
+        return {
+            role: "user",
+            content: [(0, types_1.toolResult)(tool_call_id, output)],
+            meta: { provider: "ollama", tool_call_id },
+        };
+    },
+};
 //# sourceMappingURL=transformers.js.map

package/dist/history/types.d.ts

@@ -87,10 +87,17 @@ export type MistralMeta = {
 export type GeminiMeta = {
     provider: "gemini";
 };
+/**
+ * Ollama-specific metadata
+ */
+export type OllamaMeta = {
+    provider: "ollama";
+    tool_call_id?: string;
+};
 /**
  * Union of all provider metadata types
  */
-export type ProviderMeta = AnthropicMeta | OpenAiMeta | MistralMeta | GeminiMeta;
+export type ProviderMeta = AnthropicMeta | OpenAiMeta | MistralMeta | GeminiMeta | OllamaMeta;
 /**
  * Valid roles for history entries
  */

package/dist/index.d.ts

@@ -3,13 +3,14 @@ export * from "./agents/anthropic/ClaudeAgent";
 export { OpenAiAgent } from "./agents/openai/OpenAiAgent";
 export { MistralAgent } from "./agents/mistral/MistralAgent";
 export { GeminiAgent } from "./agents/google/GeminiAgent";
+export { OllamaAgent } from "./agents/ollama/OllamaAgent";
 export * from "./agents/model-types";
 export * from "./agents/AgentConfig";
 export * from "./agents/AgentEvent";
 export * from "./agents/errors/AgentError";
 export * from "./history/History";
 export * from "./history/types";
-export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, } from "./history/transformers";
+export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, ollamaTransformer, } from "./history/transformers";
 export * from "./graph/AgentGraph";
 export * from "./tools/Tool";
 export * from "./mcp";

package/dist/index.js

@@ -22,7 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
+exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
 // Agents
 __exportStar(require("./agents/BaseAgent"), exports);
 __exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
@@ -32,6 +32,8 @@ var MistralAgent_1 = require("./agents/mistral/MistralAgent");
 Object.defineProperty(exports, "MistralAgent", { enumerable: true, get: function () { return MistralAgent_1.MistralAgent; } });
 var GeminiAgent_1 = require("./agents/google/GeminiAgent");
 Object.defineProperty(exports, "GeminiAgent", { enumerable: true, get: function () { return GeminiAgent_1.GeminiAgent; } });
+var OllamaAgent_1 = require("./agents/ollama/OllamaAgent");
+Object.defineProperty(exports, "OllamaAgent", { enumerable: true, get: function () { return OllamaAgent_1.OllamaAgent; } });
 __exportStar(require("./agents/model-types"), exports);
 __exportStar(require("./agents/AgentConfig"), exports);
 __exportStar(require("./agents/AgentEvent"), exports);
@@ -44,6 +46,7 @@ Object.defineProperty(exports, "anthropicTransformer", { enumerable: true, get:
 Object.defineProperty(exports, "openAiTransformer", { enumerable: true, get: function () { return transformers_1.openAiTransformer; } });
 Object.defineProperty(exports, "mistralTransformer", { enumerable: true, get: function () { return transformers_1.mistralTransformer; } });
 Object.defineProperty(exports, "geminiTransformer", { enumerable: true, get: function () { return transformers_1.geminiTransformer; } });
+Object.defineProperty(exports, "ollamaTransformer", { enumerable: true, get: function () { return transformers_1.ollamaTransformer; } });
 // Graph
 __exportStar(require("./graph/AgentGraph"), exports);
 // Tools

package/dist/ollama.d.ts

@@ -0,0 +1,4 @@
+export * from "./core";
+export { OllamaAgent } from "./agents/ollama/OllamaAgent";
+export { ollamaTransformer } from "./history/transformers";
+//# sourceMappingURL=ollama.d.ts.map

package/dist/ollama.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ollamaTransformer = exports.OllamaAgent = void 0;
+// Ollama Agent Entry Point
+__exportStar(require("./core"), exports);
+var OllamaAgent_1 = require("./agents/ollama/OllamaAgent");
+Object.defineProperty(exports, "OllamaAgent", { enumerable: true, get: function () { return OllamaAgent_1.OllamaAgent; } });
+var transformers_1 = require("./history/transformers");
+Object.defineProperty(exports, "ollamaTransformer", { enumerable: true, get: function () { return transformers_1.ollamaTransformer; } });
+//# sourceMappingURL=ollama.js.map

package/dist/viz/VizReporter.js

@@ -167,7 +167,6 @@ class VizReporter extends events_1.EventEmitter {
                 this.scheduleReconnect();
             };
             ws.onerror = () => {
-                ws.onerror = null;
                 ws.close();
             };
         }

package/dist/viz/types.d.ts

@@ -2,7 +2,7 @@
  * Visualization event types and interfaces for agent monitoring.
  * These types define the contract between agention-lib and @agention/viz.
  */
-export type VizVendor = "anthropic" | "openai" | "mistral" | "gemini";
+export type VizVendor = "anthropic" | "openai" | "mistral" | "gemini" | "ollama";
 export type VizEventType = "session.start" | "session.end" | "pipeline.start" | "pipeline.end" | "executor.start" | "executor.end" | "agent.start" | "agent.complete" | "agent.error" | "tool.start" | "tool.complete" | "tool.error" | "message.user" | "message.assistant";
 export type VizExecutorType = "sequential" | "parallel" | "map" | "voting" | "router";
 export type VizStopReason = "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | "error";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,6 +30,10 @@
       "types": "./dist/gemini.d.ts",
       "default": "./dist/gemini.js"
     },
+    "./ollama": {
+      "types": "./dist/ollama.d.ts",
+      "default": "./dist/ollama.js"
+    },
     "./embeddings": {
       "types": "./dist/embeddings/index.d.ts",
       "default": "./dist/embeddings/index.js"
@@ -140,6 +144,7 @@
     "@mistralai/mistralai": "^1.13.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "apache-arrow": "^18.0.0",
+    "ollama": "^0.5.18",
     "openai": "^6.16.0",
     "voyageai": "^0.0.3"
   },
@@ -170,6 +175,9 @@
     },
     "@opensearch-project/opensearch": {
       "optional": true
+    },
+    "ollama": {
+      "optional": true
     }
   },
   "dependencies": {