@agentionai/agents 0.3.0-beta

package/dist/agents/AgentEvent.d.ts

@@ -0,0 +1,18 @@
+import { BaseAgent } from "./BaseAgent";
+export declare class AgentEvent {
+    target: BaseAgent<any>;
+    static BEFORE_EXECUTE: string;
+    static AFTER_EXECUTE: string;
+    static DONE: string;
+    static TOOL_USE: string;
+    static ERROR: string;
+    static RETRY: string;
+    static MAX_RETRIES_EXCEEDED: string;
+    static MAX_TOKENS_EXCEEDED: string;
+    static TOOL_ERROR: string;
+    private defaultPrevented;
+    constructor(target: BaseAgent<any>);
+    preventDefault(): void;
+    get isDefaultPrevented(): boolean;
+}
+//# sourceMappingURL=AgentEvent.d.ts.map

package/dist/agents/AgentEvent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentEvent = void 0;
+class AgentEvent {
+    constructor(target) {
+        this.target = target;
+        this.defaultPrevented = false;
+    }
+    preventDefault() {
+        this.defaultPrevented = true;
+    }
+    get isDefaultPrevented() {
+        return this.defaultPrevented;
+    }
+}
+exports.AgentEvent = AgentEvent;
+AgentEvent.BEFORE_EXECUTE = "before_execute";
+AgentEvent.AFTER_EXECUTE = "after_execute";
+AgentEvent.DONE = "done";
+AgentEvent.TOOL_USE = "toolUse";
+AgentEvent.ERROR = "error";
+AgentEvent.RETRY = "retry";
+AgentEvent.MAX_RETRIES_EXCEEDED = "max_retries_exceeded";
+AgentEvent.MAX_TOKENS_EXCEEDED = "max_tokens_exceeded";
+AgentEvent.TOOL_ERROR = "tool_error";
+//# sourceMappingURL=AgentEvent.js.map

package/dist/agents/BaseAgent.d.ts

@@ -0,0 +1,82 @@
+import EventEmitter from "events";
+import { Tool } from "../tools/Tool";
+import { History, HistoryEntry, MessageRole, MessageContent } from "../history/History";
+import { AgentVendor, CommonAgentConfig, VendorSpecificConfig } from "./AgentConfig";
+export type { HistoryEntry, MessageRole, MessageContent };
+export type { AgentVendor };
+/**
+ * Agent config as used across all agents
+ * @deprecated Use CommonAgentConfig with vendorConfig instead
+ */
+export interface BaseAgentConfig extends CommonAgentConfig {
+    vendor: AgentVendor;
+    vendorConfig?: VendorSpecificConfig;
+}
+export type TokenUsage = {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+};
+/**
+ * The base agent is what the other agents are inheriting from
+ * Handles the BaseConfig
+ */
+export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> extends EventEmitter {
+    protected history: History;
+    protected id: string;
+    protected debug: boolean;
+    protected name: string;
+    protected description: string;
+    protected tools: Map<string, Tool<unknown>>;
+    protected maxHistoryLength: number;
+    /** The vendor/provider for this agent (anthropic, openai, mistral, gemini) */
+    protected vendor: AgentVendor;
+    /** The model identifier for this agent */
+    protected model: string;
+    /**
+     * An Agent is the primary LLM entity.
+     *
+     * @param config
+     * @param history History is transient by default, meaning it will be cleared for every question.
+     *                 this makes hostory easier to manage and saves cost. If history should be kept in between
+     *                 prompts, then supply a History object.
+     *
+     */
+    constructor(config: BaseAgentConfig, history?: History);
+    abstract execute(input: TInput): Promise<TOutput>;
+    protected abstract process(input: TInput): Promise<TOutput>;
+    protected abstract handleResponse(response: unknown): Promise<unknown>;
+    protected getToolDefinitions(): unknown[];
+    /**
+     * Add an entry to history
+     */
+    protected addToHistory(entry: HistoryEntry): void;
+    /**
+     * Add a text message to history
+     */
+    protected addTextToHistory(role: MessageRole, content: string): void;
+    /**
+     * Add system message to history if it doesn't already exist.
+     * Checks if the first system message matches the provided content.
+     */
+    protected addSystemMessage(content: string): void;
+    /**
+     * Get the standard system message for this agent
+     */
+    protected getSystemMessage(): string;
+    /**
+     * Add a message with content blocks to history
+     */
+    protected addMessageToHistory(role: MessageRole, content: MessageContent[]): void;
+    addTools(tools: Tool<unknown>[]): void;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getVendor(): AgentVendor;
+    getModel(): string;
+    getHistoryEntries(): HistoryEntry[];
+    getTools(): Tool<unknown>[];
+    clearHistory(): void;
+    protected abstract parseUsage(input: unknown): TokenUsage;
+}
+//# sourceMappingURL=BaseAgent.d.ts.map

package/dist/agents/BaseAgent.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAgent = void 0;
+const events_1 = __importDefault(require("events"));
+const Tool_1 = require("../tools/Tool");
+const History_1 = require("../history/History");
+/**
+ * The base agent is what the other agents are inheriting from
+ * Handles the BaseConfig
+ */
+class BaseAgent extends events_1.default {
+    /**
+     * An Agent is the primary LLM entity.
+     *
+     * @param config
+     * @param history History is transient by default, meaning it will be cleared for every question.
+     *                 this makes hostory easier to manage and saves cost. If history should be kept in between
+     *                 prompts, then supply a History object.
+     *
+     */
+    constructor(config, history = new History_1.History([], { transient: true })) {
+        super();
+        this.history = history;
+        this.debug = true;
+        this.id = config.id;
+        this.debug = config.debug || false;
+        this.name = config.name;
+        this.description = config.description;
+        this.vendor = config.vendor;
+        this.model = config.model || "unknown";
+        if (config.agents) {
+            const agentTools = config.agents.map((agent) => {
+                return Tool_1.Tool.fromAgent(agent, `You can use this agent ${agent.getName()} to execute tasks`);
+            });
+            config.tools = config.tools
+                ? [...config.tools, ...agentTools]
+                : agentTools;
+        }
+        this.tools = new Map((config.tools || []).map((tool) => [tool.name, tool]));
+        this.maxHistoryLength = config.maxHistoryLength || 100;
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => tool.getPrompt());
+    }
+    /**
+     * Add an entry to history
+     */
+    addToHistory(entry) {
+        this.history.addEntry(entry);
+    }
+    /**
+     * Add a text message to history
+     */
+    addTextToHistory(role, content) {
+        this.history.addText(role, content);
+    }
+    /**
+     * Add system message to history if it doesn't already exist.
+     * Checks if the first system message matches the provided content.
+     */
+    addSystemMessage(content) {
+        const existingSystem = this.history.getSystemMessage();
+        if (existingSystem === content) {
+            // System message already exists with same content, skip
+            return;
+        }
+        this.history.addSystem(content);
+    }
+    /**
+     * Get the standard system message for this agent
+     */
+    getSystemMessage() {
+        return `You are an agent called ${this.getName()} and should follow these instructions: ${this.getDescription()}`;
+    }
+    /**
+     * Add a message with content blocks to history
+     */
+    addMessageToHistory(role, content) {
+        this.history.addMessage(role, content);
+    }
+    addTools(tools) {
+        tools.forEach((tool) => {
+            if (!this.tools.has(tool.name)) {
+                this.tools.set(tool.name, tool);
+            }
+            else {
+                throw new Error(`AddTool: Tool ${tool.name} already exists for ${this.getName()}`);
+            }
+        });
+    }
+    // Getters
+    getId() {
+        return this.id;
+    }
+    getName() {
+        return this.name;
+    }
+    getDescription() {
+        return this.description;
+    }
+    getVendor() {
+        return this.vendor;
+    }
+    getModel() {
+        return this.model;
+    }
+    getHistoryEntries() {
+        return this.history.entries;
+    }
+    getTools() {
+        return [...this.tools.values()];
+    }
+    clearHistory() {
+        this.history.clear();
+    }
+}
+exports.BaseAgent = BaseAgent;
+//# sourceMappingURL=BaseAgent.js.map

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

@@ -0,0 +1,46 @@
+import { Message, Usage } from "@anthropic-ai/sdk/resources";
+import { type ToolDefinition } from "../../tools/Tool";
+import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { History } from "../../history/History";
+import { ClaudeModel } from "../model-types";
+type AgentConfig = BaseAgentConfig & {
+    apiKey: string;
+    model?: ClaudeModel;
+    maxTokens?: number;
+    disableParallelToolUse?: boolean;
+    metadata?: Record<string, string>;
+};
+/**
+ * Agent for Anthropic models.
+ *
+ * @example
+ * ```typescript
+ * const agent = new ClaudeAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: process.env.ANTHROPIC_API_KEY,
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ */
+export declare class ClaudeAgent extends BaseAgent {
+    private client;
+    protected config: Partial<AgentConfig>;
+    /** Token usage from the last execution (for metrics tracking) */
+    lastTokenUsage?: TokenUsage;
+    /** Current visualization event ID for tracking */
+    private vizEventId?;
+    /** Count of tool calls in current execution */
+    private currentToolCallCount;
+    constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    protected getToolDefinitions(): ToolDefinition[];
+    protected process(_input: string): Promise<string>;
+    execute(input: string): Promise<string>;
+    protected handleResponse(response: Message): Promise<string>;
+    private handleToolUse;
+    protected parseUsage(input: Usage): TokenUsage;
+}
+export {};
+//# sourceMappingURL=ClaudeAgent.d.ts.map

package/dist/agents/anthropic/ClaudeAgent.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAgent = void 0;
+const sdk_1 = require("@anthropic-ai/sdk");
+const BaseAgent_1 = require("../BaseAgent");
+const AgentEvent_1 = require("../AgentEvent");
+const AgentError_1 = require("../errors/AgentError");
+const History_1 = require("../../history/History");
+const transformers_1 = require("../../history/transformers");
+const VizReporter_1 = require("../../viz/VizReporter");
+const VizConfig_1 = require("../../viz/VizConfig");
+/**
+ * Agent for Anthropic models.
+ *
+ * @example
+ * ```typescript
+ * const agent = new ClaudeAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: process.env.ANTHROPIC_API_KEY,
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ */
+class ClaudeAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        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 || {};
+        const disableParallelToolUse = config.disableParallelToolUse ??
+            vendorConfig.disableParallelToolUse ??
+            false;
+        const metadata = config.metadata ?? vendorConfig.metadata;
+        this.config = {
+            model: config.model || "claude-3-5-haiku-latest",
+            maxTokens: config.maxTokens || 1024,
+            disableParallelToolUse,
+            metadata,
+            apiKey: config.apiKey,
+            temperature: config.temperature,
+            topP: config.topP,
+            topK: config.topK,
+            stopSequences: config.stopSequences,
+        };
+        // Add system message to history (skips if already exists with same content)
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => tool.getPrompt());
+    }
+    async process(_input) {
+        return "";
+    }
+    async execute(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        // Reset token usage for this execution
+        this.lastTokenUsage = undefined;
+        this.currentToolCallCount = 0;
+        // Start visualization reporting
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, "anthropic", input);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            // Re-add system message after clear
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        this.addTextToHistory("user", input);
+        try {
+            const messages = transformers_1.anthropicTransformer.toProvider(this.history.entries);
+            const systemMessage = this.history.getSystemMessage();
+            const response = await this.client.messages.create({
+                model: this.config.model,
+                system: systemMessage,
+                max_tokens: this.config.maxTokens,
+                messages,
+                tools: this.getToolDefinitions(),
+                temperature: this.config.temperature,
+                top_p: this.config.topP,
+                top_k: this.config.topK,
+                stop_sequences: this.config.stopSequences,
+                metadata: this.config.metadata,
+            });
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
+            return await this.handleResponse(response);
+        }
+        catch (error) {
+            if (error instanceof sdk_1.APIError) {
+                const apiError = new AgentError_1.ApiError(`Anthropic API error: ${error.message}`, error.status, error);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                // Report error to viz
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, error.status === 429 // Rate limit is retryable
+                    );
+                    this.vizEventId = undefined;
+                }
+                throw apiError;
+            }
+            else {
+                const executionError = new AgentError_1.ExecutionError(`Error executing agent: ${error instanceof Error ? error.message : "Unknown error"}`);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+                // Report error to viz
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw executionError;
+            }
+        }
+    }
+    async handleResponse(response) {
+        const usage = this.parseUsage(response.usage);
+        // Store token usage for metrics tracking
+        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 (response.stop_reason === "max_tokens") {
+            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);
+            // Report error to viz
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
+                this.vizEventId = undefined;
+            }
+            throw error;
+        }
+        if (response.stop_reason !== "tool_use") {
+            if (response.content && response.content[0]?.type === "text") {
+                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);
+                this.addToHistory(entry);
+                // Report completion to viz
+                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, response.content[0].text);
+                    this.vizEventId = undefined;
+                }
+                return response.content[0].text;
+            }
+            else {
+                const error = new AgentError_1.ExecutionError(`Unexpected response format: ${JSON.stringify(response.content)}`);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+                // Report error to viz
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", error.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw error;
+            }
+        }
+        else if (response.stop_reason === "tool_use") {
+            try {
+                this.emit(AgentEvent_1.AgentEvent.TOOL_USE, response.content);
+                // Add assistant response to history (normalized format)
+                const assistantEntry = transformers_1.anthropicTransformer.fromProviderContent("assistant", response.content);
+                this.addToHistory(assistantEntry);
+                const toolResults = await this.handleToolUse(response.content);
+                // Add tool results to history (normalized format)
+                this.addMessageToHistory("user", toolResults);
+                // Continue conversation with tool results
+                try {
+                    const messages = transformers_1.anthropicTransformer.toProvider(this.history.entries);
+                    const newResponse = await this.client.messages.create({
+                        model: this.config.model,
+                        max_tokens: this.config.maxTokens,
+                        messages,
+                        tools: this.getToolDefinitions(),
+                        temperature: this.config.temperature,
+                        top_p: this.config.topP,
+                        top_k: this.config.topK,
+                        stop_sequences: this.config.stopSequences,
+                        metadata: this.config.metadata,
+                    });
+                    this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
+                    return this.handleResponse(newResponse);
+                }
+                catch (error) {
+                    if (error instanceof sdk_1.APIError) {
+                        const apiError = new AgentError_1.ApiError(`Anthropic API error during tool response: ${error.message}`, error.status, error);
+                        this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                        throw apiError;
+                    }
+                    else {
+                        throw new AgentError_1.ExecutionError(`Error handling tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof AgentError_1.ToolExecutionError) {
+                    this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, error);
+                    throw error;
+                }
+                const toolError = new AgentError_1.ExecutionError(`Error during tool execution: ${error instanceof Error ? error.message : "Unknown error"}`);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, toolError);
+                throw toolError;
+            }
+        }
+        const error = new AgentError_1.ExecutionError(`Unexpected stop_reason: ${response.stop_reason}`);
+        this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+        throw error;
+    }
+    async handleToolUse(content) {
+        const toolUseBlocks = content.filter((block) => block.type === "tool_use");
+        if (!toolUseBlocks.length) {
+            throw new AgentError_1.ExecutionError("No tool use blocks found in content");
+        }
+        // Track tool call count for viz reporting
+        this.currentToolCallCount += toolUseBlocks.length;
+        const results = await Promise.all(toolUseBlocks.map(async (block) => {
+            const tool = this.tools.get(block.name);
+            if (!tool) {
+                const errorMessage = `Tool '${block.name}' not found`;
+                const error = new AgentError_1.ToolExecutionError(errorMessage, block.name, block.input);
+                if (this.debug) {
+                    console.error(error);
+                }
+                return (0, History_1.toolResult)(block.id, errorMessage, true);
+            }
+            try {
+                const result = await tool.execute(this.getId(), this.getName(), block.input, block.id, this.config.model, "anthropic");
+                return (0, History_1.toolResult)(block.id, JSON.stringify(result));
+            }
+            catch (error) {
+                const errorMessage = `Error executing tool '${block.name}': ${error instanceof Error ? error.message : "Unknown error"}`;
+                if (this.debug) {
+                    console.error(errorMessage);
+                }
+                const toolError = new AgentError_1.ToolExecutionError(errorMessage, block.name, block.input);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, toolError);
+                return (0, History_1.toolResult)(block.id, errorMessage, true);
+            }
+        }));
+        return results;
+    }
+    parseUsage(input) {
+        return {
+            input_tokens: input.input_tokens,
+            output_tokens: input.output_tokens,
+            total_tokens: input.input_tokens + input.output_tokens,
+        };
+    }
+}
+exports.ClaudeAgent = ClaudeAgent;
+//# sourceMappingURL=ClaudeAgent.js.map

package/dist/agents/errors/AgentError.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Base error class for all agent-related errors
+ */
+export declare class AgentError extends Error {
+    /**
+     * @param message Error message
+     * @param options Additional error options
+     */
+    constructor(message: string);
+}
+/**
+ * Error thrown when an agent's execution fails
+ */
+export declare class ExecutionError extends AgentError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when LLM API request fails
+ */
+export declare class ApiError extends AgentError {
+    statusCode?: number | undefined;
+    response?: any | undefined;
+    constructor(message: string, statusCode?: number | undefined, response?: any | undefined);
+}
+/**
+ * Error thrown when maximum token limit is exceeded
+ */
+export declare class MaxTokensExceededError extends AgentError {
+    tokenLimit: number;
+    constructor(message: string, tokenLimit: number);
+}
+/**
+ * Error thrown when maximum retries are exceeded
+ */
+export declare class MaxRetriesExceededError extends AgentError {
+    maxRetries: number;
+    constructor(message: string, maxRetries: number);
+}
+/**
+ * Error thrown when tool execution fails
+ */
+export declare class ToolExecutionError extends AgentError {
+    toolName: string;
+    input: any;
+    constructor(message: string, toolName: string, input: any);
+}
+//# sourceMappingURL=AgentError.d.ts.map

package/dist/agents/errors/AgentError.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutionError = exports.MaxRetriesExceededError = exports.MaxTokensExceededError = exports.ApiError = exports.ExecutionError = exports.AgentError = void 0;
+/**
+ * Base error class for all agent-related errors
+ */
+class AgentError extends Error {
+    /**
+     * @param message Error message
+     * @param options Additional error options
+     */
+    constructor(message) {
+        super(message);
+        this.name = "AgentError";
+    }
+}
+exports.AgentError = AgentError;
+/**
+ * Error thrown when an agent's execution fails
+ */
+class ExecutionError extends AgentError {
+    constructor(message) {
+        super(message);
+        this.name = "ExecutionError";
+    }
+}
+exports.ExecutionError = ExecutionError;
+/**
+ * Error thrown when LLM API request fails
+ */
+class ApiError extends AgentError {
+    constructor(message, statusCode, response) {
+        super(message);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = "ApiError";
+    }
+}
+exports.ApiError = ApiError;
+/**
+ * Error thrown when maximum token limit is exceeded
+ */
+class MaxTokensExceededError extends AgentError {
+    constructor(message, tokenLimit) {
+        super(message);
+        this.tokenLimit = tokenLimit;
+        this.name = "MaxTokensExceededError";
+    }
+}
+exports.MaxTokensExceededError = MaxTokensExceededError;
+/**
+ * Error thrown when maximum retries are exceeded
+ */
+class MaxRetriesExceededError extends AgentError {
+    constructor(message, maxRetries) {
+        super(message);
+        this.maxRetries = maxRetries;
+        this.name = "MaxRetriesExceededError";
+    }
+}
+exports.MaxRetriesExceededError = MaxRetriesExceededError;
+/**
+ * Error thrown when tool execution fails
+ */
+class ToolExecutionError extends AgentError {
+    constructor(message, toolName, input) {
+        super(message);
+        this.toolName = toolName;
+        this.input = input;
+        this.name = "ToolExecutionError";
+    }
+}
+exports.ToolExecutionError = ToolExecutionError;
+//# sourceMappingURL=AgentError.js.map