@agentionai/agents 0.13.0 → 0.14.0

package/README.md

@@ -119,7 +119,7 @@ const agent = new GeminiAgent({
 const response = await agent.execute("What's the weather in Paris?");
 ```
 
-### Local Models (Ollama / llama.cpp)
+### Local Models (Ollama / llama.cpp / OpenAI-compatible servers)
 
 Run models on your own machine — no API key required. Same agent interface as every other provider:
 
@@ -151,6 +151,21 @@ const response = await ollama.execute('What can you run locally?');
 const models = await ollama.listModels();
 ```
 
+**Custom OpenAI-compatible server** (vLLM, LM Studio, Together AI, Groq, …): extend `OpenAICompatibleAgent` directly:
+
+```typescript
+import { OpenAICompatibleAgent, OpenAICompatibleConfig } from '@agentionai/agents/llamacpp';
+
+class VLLMAgent extends OpenAICompatibleAgent {
+  constructor(config: Omit<OpenAICompatibleConfig, 'vendor'>) {
+    super({ ...config, vendor: 'llamacpp', baseURL: config.baseURL ?? 'http://localhost:8000/v1' });
+  }
+  protected getVendorName() { return 'vLLM'; }
+}
+```
+
+[Full guide →](https://docs.agention.ai/guide/agents#custom-openai-compatible-agents)
+
 ### Built-In Tools
 
 Use a provider's own server-side tools (executed by the provider, not locally) alongside your custom tools:

package/dist/agents/llamacpp/LlamaCppAgent.d.ts

@@ -1,13 +1,10 @@
-import { ChatCompletion, ChatCompletionTool } from "openai/resources/chat/completions";
-import { Model } from "openai/resources/models";
-import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
-import { History, MessageContent } from "../../history/History";
+import { History } from "../../history/History";
+import { OpenAICompatibleAgent, OpenAICompatibleConfig } from "../openai-compatible/OpenAICompatibleAgent";
 import { LlamaCppModel } from "../model-types";
-type AgentConfig = BaseAgentConfig & {
+type LlamaCppConfig = Omit<OpenAICompatibleConfig, "baseURL" | "model" | "vendor"> & {
     /** Base URL of the llama.cpp server's OpenAI-compatible API (default: `http://localhost:8080/v1`) */
     baseURL?: string;
     model?: LlamaCppModel;
-    maxTokens?: number;
 };
 /**
  * Agent for locally-hosted models served by a llama.cpp server (`llama-server`),
@@ -21,7 +18,6 @@ type AgentConfig = BaseAgentConfig & {
  *   id: "1",
  *   name: "Assistant",
  *   description: "A helpful assistant",
- *   apiKey: "",
  *   baseURL: "http://localhost:8080/v1",
  * });
  *
@@ -33,28 +29,9 @@ type AgentConfig = BaseAgentConfig & {
  * const models = await agent.listModels();
  * ```
  */
-export declare class LlamaCppAgent extends BaseAgent {
-    private client;
-    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;
-    constructor(config: Omit<AgentConfig, "vendor">, history?: History);
-    /**
-     * List the models currently available on the llama.cpp server (via its
-     * OpenAI-compatible `/v1/models` endpoint).
-     */
-    listModels(): Promise<Model[]>;
-    protected getToolDefinitions(): ChatCompletionTool[];
-    protected process(_input: string): Promise<string>;
-    execute(input: string | MessageContent[]): Promise<string>;
-    private callLlamaCpp;
-    protected handleResponse(response: ChatCompletion): Promise<string>;
-    private handleToolCalls;
-    protected parseUsage(response: ChatCompletion): TokenUsage;
+export declare class LlamaCppAgent extends OpenAICompatibleAgent {
+    constructor(config: LlamaCppConfig, history?: History);
+    protected getVendorName(): string;
 }
 export {};
 //# sourceMappingURL=LlamaCppAgent.d.ts.map

package/dist/agents/llamacpp/LlamaCppAgent.js

@@ -1,16 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlamaCppAgent = void 0;
-const openai_1 = __importDefault(require("openai"));
-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");
+const OpenAICompatibleAgent_1 = require("../openai-compatible/OpenAICompatibleAgent");
 /**
  * Agent for locally-hosted models served by a llama.cpp server (`llama-server`),
  * which exposes an OpenAI-compatible `/v1/chat/completions` API.
@@ -23,7 +14,6 @@ const VizConfig_1 = require("../../viz/VizConfig");
  *   id: "1",
  *   name: "Assistant",
  *   description: "A helpful assistant",
- *   apiKey: "",
  *   baseURL: "http://localhost:8080/v1",
  * });
  *
@@ -35,227 +25,19 @@ const VizConfig_1 = require("../../viz/VizConfig");
  * const models = await agent.listModels();
  * ```
  */
-class LlamaCppAgent extends BaseAgent_1.BaseAgent {
+class LlamaCppAgent extends OpenAICompatibleAgent_1.OpenAICompatibleAgent {
     constructor(config, history) {
-        super({ ...config, vendor: "llamacpp" }, history);
-        /** Count of tool calls in current execution */
-        this.currentToolCallCount = 0;
         const vendorConfig = config.vendorConfig?.llamacpp || {};
         const baseURL = config.baseURL ?? vendorConfig.baseURL ?? "http://localhost:8080/v1";
-        this.client = new openai_1.default({
-            apiKey: config.apiKey || "not-needed",
+        super({
+            ...config,
+            vendor: "llamacpp",
             baseURL,
-        });
-        this.config = {
-            model: config.model || "default",
-            baseURL,
-            maxTokens: config.maxTokens,
-            temperature: config.temperature,
-            topP: config.topP,
-            stopSequences: config.stopSequences,
-            seed: config.seed,
-            presencePenalty: config.presencePenalty,
-            frequencyPenalty: config.frequencyPenalty,
-            apiKey: config.apiKey,
-        };
-        this.addSystemMessage(this.getSystemMessage());
-    }
-    /**
-     * List the models currently available on the llama.cpp server (via its
-     * OpenAI-compatible `/v1/models` endpoint).
-     */
-    async listModels() {
-        try {
-            const page = await this.client.models.list();
-            return page.data;
-        }
-        catch (error) {
-            throw new AgentError_1.ExecutionError(`Failed to list llama.cpp models: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-    }
-    getToolDefinitions() {
-        return Array.from(this.tools.values()).map((tool) => {
-            const prompt = tool.getPrompt();
-            return {
-                type: "function",
-                function: {
-                    name: prompt.name,
-                    description: prompt.description,
-                    parameters: prompt.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, "llamacpp", 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 {
-            const response = await this.callLlamaCpp();
-            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
-            return await this.handleResponse(response);
-        }
-        catch (error) {
-            if (error instanceof openai_1.default.APIError) {
-                const apiError = new AgentError_1.ApiError(`llama.cpp API error: ${error.message}`, error.status, error);
-                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
-                if (this.vizEventId) {
-                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, error.status === 429);
-                    this.vizEventId = undefined;
-                }
-                throw apiError;
-            }
-            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(`llama.cpp 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();
-        }
-    }
-    async callLlamaCpp() {
-        const messages = transformers_1.chatCompletionsTransformer.toProvider(this.history.getEntries());
-        const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
-        return this.client.chat.completions.create({
-            model: this.config.model,
-            messages,
-            tools,
-            stream: false,
-            max_tokens: this.config.maxTokens,
-            temperature: this.config.temperature,
-            top_p: this.config.topP,
-            stop: this.config.stopSequences,
-            seed: this.config.seed,
-            presence_penalty: this.config.presencePenalty,
-            frequency_penalty: this.config.frequencyPenalty,
-        });
-    }
-    async handleResponse(response) {
-        const usage = this.parseUsage(response);
-        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 };
-        }
-        const choice = response.choices[0];
-        const message = choice.message;
-        if (choice.finish_reason === "length") {
-            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 1024);
-            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 hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
-        if (!hasToolCalls) {
-            const textContent = message.content || "";
-            const entry = transformers_1.chatCompletionsTransformer.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;
-        const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage(message);
-        this.addToHistory(assistantEntry);
-        const toolResults = await this.handleToolCalls(toolCalls);
-        for (const result of toolResults) {
-            const resultEntry = transformers_1.chatCompletionsTransformer.toolResultEntry(result.toolCallId, result.content);
-            this.addToHistory(resultEntry);
-        }
-        // Continue conversation with tool results
-        try {
-            const newResponse = await this.callLlamaCpp();
-            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
-            return this.handleResponse(newResponse);
-        }
-        catch (error) {
-            const executionError = new AgentError_1.ExecutionError(`llama.cpp error during tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
-            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
-            throw executionError;
-        }
-    }
-    async handleToolCalls(toolCalls) {
-        return Promise.all(toolCalls.map(async (toolCall) => {
-            const toolName = toolCall.type === "function" ? toolCall.function.name : "";
-            const tool = this.tools.get(toolName);
-            const toolCallId = toolCall.id;
-            if (toolCall.type !== "function" || !tool) {
-                const errorMessage = `Tool '${toolName}' not found`;
-                const error = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.type === "function" ? toolCall.function.arguments : undefined);
-                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, error);
-                return { toolCallId, content: errorMessage };
-            }
-            try {
-                const args = JSON.parse(toolCall.function.arguments || "{}");
-                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "llamacpp");
-                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 };
-            }
-        }));
+            model: config.model ?? "default",
+        }, history);
     }
-    parseUsage(response) {
-        const usage = response.usage;
-        return {
-            input_tokens: usage?.prompt_tokens ?? 0,
-            output_tokens: usage?.completion_tokens ?? 0,
-            total_tokens: usage?.total_tokens ?? 0,
-        };
+    getVendorName() {
+        return "llama.cpp";
     }
 }
 exports.LlamaCppAgent = LlamaCppAgent;

package/dist/agents/openai-compatible/OpenAICompatibleAgent.d.ts

@@ -0,0 +1,48 @@
+import OpenAI from "openai";
+import { ChatCompletion, ChatCompletionTool } from "openai/resources/chat/completions";
+import { Model } from "openai/resources/models";
+import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { AgentVendor } from "../AgentConfig";
+import { History, MessageContent } from "../../history/History";
+export type OpenAICompatibleConfig = BaseAgentConfig & {
+    /** Base URL of the OpenAI-compatible `/v1` endpoint (required) */
+    baseURL: string;
+    model?: string;
+    maxTokens?: number;
+};
+/**
+ * Abstract base class for agents that talk to any OpenAI-compatible
+ * `/v1/chat/completions` endpoint (llama.cpp, vLLM, LM Studio, etc.).
+ *
+ * Subclasses must implement:
+ * - `getVendorName()` — human-readable name used in error messages (e.g. `"llama.cpp"`)
+ *
+ * Subclasses may override:
+ * - `buildExtraRequestParams()` — extra fields merged into the completions request
+ */
+export declare abstract class OpenAICompatibleAgent extends BaseAgent {
+    protected client: OpenAI;
+    protected config: Partial<OpenAICompatibleConfig>;
+    lastTokenUsage?: TokenUsage;
+    private vizEventId?;
+    private currentToolCallCount;
+    constructor(config: OpenAICompatibleConfig & {
+        vendor: AgentVendor;
+    }, history?: History);
+    /** Human-readable vendor name used in error messages (e.g. `"llama.cpp"`). */
+    protected abstract getVendorName(): string;
+    /** Extra fields to merge into the chat completions request. Override for vendor-specific params. */
+    protected buildExtraRequestParams(): Record<string, unknown>;
+    /**
+     * List the models available on the server via the `/v1/models` endpoint.
+     */
+    listModels(): Promise<Model[]>;
+    protected getToolDefinitions(): ChatCompletionTool[];
+    protected process(_input: string): Promise<string>;
+    execute(input: string | MessageContent[]): Promise<string>;
+    private callProvider;
+    protected handleResponse(response: ChatCompletion): Promise<string>;
+    private handleToolCalls;
+    protected parseUsage(response: ChatCompletion): TokenUsage;
+}
+//# sourceMappingURL=OpenAICompatibleAgent.d.ts.map

package/dist/agents/openai-compatible/OpenAICompatibleAgent.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleAgent = void 0;
+const openai_1 = __importDefault(require("openai"));
+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");
+/**
+ * Abstract base class for agents that talk to any OpenAI-compatible
+ * `/v1/chat/completions` endpoint (llama.cpp, vLLM, LM Studio, etc.).
+ *
+ * Subclasses must implement:
+ * - `getVendorName()` — human-readable name used in error messages (e.g. `"llama.cpp"`)
+ *
+ * Subclasses may override:
+ * - `buildExtraRequestParams()` — extra fields merged into the completions request
+ */
+class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        super(config, history);
+        this.currentToolCallCount = 0;
+        this.client = new openai_1.default({
+            apiKey: config.apiKey || "not-needed",
+            baseURL: config.baseURL,
+        });
+        this.config = {
+            model: config.model,
+            baseURL: config.baseURL,
+            maxTokens: config.maxTokens,
+            temperature: config.temperature,
+            topP: config.topP,
+            stopSequences: config.stopSequences,
+            seed: config.seed,
+            presencePenalty: config.presencePenalty,
+            frequencyPenalty: config.frequencyPenalty,
+            apiKey: config.apiKey,
+        };
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    /** Extra fields to merge into the chat completions request. Override for vendor-specific params. */
+    buildExtraRequestParams() {
+        return {};
+    }
+    /**
+     * List the models available on the server via the `/v1/models` endpoint.
+     */
+    async listModels() {
+        try {
+            const page = await this.client.models.list();
+            return page.data;
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list ${this.getVendorName()} models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => {
+            const prompt = tool.getPrompt();
+            return {
+                type: "function",
+                function: {
+                    name: prompt.name,
+                    description: prompt.description,
+                    parameters: prompt.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, this.vendor, 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 {
+            const response = await this.callProvider();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
+            return await this.handleResponse(response);
+        }
+        catch (error) {
+            if (error instanceof openai_1.default.APIError) {
+                const apiError = new AgentError_1.ApiError(`${this.getVendorName()} API error: ${error.message}`, error.status, error);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, error.status === 429);
+                    this.vizEventId = undefined;
+                }
+                throw apiError;
+            }
+            if (error instanceof AgentError_1.AgentError) {
+                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(`${this.getVendorName()} 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();
+        }
+    }
+    async callProvider() {
+        const messages = transformers_1.chatCompletionsTransformer.toProvider(this.history.getEntries());
+        const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        return this.client.chat.completions.create({
+            model: this.config.model,
+            messages,
+            tools,
+            stream: false,
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            top_p: this.config.topP,
+            stop: this.config.stopSequences,
+            seed: this.config.seed,
+            presence_penalty: this.config.presencePenalty,
+            frequency_penalty: this.config.frequencyPenalty,
+            ...this.buildExtraRequestParams(),
+        });
+    }
+    async handleResponse(response) {
+        const usage = this.parseUsage(response);
+        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 };
+        }
+        const choice = response.choices[0];
+        const message = choice.message;
+        if (choice.finish_reason === "length") {
+            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 1024);
+            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 hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
+        if (!hasToolCalls) {
+            const textContent = message.content || "";
+            const entry = transformers_1.chatCompletionsTransformer.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;
+        }
+        const toolCalls = message.tool_calls;
+        this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+        this.currentToolCallCount += toolCalls.length;
+        const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage(message);
+        this.addToHistory(assistantEntry);
+        const toolResults = await this.handleToolCalls(toolCalls);
+        for (const result of toolResults) {
+            const resultEntry = transformers_1.chatCompletionsTransformer.toolResultEntry(result.toolCallId, result.content);
+            this.addToHistory(resultEntry);
+        }
+        try {
+            const newResponse = await this.callProvider();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
+            return this.handleResponse(newResponse);
+        }
+        catch (error) {
+            const executionError = new AgentError_1.ExecutionError(`${this.getVendorName()} error during tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            throw executionError;
+        }
+    }
+    async handleToolCalls(toolCalls) {
+        return Promise.all(toolCalls.map(async (toolCall) => {
+            const toolName = toolCall.type === "function" ? toolCall.function.name : "";
+            const tool = this.tools.get(toolName);
+            const toolCallId = toolCall.id;
+            if (toolCall.type !== "function" || !tool) {
+                const errorMessage = `Tool '${toolName}' not found`;
+                const error = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.type === "function"
+                    ? toolCall.function.arguments
+                    : undefined);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, error);
+                return { toolCallId, content: errorMessage };
+            }
+            try {
+                const args = JSON.parse(toolCall.function.arguments || "{}");
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, this.vendor);
+                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(response) {
+        const usage = response.usage;
+        return {
+            input_tokens: usage?.prompt_tokens ?? 0,
+            output_tokens: usage?.completion_tokens ?? 0,
+            total_tokens: usage?.total_tokens ?? 0,
+        };
+    }
+}
+exports.OpenAICompatibleAgent = OpenAICompatibleAgent;
+//# sourceMappingURL=OpenAICompatibleAgent.js.map

package/dist/index.d.ts

@@ -5,6 +5,8 @@ export { MistralAgent } from "./agents/mistral/MistralAgent";
 export { GeminiAgent } from "./agents/google/GeminiAgent";
 export { OllamaAgent } from "./agents/ollama/OllamaAgent";
 export { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";
+export { OpenAICompatibleAgent } from "./agents/openai-compatible/OpenAICompatibleAgent";
+export type { OpenAICompatibleConfig } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export * from "./agents/model-types";
 export * from "./agents/AgentConfig";
 export * from "./agents/AgentEvent";

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.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.LlamaCppAgent = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
+exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
 // Agents
 __exportStar(require("./agents/BaseAgent"), exports);
 __exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
@@ -36,6 +36,8 @@ var OllamaAgent_1 = require("./agents/ollama/OllamaAgent");
 Object.defineProperty(exports, "OllamaAgent", { enumerable: true, get: function () { return OllamaAgent_1.OllamaAgent; } });
 var LlamaCppAgent_1 = require("./agents/llamacpp/LlamaCppAgent");
 Object.defineProperty(exports, "LlamaCppAgent", { enumerable: true, get: function () { return LlamaCppAgent_1.LlamaCppAgent; } });
+var OpenAICompatibleAgent_1 = require("./agents/openai-compatible/OpenAICompatibleAgent");
+Object.defineProperty(exports, "OpenAICompatibleAgent", { enumerable: true, get: function () { return OpenAICompatibleAgent_1.OpenAICompatibleAgent; } });
 __exportStar(require("./agents/model-types"), exports);
 __exportStar(require("./agents/AgentConfig"), exports);
 __exportStar(require("./agents/AgentEvent"), exports);

package/dist/llamacpp.d.ts

@@ -1,4 +1,6 @@
 export * from "./core";
 export { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";
+export { OpenAICompatibleAgent } from "./agents/openai-compatible/OpenAICompatibleAgent";
+export type { OpenAICompatibleConfig } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export { chatCompletionsTransformer } from "./history/transformers";
 //# sourceMappingURL=llamacpp.d.ts.map

package/dist/llamacpp.js

@@ -14,11 +14,13 @@ 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.chatCompletionsTransformer = exports.LlamaCppAgent = void 0;
-// llama.cpp Agent Entry Point
+exports.chatCompletionsTransformer = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = void 0;
+// llama.cpp / OpenAI-compatible Agent Entry Point
 __exportStar(require("./core"), exports);
 var LlamaCppAgent_1 = require("./agents/llamacpp/LlamaCppAgent");
 Object.defineProperty(exports, "LlamaCppAgent", { enumerable: true, get: function () { return LlamaCppAgent_1.LlamaCppAgent; } });
+var OpenAICompatibleAgent_1 = require("./agents/openai-compatible/OpenAICompatibleAgent");
+Object.defineProperty(exports, "OpenAICompatibleAgent", { enumerable: true, get: function () { return OpenAICompatibleAgent_1.OpenAICompatibleAgent; } });
 var transformers_1 = require("./history/transformers");
 Object.defineProperty(exports, "chatCompletionsTransformer", { enumerable: true, get: function () { return transformers_1.chatCompletionsTransformer; } });
 //# sourceMappingURL=llamacpp.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",