@agentionai/agents 0.12.0 → 0.13.0

package/README.md

@@ -27,6 +27,7 @@ Get an API key from your chosen provider:
 - **OpenAI**: [platform.openai.com](https://platform.openai.com/api-keys)
 - **Gemini**: [aistudio.google.com](https://aistudio.google.com/app/apikey)
 - **Mistral**: [console.mistral.ai](https://console.mistral.ai/)
+- **Ollama** / **llama.cpp**: no API key needed — run models locally (see [Agents guide](https://docs.agention.ai/guide/agents))
 
 Set it as an environment variable:
 
@@ -56,10 +57,12 @@ console.log(response);
 Import only the agents you need:
 
 ```typescript
-import { ClaudeAgent } from '@agentionai/agents/claude';    // Requires @anthropic-ai/sdk
-import { OpenAiAgent } from '@agentionai/agents/openai';    // Requires openai
-import { GeminiAgent } from '@agentionai/agents/gemini';    // Requires @google/generative-ai
-import { MistralAgent } from '@agentionai/agents/mistral';  // Requires @mistralai/mistralai
+import { ClaudeAgent } from '@agentionai/agents/claude';     // Requires @anthropic-ai/sdk
+import { OpenAiAgent } from '@agentionai/agents/openai';     // Requires openai
+import { GeminiAgent } from '@agentionai/agents/gemini';     // Requires @google/generative-ai
+import { MistralAgent } from '@agentionai/agents/mistral';   // Requires @mistralai/mistralai
+import { OllamaAgent } from '@agentionai/agents/ollama';     // Requires ollama (local, no API key)
+import { LlamaCppAgent } from '@agentionai/agents/llamacpp'; // Requires openai (local, no API key)
 ```
 
 Or import everything (requires all SDKs):
@@ -71,7 +74,8 @@ import { ClaudeAgent, OpenAiAgent } from '@agentionai/agents';
 
 ## Features
 
-- **Multi-Provider, No Lock-in** - Claude, OpenAI, Gemini, Mistral—same interface. Switch models with one line.
+- **Multi-Provider, No Lock-in** - Claude, OpenAI, Gemini, Mistral, plus local models via Ollama and llama.cpp—same interface. Switch models with one line.
+- **Built-In Tools** - Use provider-defined server-side tools (e.g. Anthropic's web search, bash, text editor) alongside your own.
 - **Composable, Not Magical** - Agents are objects. Pipelines are arrays. No hidden state, no surprises.
 - **Multimodal / Vision** - Send images alongside text with a unified `MessageContent[]` API across all providers.
 - **Full Observability** - Per-call token counts, execution timing, pipeline structure visualization.
@@ -115,6 +119,58 @@ const agent = new GeminiAgent({
 const response = await agent.execute("What's the weather in Paris?");
 ```
 
+### Local Models (Ollama / llama.cpp)
+
+Run models on your own machine — no API key required. Same agent interface as every other provider:
+
+```typescript
+import { OllamaAgent } from '@agentionai/agents/ollama';
+import { LlamaCppAgent } from '@agentionai/agents/llamacpp';
+
+// Ollama (https://ollama.com) — pull a model first: `ollama pull qwen2.5`
+const ollama = new OllamaAgent({
+  id: 'local-ollama',
+  name: 'Local Assistant',
+  description: 'You are a helpful assistant.',
+  model: 'qwen2.5',
+  apiKey: '',
+});
+
+// llama.cpp server (`llama-server -m model.gguf`) — OpenAI-compatible API
+const llamaCpp = new LlamaCppAgent({
+  id: 'local-llamacpp',
+  name: 'Local Assistant',
+  description: 'You are a helpful assistant.',
+  apiKey: '',
+  baseURL: 'http://localhost:8080/v1',
+});
+
+const response = await ollama.execute('What can you run locally?');
+
+// Discover which models are available on the server
+const models = await ollama.listModels();
+```
+
+### Built-In Tools
+
+Use a provider's own server-side tools (executed by the provider, not locally) alongside your custom tools:
+
+```typescript
+import { ClaudeAgent } from '@agentionai/agents/claude';
+import { webSearchTool } from '@agentionai/agents/claude';
+
+const agent = new ClaudeAgent({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  id: 'researcher',
+  name: 'Researcher',
+  description: 'You are a helpful research assistant with web access.',
+  model: 'claude-sonnet-4-6',
+  builtInTools: [webSearchTool({ maxUses: 5 })],
+});
+
+const response = await agent.execute('What happened in the news today?');
+```
+
 ### Multi-Agent Pipeline
 
 Chain agents together with different providers and models:
@@ -216,12 +272,12 @@ const response2 = await agent.execute([
 ## Core Concepts
 
 ### Agents
-Unified interface across Claude, OpenAI, Gemini, and Mistral. Tools, history, and token tracking built-in.
+Unified interface across Claude, OpenAI, Gemini, Mistral, and local models via Ollama and llama.cpp. Tools, history, and token tracking built-in.
 
 [Learn more →](https://docs.agention.ai/guide/agents)
 
 ### Tools
-JSON Schema + handler pattern. Unique capability: wrap any agent as a tool for delegation hierarchies.
+JSON Schema + handler pattern. Unique capability: wrap any agent as a tool for delegation hierarchies. Also supports provider-defined built-in tools (e.g. Anthropic's web search, bash, text editor) that run server-side.
 
 [Learn more →](https://docs.agention.ai/guide/tools)
 

package/dist/agents/Agent.d.ts

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

package/dist/agents/Agent.js

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

package/dist/agents/AgentConfig.d.ts

@@ -1,7 +1,8 @@
 import { Tool } from "../tools/Tool";
+import { BuiltInTool } from "../tools/BuiltInTool";
 import { BaseAgent } from "./BaseAgent";
 /** Supported LLM vendors */
-export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini" | "ollama";
+export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini" | "ollama" | "llamacpp";
 /**
  * Common configuration shared by all agents
  */
@@ -57,6 +58,21 @@ export interface CommonAgentConfig {
 export interface ClaudeSpecificConfig {
     disableParallelToolUse?: boolean;
     metadata?: Record<string, string>;
+    /**
+     * Provider-defined / server-side tools (e.g. web search, bash, text editor).
+     * These are executed by Anthropic rather than locally — see `lib/tools/BuiltInTool.ts`.
+     */
+    builtInTools?: BuiltInTool[];
+    /**
+     * How `apiKey` should be presented to the Anthropic SDK.
+     * - `"apiKey"` (default): sent as the `x-api-key` header — for standard Anthropic API keys.
+     * - `"oauth"`: sent as a bearer `authToken` — for OAuth access tokens (e.g. Claude Code /
+     *   Claude.ai tokens, which look like `sk-ant-oat...`).
+     *
+     * Set this explicitly rather than relying on the token's prefix, since prefixes are an
+     * implementation detail that can change.
+     */
+    authType?: "apiKey" | "oauth";
 }
 /**
  * Vendor-specific configuration for OpenAI
@@ -90,9 +106,16 @@ export interface GeminiSpecificConfig {
  * Vendor-specific configuration for Ollama (local)
  */
 export interface OllamaSpecificConfig {
-    /** Ollama server URL (default: http://localhost:11434) */
+    /** Ollama server URL (default: `http://localhost:11434`) */
     host?: string;
 }
+/**
+ * Vendor-specific configuration for llama.cpp server (local)
+ */
+export interface LlamaCppSpecificConfig {
+    /** Base URL of the llama.cpp server's OpenAI-compatible API (default: `http://localhost:8080/v1`) */
+    baseURL?: string;
+}
 /**
  * Generic vendor-specific configuration container
  * This allows any vendor to add custom config without modifying base types
@@ -103,6 +126,7 @@ export interface VendorSpecificConfig {
     mistral?: MistralSpecificConfig;
     gemini?: GeminiSpecificConfig;
     ollama?: OllamaSpecificConfig;
+    llamacpp?: LlamaCppSpecificConfig;
 }
 /**
  * Complete agent configuration with vendor-specific extensions
@@ -144,10 +168,12 @@ export type TypedAgentConfig<V extends AgentVendor> = CommonAgentConfig & {
         gemini?: GeminiSpecificConfig;
     } : V extends "ollama" ? {
         ollama?: OllamaSpecificConfig;
+    } : V extends "llamacpp" ? {
+        llamacpp?: LlamaCppSpecificConfig;
     } : 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 : V extends "ollama" ? OllamaSpecificConfig : 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 : V extends "llamacpp" ? LlamaCppSpecificConfig : never;
 //# sourceMappingURL=AgentConfig.d.ts.map

package/dist/agents/anthropic/ClaudeAgent.d.ts

@@ -1,5 +1,6 @@
-import { Message, Usage } from "@anthropic-ai/sdk/resources";
+import { Message, ToolUnion, Usage } from "@anthropic-ai/sdk/resources";
 import { type ToolDefinition } from "../../tools/Tool";
+import { type BuiltInTool } from "../../tools/BuiltInTool";
 import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
 import { ClaudeModel } from "../model-types";
@@ -9,6 +10,18 @@ type AgentConfig = BaseAgentConfig & {
     maxTokens?: number;
     disableParallelToolUse?: boolean;
     metadata?: Record<string, string>;
+    /**
+     * How `apiKey` should be presented to the Anthropic SDK — `"apiKey"` (default, `x-api-key`
+     * header) or `"oauth"` (bearer `authToken`, for OAuth access tokens like Claude Code's
+     * `sk-ant-oat...` tokens). Set explicitly; do not infer it from the token's prefix.
+     */
+    authType?: "apiKey" | "oauth";
+    /**
+     * Provider-defined / server-side tools (e.g. web search, bash, text editor).
+     * These run on Anthropic's infrastructure rather than locally.
+     * @see lib/tools/BuiltInTool.ts
+     */
+    builtInTools?: BuiltInTool[];
 };
 /**
  * Agent for Anthropic models.
@@ -36,6 +49,11 @@ export declare class ClaudeAgent extends BaseAgent {
     private currentToolCallCount;
     constructor(config: Omit<AgentConfig, "vendor">, history?: History);
     protected getToolDefinitions(): ToolDefinition[];
+    /**
+     * Combine locally-executed tool definitions with provider-defined
+     * (server-side) built-in tools, in the shape Anthropic's API expects.
+     */
+    protected getAllToolDefinitions(): ToolUnion[];
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[]): Promise<string>;
     protected handleResponse(response: Message): Promise<string>;

package/dist/agents/anthropic/ClaudeAgent.js

@@ -29,9 +29,6 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         super({ ...config, vendor: "anthropic" }, history);
         /** Count of tool calls in current execution */
         this.currentToolCallCount = 0;
-        this.client = new sdk_1.Anthropic({
-            apiKey: config.apiKey,
-        });
         // Merge flat config (deprecated) with nested vendorConfig
         // Flat config takes precedence for backward compatibility
         const vendorConfig = config.vendorConfig?.anthropic || {};
@@ -39,11 +36,18 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
             vendorConfig.disableParallelToolUse ??
             false;
         const metadata = config.metadata ?? vendorConfig.metadata;
+        const builtInTools = config.builtInTools ?? vendorConfig.builtInTools;
+        const authType = config.authType ?? vendorConfig.authType ?? "apiKey";
+        this.client = new sdk_1.Anthropic(authType === "oauth"
+            ? { authToken: config.apiKey }
+            : { apiKey: config.apiKey });
         this.config = {
             model: config.model || "claude-3-5-haiku-latest",
             maxTokens: config.maxTokens || 1024,
             disableParallelToolUse,
             metadata,
+            builtInTools,
+            authType,
             apiKey: config.apiKey,
             temperature: config.temperature,
             topP: config.topP,
@@ -56,6 +60,16 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => tool.getPrompt());
     }
+    /**
+     * Combine locally-executed tool definitions with provider-defined
+     * (server-side) built-in tools, in the shape Anthropic's API expects.
+     */
+    getAllToolDefinitions() {
+        return [
+            ...this.getToolDefinitions(),
+            ...(this.config.builtInTools ?? []),
+        ];
+    }
     async process(_input) {
         return "";
     }
@@ -95,7 +109,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 system: systemMessage,
                 max_tokens: this.config.maxTokens,
                 messages,
-                tools: this.getToolDefinitions(),
+                tools: this.getAllToolDefinitions(),
                 temperature: this.config.temperature,
                 top_p: this.config.topP,
                 top_k: this.config.topK,
@@ -155,7 +169,12 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
             throw error;
         }
         if (response.stop_reason !== "tool_use") {
-            if (response.content && response.content[0]?.type === "text") {
+            // Server-side tools (web search, bash, etc.) add their own content blocks
+            // (server_tool_use / web_search_tool_result / ...) ahead of the final
+            // text — collect every text block rather than assuming content[0] is text.
+            const textBlocks = response.content?.filter((block) => block.type === "text");
+            if (response.content && textBlocks && textBlocks.length > 0) {
+                const textContent = textBlocks.map((block) => block.text).join("\n");
                 this.emit(AgentEvent_1.AgentEvent.DONE, response, usage);
                 // Convert response to normalized format and add to history
                 const entry = transformers_1.anthropicTransformer.fromProviderContent("assistant", response.content);
@@ -166,10 +185,10 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                         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, response.content[0].text);
+                    }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
                     this.vizEventId = undefined;
                 }
-                return response.content[0].text;
+                return textContent;
             }
             else {
                 const error = new AgentError_1.ExecutionError(`Unexpected response format: ${JSON.stringify(response.content)}`);
@@ -199,7 +218,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                         system: this.history.getSystemMessage(),
                         max_tokens: this.config.maxTokens,
                         messages,
-                        tools: this.getToolDefinitions(),
+                        tools: this.getAllToolDefinitions(),
                         temperature: this.config.temperature,
                         top_p: this.config.topP,
                         top_k: this.config.topK,

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

@@ -0,0 +1,60 @@
+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 { LlamaCppModel } from "../model-types";
+type AgentConfig = BaseAgentConfig & {
+    /** 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`),
+ * which exposes an OpenAI-compatible `/v1/chat/completions` API.
+ *
+ * Requires the `openai` package as a peer dependency and a running llama.cpp server.
+ *
+ * @example
+ * ```typescript
+ * const agent = new LlamaCppAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: "",
+ *   baseURL: "http://localhost:8080/v1",
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ *
+ * @example List available models
+ * ```typescript
+ * 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 {};
+//# sourceMappingURL=LlamaCppAgent.d.ts.map

package/dist/agents/llamacpp/LlamaCppAgent.js

@@ -0,0 +1,262 @@
+"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");
+/**
+ * Agent for locally-hosted models served by a llama.cpp server (`llama-server`),
+ * which exposes an OpenAI-compatible `/v1/chat/completions` API.
+ *
+ * Requires the `openai` package as a peer dependency and a running llama.cpp server.
+ *
+ * @example
+ * ```typescript
+ * const agent = new LlamaCppAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: "",
+ *   baseURL: "http://localhost:8080/v1",
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ *
+ * @example List available models
+ * ```typescript
+ * const models = await agent.listModels();
+ * ```
+ */
+class LlamaCppAgent extends BaseAgent_1.BaseAgent {
+    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",
+            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 };
+            }
+        }));
+    }
+    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.LlamaCppAgent = LlamaCppAgent;
+//# sourceMappingURL=LlamaCppAgent.js.map

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

@@ -27,6 +27,13 @@ export type MistralModel = "mistral-large-latest" | "mistral-small-latest" | "mi
  * @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 & {});
+/**
+ * Models served by a local llama.cpp server (`llama-server`).
+ * The model is identified by the GGUF file/alias loaded by the server, so any
+ * string is accepted — the values below are common conventions.
+ * @see https://github.com/ggml-org/llama.cpp/tree/master/tools/server
+ */
+export type LlamaCppModel = "default" | "gpt-oss-20b" | "gpt-oss-120b" | "llama-3.1-8b-instruct" | "llama-3.2-3b-instruct" | "qwen2.5-7b-instruct" | "qwen2.5-coder-7b-instruct" | "mistral-7b-instruct" | "phi-4" | "deepseek-r1-distill-qwen-7b" | (string & {});
 /**
  * Supported OpenAI models.
  * You can also provide any custom string for newer models not yet listed.

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

@@ -2,7 +2,7 @@ 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) */
+    /** Ollama server URL (default: `http://localhost:11434`) */
     host?: string;
     model?: OllamaModel;
     maxTokens?: number;
@@ -56,6 +56,10 @@ export declare class OllamaAgent extends BaseAgent {
     private _client;
     constructor(config: Omit<AgentConfig, "vendor">, history?: History);
     private getClient;
+    /**
+     * List the models currently available on the Ollama server.
+     */
+    listModels(): Promise<OllamaModelInfo[]>;
     protected getToolDefinitions(): OllamaToolDefinition[];
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[]): Promise<string>;
@@ -65,5 +69,23 @@ export declare class OllamaAgent extends BaseAgent {
     private handleToolCalls;
     protected parseUsage(input: unknown): TokenUsage;
 }
+/**
+ * A model available on the Ollama server, as returned by `client.list()`.
+ */
+export type OllamaModelInfo = {
+    name: string;
+    model: string;
+    modified_at: Date;
+    size: number;
+    digest: string;
+    details: {
+        parent_model: string;
+        format: string;
+        family: string;
+        families: string[];
+        parameter_size: string;
+        quantization_level: string;
+    };
+};
 export {};
 //# sourceMappingURL=OllamaAgent.d.ts.map

package/dist/agents/ollama/OllamaAgent.js

@@ -107,6 +107,19 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
         }
         return this._client;
     }
+    /**
+     * List the models currently available on the Ollama server.
+     */
+    async listModels() {
+        try {
+            const client = await this.getClient();
+            const response = await client.list();
+            return response.models;
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list Ollama models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => ({
             type: "function",

package/dist/core.d.ts

@@ -7,6 +7,7 @@ export * from "./history/History";
 export * from "./history/types";
 export * from "./graph/AgentGraph";
 export * from "./tools/Tool";
+export * from "./tools/BuiltInTool";
 export * from "./mcp";
 export * from "./viz";
 export * from "./embeddings";

package/dist/core.js

@@ -29,6 +29,7 @@ __exportStar(require("./history/types"), exports);
 __exportStar(require("./graph/AgentGraph"), exports);
 // Tools
 __exportStar(require("./tools/Tool"), exports);
+__exportStar(require("./tools/BuiltInTool"), exports);
 // MCP (Model Context Protocol)
 __exportStar(require("./mcp"), exports);
 // Visualization

package/dist/history/transformers.d.ts

@@ -134,5 +134,69 @@ export declare const ollamaTransformer: {
      */
     toolResultEntry(tool_call_id: string, output: string): HistoryEntry;
 };
+/**
+ * Convert normalized entries to/from the OpenAI Chat Completions message format
+ * (`/v1/chat/completions`). Used by `LlamaCppAgent` and any other agent that
+ * targets an OpenAI-compatible chat-completions endpoint.
+ */
+export declare const chatCompletionsTransformer: {
+    /**
+     * Convert normalized entries to Chat Completions message format.
+     * Tool results become role:"tool" messages; tool calls are embedded in assistant messages.
+     */
+    toProvider(entries: HistoryEntry[]): ChatCompletionMessage[];
+    /**
+     * Convert a Chat Completions response message to a normalized HistoryEntry.
+     */
+    fromProviderMessage(message: ChatCompletionResponseMessage): HistoryEntry;
+    /**
+     * Create a normalized tool result entry for a Chat Completions tool call
+     */
+    toolResultEntry(tool_call_id: string, output: string): HistoryEntry;
+};
+type ChatCompletionToolCallParam = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+type ChatCompletionContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+};
+type ChatCompletionMessage = {
+    role: "system";
+    content: string;
+} | {
+    role: "user";
+    content: string | ChatCompletionContentPart[];
+} | {
+    role: "assistant";
+    content: string | null;
+    tool_calls?: ChatCompletionToolCallParam[];
+} | {
+    role: "tool";
+    tool_call_id: string;
+    content: string;
+};
+type ChatCompletionResponseMessage = {
+    role: string;
+    content: string | null;
+    tool_calls?: Array<{
+        id: string;
+        function?: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+};
 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.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = void 0;
+exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = void 0;
 const types_1 = require("./types");
 // =============================================================================
 // Anthropic Transformer
@@ -576,4 +576,121 @@ exports.ollamaTransformer = {
         };
     },
 };
+// =============================================================================
+// Chat Completions Transformer (OpenAI-compatible servers, e.g. llama.cpp)
+// =============================================================================
+/**
+ * Convert normalized entries to/from the OpenAI Chat Completions message format
+ * (`/v1/chat/completions`). Used by `LlamaCppAgent` and any other agent that
+ * targets an OpenAI-compatible chat-completions endpoint.
+ */
+exports.chatCompletionsTransformer = {
+    /**
+     * Convert normalized entries to Chat Completions 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);
+            const imageUrlBlocks = entry.content.filter(types_1.isImageUrlContent);
+            const imageBase64Blocks = entry.content.filter(types_1.isImageBase64Content);
+            const hasImages = imageUrlBlocks.length > 0 || imageBase64Blocks.length > 0;
+            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") || null,
+                };
+                if (toolUseBlocks.length > 0) {
+                    msg.tool_calls = toolUseBlocks.map((block) => ({
+                        id: block.id,
+                        type: "function",
+                        function: {
+                            name: block.name,
+                            arguments: JSON.stringify(block.input),
+                        },
+                    }));
+                }
+                messages.push(msg);
+                continue;
+            }
+            // User role — could be text, images, or tool results
+            if (toolResultBlocks.length > 0) {
+                for (const result of toolResultBlocks) {
+                    messages.push({
+                        role: "tool",
+                        tool_call_id: result.tool_use_id,
+                        content: result.content,
+                    });
+                }
+            }
+            else if (hasImages) {
+                const parts = [];
+                for (const block of entry.content) {
+                    if ((0, types_1.isTextContent)(block)) {
+                        parts.push({ type: "text", text: block.text });
+                    }
+                    else if ((0, types_1.isImageUrlContent)(block)) {
+                        parts.push({
+                            type: "image_url",
+                            image_url: {
+                                url: block.url,
+                                ...(block.detail ? { detail: block.detail } : {}),
+                            },
+                        });
+                    }
+                    else if ((0, types_1.isImageBase64Content)(block)) {
+                        parts.push({
+                            type: "image_url",
+                            image_url: { url: `data:${block.mimeType};base64,${block.data}` },
+                        });
+                    }
+                }
+                messages.push({ role: "user", content: parts });
+            }
+            else if (textBlocks.length > 0) {
+                messages.push({ role: "user", content: textBlocks.map((c) => c.text).join("\n") });
+            }
+        }
+        return messages;
+    },
+    /**
+     * Convert a Chat Completions response message to a normalized HistoryEntry.
+     */
+    fromProviderMessage(message) {
+        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) => {
+                if (!call.function)
+                    return;
+                const args = JSON.parse(call.function.arguments || "{}");
+                content.push((0, types_1.toolUse)(call.id, call.function.name, args));
+            });
+        }
+        return {
+            role: "assistant",
+            content,
+            meta: { provider: "llamacpp" },
+        };
+    },
+    /**
+     * Create a normalized tool result entry for a Chat Completions tool call
+     */
+    toolResultEntry(tool_call_id, output) {
+        return {
+            role: "user",
+            content: [(0, types_1.toolResult)(tool_call_id, output)],
+            meta: { provider: "llamacpp", tool_call_id },
+        };
+    },
+};
 //# sourceMappingURL=transformers.js.map

package/dist/history/types.d.ts

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

package/dist/index.d.ts

@@ -4,15 +4,17 @@ 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 { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";
 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, ollamaTransformer, } from "./history/transformers";
+export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, ollamaTransformer, chatCompletionsTransformer, } from "./history/transformers";
 export * from "./graph/AgentGraph";
 export * from "./tools/Tool";
+export * from "./tools/BuiltInTool";
 export * from "./mcp";
 export * from "./viz";
 export * from "./vectorstore";

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.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
+exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.LlamaCppAgent = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
 // Agents
 __exportStar(require("./agents/BaseAgent"), exports);
 __exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
@@ -34,6 +34,8 @@ 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; } });
+var LlamaCppAgent_1 = require("./agents/llamacpp/LlamaCppAgent");
+Object.defineProperty(exports, "LlamaCppAgent", { enumerable: true, get: function () { return LlamaCppAgent_1.LlamaCppAgent; } });
 __exportStar(require("./agents/model-types"), exports);
 __exportStar(require("./agents/AgentConfig"), exports);
 __exportStar(require("./agents/AgentEvent"), exports);
@@ -47,10 +49,12 @@ Object.defineProperty(exports, "openAiTransformer", { enumerable: true, get: fun
 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; } });
+Object.defineProperty(exports, "chatCompletionsTransformer", { enumerable: true, get: function () { return transformers_1.chatCompletionsTransformer; } });
 // Graph
 __exportStar(require("./graph/AgentGraph"), exports);
 // Tools
 __exportStar(require("./tools/Tool"), exports);
+__exportStar(require("./tools/BuiltInTool"), exports);
 // MCP (Model Context Protocol)
 __exportStar(require("./mcp"), exports);
 // Visualization

package/dist/llamacpp.d.ts

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

package/dist/llamacpp.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.chatCompletionsTransformer = exports.LlamaCppAgent = void 0;
+// llama.cpp 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 transformers_1 = require("./history/transformers");
+Object.defineProperty(exports, "chatCompletionsTransformer", { enumerable: true, get: function () { return transformers_1.chatCompletionsTransformer; } });
+//# sourceMappingURL=llamacpp.js.map

package/dist/tools/BuiltInTool.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Provider-defined ("built-in" / server-side) tools.
+ *
+ * Unlike `Tool`, these are not executed locally — the provider runs them as
+ * part of generating its response (e.g. Anthropic's web search, bash, and
+ * text editor tools). They carry no `execute` function or input schema; the
+ * agent simply forwards their definition to the provider's API.
+ *
+ * Pass arbitrary built-in tool definitions straight through — only `type`
+ * and `name` are required, any other provider-specific fields are allowed:
+ *
+ * @example
+ * ```typescript
+ * const agent = new ClaudeAgent({
+ *   ...,
+ *   builtInTools: [
+ *     { type: "web_search_20250305", name: "web_search", max_uses: 5 },
+ *   ],
+ * });
+ * ```
+ *
+ * Or use one of the helpers below for the well-known Anthropic tools.
+ */
+export interface BuiltInTool {
+    /** Provider-specific tool type identifier, e.g. `"web_search_20250305"` */
+    type: string;
+    /** Name the model will use to refer to the tool, e.g. `"web_search"` */
+    name: string;
+    /** Any additional provider-specific configuration for this tool */
+    [key: string]: unknown;
+}
+/**
+ * Options for Anthropic's web search tool (`web_search_20250305`).
+ * @see https://docs.anthropic.com/en/docs/build-with-claude/tool-use/web-search-tool
+ */
+export interface WebSearchToolOptions {
+    /** Maximum number of searches Claude can perform during the request */
+    maxUses?: number;
+    /** Only include results from these domains (mutually exclusive with `blockedDomains`) */
+    allowedDomains?: string[];
+    /** Never include results from these domains (mutually exclusive with `allowedDomains`) */
+    blockedDomains?: string[];
+    /** Approximate user location, used to localize search results */
+    userLocation?: {
+        type?: "approximate";
+        city?: string;
+        region?: string;
+        country?: string;
+        timezone?: string;
+    };
+}
+/**
+ * Anthropic's server-side web search tool.
+ * Claude decides when to search and the results are fetched and processed by Anthropic.
+ */
+export declare function webSearchTool(options?: WebSearchToolOptions): BuiltInTool;
+/**
+ * Anthropic's server-side bash tool — gives Claude a persistent shell session.
+ * Requires a compatible model (e.g. Claude 4 / 3.7 Sonnet) and beta header support.
+ */
+export declare function bashTool(): BuiltInTool;
+/**
+ * Anthropic's server-side text editor tool — lets Claude view and edit text files.
+ */
+export declare function textEditorTool(version?: "20250124" | "20250429" | "20250728"): BuiltInTool;
+/**
+ * Define an arbitrary provider-defined / built-in tool by its raw definition.
+ * Use this to pass through tools not covered by the helpers above (or for
+ * other providers that support server-side tools).
+ */
+export declare function builtInTool(definition: BuiltInTool): BuiltInTool;
+//# sourceMappingURL=BuiltInTool.d.ts.map

package/dist/tools/BuiltInTool.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSearchTool = webSearchTool;
+exports.bashTool = bashTool;
+exports.textEditorTool = textEditorTool;
+exports.builtInTool = builtInTool;
+/**
+ * Anthropic's server-side web search tool.
+ * Claude decides when to search and the results are fetched and processed by Anthropic.
+ */
+function webSearchTool(options = {}) {
+    const tool = {
+        type: "web_search_20250305",
+        name: "web_search",
+    };
+    if (options.maxUses !== undefined)
+        tool.max_uses = options.maxUses;
+    if (options.allowedDomains)
+        tool.allowed_domains = options.allowedDomains;
+    if (options.blockedDomains)
+        tool.blocked_domains = options.blockedDomains;
+    if (options.userLocation) {
+        tool.user_location = { type: "approximate", ...options.userLocation };
+    }
+    return tool;
+}
+/**
+ * Anthropic's server-side bash tool — gives Claude a persistent shell session.
+ * Requires a compatible model (e.g. Claude 4 / 3.7 Sonnet) and beta header support.
+ */
+function bashTool() {
+    return { type: "bash_20250124", name: "bash" };
+}
+/**
+ * Anthropic's server-side text editor tool — lets Claude view and edit text files.
+ */
+function textEditorTool(version = "20250728") {
+    const names = {
+        "20250124": "str_replace_editor",
+        "20250429": "str_replace_based_edit_tool",
+        "20250728": "str_replace_based_edit_tool",
+    };
+    return { type: `text_editor_${version}`, name: names[version] };
+}
+/**
+ * Define an arbitrary provider-defined / built-in tool by its raw definition.
+ * Use this to pass through tools not covered by the helpers above (or for
+ * other providers that support server-side tools).
+ */
+function builtInTool(definition) {
+    return definition;
+}
+//# sourceMappingURL=BuiltInTool.js.map

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" | "ollama";
+export type VizVendor = "anthropic" | "openai" | "mistral" | "gemini" | "ollama" | "llamacpp";
 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.12.0",
+  "version": "0.13.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,6 +34,10 @@
       "types": "./dist/ollama.d.ts",
       "default": "./dist/ollama.js"
     },
+    "./llamacpp": {
+      "types": "./dist/llamacpp.d.ts",
+      "default": "./dist/llamacpp.js"
+    },
     "./embeddings": {
       "types": "./dist/embeddings/index.d.ts",
       "default": "./dist/embeddings/index.js"