@agentionai/agents 0.6.1 → 0.7.0

package/dist/agents/BaseAgent.d.ts

@@ -4,11 +4,6 @@ import { History, HistoryEntry, MessageRole, MessageContent } from "../history/H
 import { AgentVendor, CommonAgentConfig, VendorSpecificConfig } from "./AgentConfig";
 export type { HistoryEntry, MessageRole, MessageContent };
 export type { AgentVendor };
-/**
- * Parses a `retry-after` header value (seconds as string) into milliseconds.
- */
-declare function parseRetryAfterHeader(header: string | undefined): number | undefined;
-export { parseRetryAfterHeader };
 /**
  * Agent config as used across all agents
  * @deprecated Use CommonAgentConfig with vendorConfig instead
@@ -38,16 +33,6 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
     protected vendor: AgentVendor;
     /** The model identifier for this agent */
     protected model: string;
-    /** Token usage from the last execution (for metrics tracking) */
-    lastTokenUsage?: TokenUsage;
-    /** Maximum number of retry attempts (0 = disabled) */
-    protected maxRetries: number;
-    /** Initial backoff delay in ms */
-    private retryDelayMs;
-    /** Multiplier applied to delay after each attempt */
-    private retryBackoffFactor;
-    /** Maximum backoff delay cap in ms */
-    private retryMaxDelayMs;
     /**
      * An Agent is the primary LLM entity.
      *
@@ -83,30 +68,6 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
      * Add a message with content blocks to history
      */
     protected addMessageToHistory(role: MessageRole, content: MessageContent[]): void;
-    /**
-     * Enable retry with exponential backoff for this agent.
-     * @param options.maxRetries - Number of retry attempts (default: 3)
-     * @param options.initialDelay - Initial backoff delay in ms (default: 1000)
-     * @param options.backoffFactor - Multiplier per attempt (default: 2)
-     * @param options.maxDelay - Maximum delay cap in ms (default: 30000)
-     */
-    withRetry(options?: {
-        maxRetries?: number;
-        initialDelay?: number;
-        backoffFactor?: number;
-        maxDelay?: number;
-    }): this;
-    /**
-     * Executes a function with retry and exponential backoff.
-     *
-     * Retries on 429 (rate limit) and 5xx (server error) responses.
-     * Never retries on MaxTokensExceededError or 4xx client errors.
-     * Throws MaxRetriesExceededError when all attempts are exhausted.
-     *
-     * @param fn - The async function to execute
-     * @param getRetryAfterMs - Optional extractor for retry-after header (returns ms to wait)
-     */
-    protected executeWithRetry<T>(fn: () => Promise<T>, getRetryAfterMs?: (error: unknown) => number | undefined): Promise<T>;
     addTools(tools: Tool<unknown>[]): void;
     getId(): string;
     getName(): string;

package/dist/agents/BaseAgent.js

@@ -4,30 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseAgent = void 0;
-exports.parseRetryAfterHeader = parseRetryAfterHeader;
 const events_1 = __importDefault(require("events"));
 const Tool_1 = require("../tools/Tool");
 const History_1 = require("../history/History");
-const AgentEvent_1 = require("./AgentEvent");
-const AgentError_1 = require("./errors/AgentError");
-/**
- * Extracts an HTTP status code from a raw SDK error of any vendor shape.
- */
-function extractStatusCode(error) {
-    if (error instanceof AgentError_1.ApiError)
-        return error.statusCode;
-    const e = error;
-    return typeof e.status === "number" ? e.status : undefined;
-}
-/**
- * Parses a `retry-after` header value (seconds as string) into milliseconds.
- */
-function parseRetryAfterHeader(header) {
-    if (!header)
-        return undefined;
-    const seconds = parseFloat(header);
-    return isNaN(seconds) ? undefined : Math.ceil(seconds * 1000);
-}
 /**
  * The base agent is what the other agents are inheriting from
  * Handles the BaseConfig
@@ -45,15 +24,7 @@ class BaseAgent extends events_1.default {
     constructor(config, history = new History_1.History([], { transient: true })) {
         super();
         this.history = history;
-        this.debug = false;
-        /** Maximum number of retry attempts (0 = disabled) */
-        this.maxRetries = 0;
-        /** Initial backoff delay in ms */
-        this.retryDelayMs = 1000;
-        /** Multiplier applied to delay after each attempt */
-        this.retryBackoffFactor = 2;
-        /** Maximum backoff delay cap in ms */
-        this.retryMaxDelayMs = 30000;
+        this.debug = true;
         this.id = config.id;
         this.debug = config.debug || false;
         this.name = config.name;
@@ -70,7 +41,6 @@ class BaseAgent extends events_1.default {
         }
         this.tools = new Map((config.tools || []).map((tool) => [tool.name, tool]));
         this.maxHistoryLength = config.maxHistoryLength || 100;
-        this.maxRetries = config.maxRetries ?? 0;
     }
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => tool.getPrompt());
@@ -111,75 +81,6 @@ class BaseAgent extends events_1.default {
     addMessageToHistory(role, content) {
         this.history.addMessage(role, content);
     }
-    /**
-     * Enable retry with exponential backoff for this agent.
-     * @param options.maxRetries - Number of retry attempts (default: 3)
-     * @param options.initialDelay - Initial backoff delay in ms (default: 1000)
-     * @param options.backoffFactor - Multiplier per attempt (default: 2)
-     * @param options.maxDelay - Maximum delay cap in ms (default: 30000)
-     */
-    withRetry(options) {
-        this.maxRetries = options?.maxRetries ?? 3;
-        if (options?.initialDelay !== undefined)
-            this.retryDelayMs = options.initialDelay;
-        if (options?.backoffFactor !== undefined)
-            this.retryBackoffFactor = options.backoffFactor;
-        if (options?.maxDelay !== undefined)
-            this.retryMaxDelayMs = options.maxDelay;
-        return this;
-    }
-    /**
-     * Executes a function with retry and exponential backoff.
-     *
-     * Retries on 429 (rate limit) and 5xx (server error) responses.
-     * Never retries on MaxTokensExceededError or 4xx client errors.
-     * Throws MaxRetriesExceededError when all attempts are exhausted.
-     *
-     * @param fn - The async function to execute
-     * @param getRetryAfterMs - Optional extractor for retry-after header (returns ms to wait)
-     */
-    async executeWithRetry(fn, getRetryAfterMs) {
-        let attempt = 0;
-        let delayMs = this.retryDelayMs;
-        while (true) {
-            try {
-                return await fn();
-            }
-            catch (error) {
-                // MaxTokensExceededError is never retryable
-                if (error instanceof AgentError_1.MaxTokensExceededError)
-                    throw error;
-                const statusCode = extractStatusCode(error);
-                const isRetryable = statusCode === 429 ||
-                    (statusCode !== undefined && statusCode >= 500);
-                if (!isRetryable || attempt >= this.maxRetries) {
-                    if (attempt > 0) {
-                        this.emit(AgentEvent_1.AgentEvent.MAX_RETRIES_EXCEEDED, {
-                            maxRetries: this.maxRetries,
-                            error,
-                        });
-                        throw new AgentError_1.MaxRetriesExceededError(`Max retries (${this.maxRetries}) exceeded`, this.maxRetries);
-                    }
-                    throw error;
-                }
-                attempt++;
-                // Respect retry-after header if the SDK provides it
-                const retryAfter = getRetryAfterMs?.(error);
-                // Add ±10% jitter to avoid thundering herd
-                const jitter = delayMs * 0.1 * (Math.random() * 2 - 1);
-                const waitMs = Math.min(retryAfter ?? delayMs + jitter, this.retryMaxDelayMs);
-                this.emit(AgentEvent_1.AgentEvent.RETRY, {
-                    attempt,
-                    maxRetries: this.maxRetries,
-                    delayMs: waitMs,
-                    statusCode,
-                    error,
-                });
-                await new Promise((resolve) => setTimeout(resolve, waitMs));
-                delayMs = Math.min(delayMs * this.retryBackoffFactor, this.retryMaxDelayMs);
-            }
-        }
-    }
     addTools(tools) {
         tools.forEach((tool) => {
             if (!this.tools.has(tool.name)) {

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

@@ -28,6 +28,8 @@ type AgentConfig = BaseAgentConfig & {
 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 */

package/dist/agents/anthropic/ClaudeAgent.js

@@ -77,7 +77,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         try {
             const messages = transformers_1.anthropicTransformer.toProvider(this.history.entries);
             const systemMessage = this.history.getSystemMessage();
-            const response = await this.executeWithRetry(() => this.client.messages.create({
+            const response = await this.client.messages.create({
                 model: this.config.model,
                 system: systemMessage,
                 max_tokens: this.config.maxTokens,
@@ -88,9 +88,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 top_k: this.config.topK,
                 stop_sequences: this.config.stopSequences,
                 metadata: this.config.metadata,
-            }), (err) => err instanceof sdk_1.APIError
-                ? (0, BaseAgent_1.parseRetryAfterHeader)(err.headers?.["retry-after"])
-                : undefined);
+            });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -180,7 +178,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation with tool results
                 try {
                     const messages = transformers_1.anthropicTransformer.toProvider(this.history.entries);
-                    const newResponse = await this.executeWithRetry(() => this.client.messages.create({
+                    const newResponse = await this.client.messages.create({
                         model: this.config.model,
                         max_tokens: this.config.maxTokens,
                         messages,
@@ -190,9 +188,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                         top_k: this.config.topK,
                         stop_sequences: this.config.stopSequences,
                         metadata: this.config.metadata,
-                    }), (err) => err instanceof sdk_1.APIError
-                        ? (0, BaseAgent_1.parseRetryAfterHeader)(err.headers?.["retry-after"])
-                        : undefined);
+                    });
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
                 }

package/dist/agents/google/GeminiAgent.d.ts

@@ -29,6 +29,8 @@ export declare class GeminiAgent extends BaseAgent {
     private client;
     private generativeModel;
     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 */

package/dist/agents/google/GeminiAgent.js

@@ -179,7 +179,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             const contents = transformers_1.geminiTransformer.toProvider(this.history.entries);
             const systemMessage = this.history.getSystemMessage();
             const tools = this.getToolDefinitionsForGemini();
-            const response = await this.executeWithRetry(() => this.generativeModel.generateContent({
+            const response = await this.generativeModel.generateContent({
                 contents,
                 systemInstruction: systemMessage,
                 tools: tools ? [tools] : undefined,
@@ -193,7 +193,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                     responseMimeType: this.config.responseMimeType,
                     responseSchema: this.config.responseSchema,
                 },
-            }));
+            });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -293,7 +293,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                 const newContents = transformers_1.geminiTransformer.toProvider(this.history.entries);
                 const systemMessage = this.history.getSystemMessage();
                 const tools = this.getToolDefinitionsForGemini();
-                const newResponse = await this.executeWithRetry(() => this.generativeModel.generateContent({
+                const newResponse = await this.generativeModel.generateContent({
                     contents: newContents,
                     systemInstruction: systemMessage,
                     tools: tools ? [tools] : undefined,
@@ -307,7 +307,7 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                         responseMimeType: this.config.responseMimeType,
                         responseSchema: this.config.responseSchema,
                     },
-                }));
+                });
                 this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                 return this.handleResponse(newResponse);
             }

package/dist/agents/mistral/MistralAgent.d.ts

@@ -29,6 +29,8 @@ type AgentConfig = BaseAgentConfig & {
 export declare class MistralAgent 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 */

package/dist/agents/mistral/MistralAgent.js

@@ -87,7 +87,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         this.addTextToHistory("user", input);
         try {
             const messages = transformers_1.mistralTransformer.toProvider(this.history.entries);
-            const response = await this.executeWithRetry(() => this.client.chat.complete({
+            const response = await this.client.chat.complete({
                 model: this.config.model,
                 messages: messages,
                 tools: this.getToolDefinitions(),
@@ -97,7 +97,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 randomSeed: this.config.randomSeed,
                 safePrompt: this.config.safePrompt,
                 stop: this.config.stopSequences,
-            }));
+            });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -203,7 +203,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation
                 try {
                     const messages = transformers_1.mistralTransformer.toProvider(this.history.entries);
-                    const newResponse = await this.executeWithRetry(() => this.client.chat.complete({
+                    const newResponse = await this.client.chat.complete({
                         model: this.config.model,
                         messages: messages,
                         tools: this.getToolDefinitions(),
@@ -213,7 +213,7 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                         randomSeed: this.config.randomSeed,
                         safePrompt: this.config.safePrompt,
                         stop: this.config.stopSequences,
-                    }));
+                    });
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
                 }

package/dist/agents/openai/OpenAiAgent.d.ts

@@ -30,6 +30,8 @@ type AgentConfig = BaseAgentConfig & {
 export declare class OpenAiAgent 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 */

package/dist/agents/openai/OpenAiAgent.js

@@ -98,7 +98,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         this.addTextToHistory("user", input);
         try {
             const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.entries);
-            const response = await this.executeWithRetry(() => this.client.responses.create({
+            const response = await this.client.responses.create({
                 model: this.config.model,
                 max_output_tokens: this.config.maxTokens,
                 input: inputMessages,
@@ -110,7 +110,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 user: this.config.user,
                 ...(this.config.disableReasoning && { reasoning: { effort: null } }),
                 reasoning: { effort: this.config.reasoningEffort },
-            }));
+            });
             this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
             return await this.handleResponse(response);
         }
@@ -217,7 +217,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                 // Continue conversation
                 try {
                     const inputMessages = transformers_1.openAiTransformer.toProvider(this.history.entries);
-                    const newResponse = await this.executeWithRetry(() => this.client.responses.create({
+                    const newResponse = await this.client.responses.create({
                         model: this.config.model,
                         max_output_tokens: this.config.maxTokens,
                         input: inputMessages,
@@ -234,7 +234,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                             !this.config.disableReasoning && {
                             reasoning: { effort: this.config.reasoningEffort },
                         }),
-                    }));
+                    });
                     this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
                     return this.handleResponse(newResponse);
                 }

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 "./mcp";
 export * from "./viz";
 export * from "./vectorstore";
 export * from "./chunkers";

package/dist/core.js

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

package/dist/graph/planning/PlanExecutor.d.ts

@@ -23,14 +23,6 @@ export interface PlanExecutorOptions {
      * @default true
      */
     stopOnFailure?: boolean;
-    /**
-     * Maximum number of previous step results to include in worker context.
-     * This prevents context overflow by limiting how much history is passed to each step.
-     * Set to 0 to include no previous steps (workers should use context_get to retrieve data).
-     * Set to a small number (1-3) to include only recent context.
-     * @default 0 (workers request context explicitly)
-     */
-    maxContextSteps?: number;
     /**
      * Callback invoked when planning phase completes.
      */
@@ -153,10 +145,6 @@ export declare class PlanExecutor extends BaseExecutor<string, string> {
     private createPlanningPrompt;
     /**
      * Create input for a step execution.
-     *
-     * By default, only includes the current step information.
-     * Workers should use context_get to retrieve data from previous steps.
-     * This prevents token overflow from accumulating context.
      */
     private createStepInput;
     /**

package/dist/graph/planning/PlanExecutor.js

@@ -57,7 +57,6 @@ class PlanExecutor extends BaseExecutor_1.BaseExecutor {
             maxSteps: options.maxSteps ?? 50,
             concurrency: options.concurrency ?? 1,
             stopOnFailure: options.stopOnFailure ?? true,
-            maxContextSteps: options.maxContextSteps ?? 0, // Default: no auto context
             onPlanCreated: options.onPlanCreated,
             onStepStart: options.onStepStart,
             onStepComplete: options.onStepComplete,
@@ -151,16 +150,11 @@ class PlanExecutor extends BaseExecutor_1.BaseExecutor {
         const results = [];
         let stepNumber = 0;
         const activePromises = new Map();
-        let stopError;
         while (stepNumber < this.options.maxSteps) {
             // Wait if we've reached concurrency limit
             if (activePromises.size >= this.options.concurrency) {
                 await Promise.race(activePromises.values());
             }
-            // If a step failed and stopOnFailure is set, drain remaining promises then throw
-            if (stopError) {
-                break;
-            }
             const nextStep = this.planStore.getNextStep();
             if (!nextStep) {
                 // No more pending steps
@@ -208,9 +202,9 @@ class PlanExecutor extends BaseExecutor_1.BaseExecutor {
                     });
                     // Notify step failure
                     this.options.onStepFailed?.(nextStep, error instanceof Error ? error : new Error(errorMessage), stepNumber);
-                    // Record error to stop after in-flight steps complete
+                    // Stop if configured to do so
                     if (this.options.stopOnFailure) {
-                        stopError = new Error(`Step ${stepNumber} failed: ${errorMessage}`);
+                        throw new Error(`Step ${stepNumber} failed: ${errorMessage}`);
                     }
                 }
                 finally {
@@ -226,12 +220,9 @@ class PlanExecutor extends BaseExecutor_1.BaseExecutor {
                 await promise;
             }
         }
-        // Always wait for all in-flight promises to finish before returning/throwing
+        // Wait for all remaining promises to complete
         if (activePromises.size > 0) {
-            await Promise.allSettled(activePromises.values());
-        }
-        if (stopError) {
-            throw stopError;
+            await Promise.all(activePromises.values());
         }
         if (stepNumber >= this.options.maxSteps) {
             const plan = this.planStore.getActivePlan();
@@ -250,81 +241,34 @@ class PlanExecutor extends BaseExecutor_1.BaseExecutor {
 
 Task: ${task}
 
-CRITICAL: You can create a maximum of ${this.options.maxSteps} steps. Plan accordingly and prioritize the most important subtasks.
-
-CONTEXT LIMIT WARNING: Each step will be executed independently with limited context. To avoid rate limits and context overflow:
-- Break work into VERY SMALL, ATOMIC steps
-- Each step should process only 1-3 items at a time
-- Never create steps that say "analyze all", "process everything", "read all files", etc.
-- Instead, break into multiple steps: "Read file1", "Read file2", "Read file3"
-
-Use the create_plan tool to create a plan with clear, actionable steps. Each step MUST be:
-
-1. MICRO-SIZED - Can be completed in under 10 seconds with minimal tokens
-2. SINGLE ACTION - Exactly ONE thing to do (read ONE file, list ONE directory, etc.)
-3. SPECIFIC - Mention exact file names, directories, or items (not "all files")
-4. NO BATCH OPERATIONS - Process items one-by-one, not in bulk
-5. SEQUENTIAL - Let each step's output inform the next step
-
-GOOD EXAMPLES (SMALL STEPS):
-✓ "List files in the lib/graph directory"
-✓ "Read the first 50 lines of PlanExecutor.ts"
-✓ "Search for the definition of 'createPlan' function"
-✓ "Summarize the purpose of SequentialExecutor class in 2 sentences"
-
-BAD EXAMPLES (TOO LARGE):
-✗ "Read and analyze all files in lib/graph" (reads too much, use multiple steps)
-✗ "Analyze the entire codebase architecture" (too broad, break into 5+ steps)
-✗ "Review all test files and identify issues" (batch operation, do one at a time)
-✗ "Research best practices and implement them" (vague, multi-step)
+IMPORTANT: You can create a maximum of ${this.options.maxSteps} steps. Plan accordingly and prioritize the most important subtasks.
 
-STRATEGY FOR AVOIDING RATE LIMITS:
-- If analyzing multiple files: Create one step per file
-- If processing a list: Create one step per item
-- If researching: Create steps for: 1) identify what to research, 2) research item 1, 3) research item 2, etc.
-- If the task seems large: Create 2x as many steps as you initially think
-
-Break down complex tasks into the SMALLEST possible steps. Having ${this.options.maxSteps} small steps is much better than having ${Math.floor(this.options.maxSteps / 2)} larger ones.
+Use the create_plan tool to create a plan with clear, actionable steps. Each step should be:
+- Specific and focused on a single subtask
+- Ordered logically (dependencies should be addressed)
+- Achievable by a worker agent
 
 After creating the plan, respond with a brief confirmation.`;
     }
     /**
      * Create input for a step execution.
-     *
-     * By default, only includes the current step information.
-     * Workers should use context_get to retrieve data from previous steps.
-     * This prevents token overflow from accumulating context.
      */
     createStepInput(step, stepNumber) {
         const plan = this.planStore.getActivePlan();
         const completedSteps = plan?.steps.filter((s) => s.status === "completed") || [];
-        // Limit context to prevent token overflow
-        // Only include the most recent N steps based on maxContextSteps option
-        const recentSteps = this.options.maxContextSteps > 0
-            ? completedSteps.slice(-this.options.maxContextSteps)
-            : [];
-        const input = {
+        return JSON.stringify({
             stepNumber,
             totalSteps: plan?.steps.length,
             currentStep: {
                 id: step.id,
                 description: step.description,
             },
-            planGoal: plan?.goal,
-        };
-        // Only add previous steps if maxContextSteps > 0
-        if (this.options.maxContextSteps > 0 && recentSteps.length > 0) {
-            input.previousSteps = recentSteps.map((s) => ({
+            previousSteps: completedSteps.map((s) => ({
                 description: s.description,
                 output: s.output,
-            }));
-            input.contextNote = `Showing last ${recentSteps.length} of ${completedSteps.length} completed steps`;
-        }
-        else {
-            input.contextNote =
-                "Use context_get tool to retrieve data from previous steps if needed";
-        }
-        return JSON.stringify(input, null, 2);
+            })),
+            planGoal: plan?.goal,
+        });
     }
     /**
      * Compile the final result from step results.
@@ -377,12 +321,13 @@ After creating the plan, respond with a brief confirmation.`;
      * Extract token usage from an agent if available.
      */
     extractTokenUsage(agent) {
-        if (!agent.lastTokenUsage)
+        const agentWithUsage = agent;
+        if (!agentWithUsage.lastTokenUsage)
             return undefined;
         return {
-            inputTokens: agent.lastTokenUsage.input_tokens,
-            outputTokens: agent.lastTokenUsage.output_tokens,
-            totalTokens: agent.lastTokenUsage.total_tokens,
+            inputTokens: agentWithUsage.lastTokenUsage.input_tokens,
+            outputTokens: agentWithUsage.lastTokenUsage.output_tokens,
+            totalTokens: agentWithUsage.lastTokenUsage.total_tokens,
         };
     }
     /**

package/dist/graph/planning/PlanStore.js

@@ -119,12 +119,8 @@ class PlanStore {
         const plan = this.getActivePlan();
         if (!plan)
             return undefined;
-        const maxIndex = plan.steps.reduce((max, s) => {
-            const match = s.id.match(/^step_(\d+)$/);
-            return match ? Math.max(max, parseInt(match[1], 10)) : max;
-        }, 0);
         const newStep = {
-            id: `step_${maxIndex + 1}`,
+            id: `step_${plan.steps.length + 1}`,
             description,
             status: "pending",
         };
@@ -173,7 +169,7 @@ class PlanStore {
      * Update the overall plan status based on step statuses.
      */
     updatePlanStatus(plan) {
-        const allCompleted = plan.steps.every((s) => s.status === "completed" || s.status === "skipped");
+        const allCompleted = plan.steps.every((s) => s.status === "completed");
         const anyFailed = plan.steps.some((s) => s.status === "failed");
         const anyInProgress = plan.steps.some((s) => s.status === "in_progress");
         let newStatus;

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export * from "./history/types";
 export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, } from "./history/transformers";
 export * from "./graph/AgentGraph";
 export * from "./tools/Tool";
+export * from "./mcp";
 export * from "./viz";
 export * from "./vectorstore";
 export * from "./embeddings";

package/dist/index.js

@@ -45,6 +45,8 @@ Object.defineProperty(exports, "geminiTransformer", { enumerable: true, get: fun
 __exportStar(require("./graph/AgentGraph"), exports);
 // Tools
 __exportStar(require("./tools/Tool"), exports);
+// MCP (Model Context Protocol)
+__exportStar(require("./mcp"), exports);
 // Visualization
 __exportStar(require("./viz"), exports);
 // Vector Store

package/dist/mcp/MCPClient.d.ts

@@ -0,0 +1,106 @@
+import { Tool } from "../tools/Tool";
+import { MCPStdioConfig, MCPHttpConfig, MCPClientOptions } from "./types";
+/**
+ * MCPClient connects to an MCP (Model Context Protocol) server and converts its
+ * tools into agention-lib {@link Tool} instances that can be passed to any agent.
+ *
+ * Supports two transport types:
+ * - **stdio** — spawns a local process and communicates over stdin/stdout
+ * - **http** — connects to a remote MCP server over Streamable HTTP
+ *
+ * @requires @modelcontextprotocol/sdk - Install as a peer dependency:
+ * ```
+ * npm install @modelcontextprotocol/sdk
+ * ```
+ *
+ * @example Stdio (local process)
+ * ```typescript
+ * import { MCPClient } from "@agentionai/agents";
+ * import { ClaudeAgent } from "@agentionai/agents/claude";
+ *
+ * const mcp = MCPClient.fromStdio({
+ *   command: "npx",
+ *   args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
+ * });
+ *
+ * await mcp.connect();
+ * const agent = new ClaudeAgent({
+ *   id: "file-agent",
+ *   name: "File Agent",
+ *   description: "An agent that can work with files",
+ *   apiKey: process.env.ANTHROPIC_API_KEY!,
+ *   tools: mcp.getTools(),
+ * });
+ *
+ * const result = await agent.execute("List the files in /tmp");
+ * await mcp.disconnect();
+ * ```
+ *
+ * @example HTTP with static API key
+ * ```typescript
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   headers: { Authorization: "Bearer my-api-key" },
+ * });
+ *
+ * await mcp.connect();
+ * agent.addTools(mcp.getTools());
+ * ```
+ *
+ * @example HTTP with OAuth
+ * ```typescript
+ * import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+ *
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   authProvider: myOAuthProvider, // implements OAuthClientProvider
+ * });
+ * ```
+ */
+export declare class MCPClient {
+    private readonly transportConfig;
+    private readonly options;
+    private sdkClient;
+    private sdkTransport;
+    private _tools;
+    private connected;
+    private constructor();
+    /**
+     * Create an MCPClient that connects to a local MCP server process via stdio.
+     *
+     * @param config - Command and arguments to spawn the MCP server process
+     * @param options - Optional client identification options
+     */
+    static fromStdio(config: MCPStdioConfig, options?: MCPClientOptions): MCPClient;
+    /**
+     * Create an MCPClient that connects to a remote MCP server via HTTP.
+     *
+     * @param url - Full URL to the MCP endpoint
+     * @param options - Optional client options including auth headers or OAuth provider
+     */
+    static fromUrl(url: string, options?: MCPClientOptions & Pick<MCPHttpConfig, "headers" | "authProvider">): MCPClient;
+    /**
+     * Connect to the MCP server and discover all available tools.
+     *
+     * This method is idempotent — calling it when already connected is a no-op.
+     * Must be called before {@link getTools}.
+     *
+     * @throws If the MCP server cannot be reached or the SDK is not installed
+     */
+    connect(): Promise<void>;
+    /**
+     * Return all tools discovered from the MCP server as agention-lib Tool instances.
+     *
+     * Returns an empty array if {@link connect} has not been called yet.
+     * The returned tools can be passed directly to any agent via the `tools` config
+     * option or {@link BaseAgent.addTools}.
+     */
+    getTools(): Tool<unknown>[];
+    /**
+     * Disconnect from the MCP server and release all resources.
+     *
+     * This method is idempotent — calling it when not connected is a no-op.
+     * After disconnecting, {@link getTools} returns an empty array.
+     */
+    disconnect(): Promise<void>;
+    private wrapMcpTool;
+}
+//# sourceMappingURL=MCPClient.d.ts.map

package/dist/mcp/MCPClient.js

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPClient = void 0;
+const Tool_1 = require("../tools/Tool");
+/**
+ * MCPClient connects to an MCP (Model Context Protocol) server and converts its
+ * tools into agention-lib {@link Tool} instances that can be passed to any agent.
+ *
+ * Supports two transport types:
+ * - **stdio** — spawns a local process and communicates over stdin/stdout
+ * - **http** — connects to a remote MCP server over Streamable HTTP
+ *
+ * @requires @modelcontextprotocol/sdk - Install as a peer dependency:
+ * ```
+ * npm install @modelcontextprotocol/sdk
+ * ```
+ *
+ * @example Stdio (local process)
+ * ```typescript
+ * import { MCPClient } from "@agentionai/agents";
+ * import { ClaudeAgent } from "@agentionai/agents/claude";
+ *
+ * const mcp = MCPClient.fromStdio({
+ *   command: "npx",
+ *   args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
+ * });
+ *
+ * await mcp.connect();
+ * const agent = new ClaudeAgent({
+ *   id: "file-agent",
+ *   name: "File Agent",
+ *   description: "An agent that can work with files",
+ *   apiKey: process.env.ANTHROPIC_API_KEY!,
+ *   tools: mcp.getTools(),
+ * });
+ *
+ * const result = await agent.execute("List the files in /tmp");
+ * await mcp.disconnect();
+ * ```
+ *
+ * @example HTTP with static API key
+ * ```typescript
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   headers: { Authorization: "Bearer my-api-key" },
+ * });
+ *
+ * await mcp.connect();
+ * agent.addTools(mcp.getTools());
+ * ```
+ *
+ * @example HTTP with OAuth
+ * ```typescript
+ * import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+ *
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   authProvider: myOAuthProvider, // implements OAuthClientProvider
+ * });
+ * ```
+ */
+class MCPClient {
+    constructor(transportConfig, options = {}) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.sdkClient = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.sdkTransport = null;
+        this._tools = [];
+        this.connected = false;
+        this.transportConfig = transportConfig;
+        this.options = {
+            clientName: options.clientName ?? "agention-mcp-client",
+            clientVersion: options.clientVersion ?? "1.0.0",
+        };
+    }
+    /**
+     * Create an MCPClient that connects to a local MCP server process via stdio.
+     *
+     * @param config - Command and arguments to spawn the MCP server process
+     * @param options - Optional client identification options
+     */
+    static fromStdio(config, options) {
+        return new MCPClient({ type: "stdio", config }, options);
+    }
+    /**
+     * Create an MCPClient that connects to a remote MCP server via HTTP.
+     *
+     * @param url - Full URL to the MCP endpoint
+     * @param options - Optional client options including auth headers or OAuth provider
+     */
+    static fromUrl(url, options) {
+        const config = {
+            url,
+            headers: options?.headers,
+            authProvider: options?.authProvider,
+        };
+        return new MCPClient({ type: "http", config }, options);
+    }
+    /**
+     * Connect to the MCP server and discover all available tools.
+     *
+     * This method is idempotent — calling it when already connected is a no-op.
+     * Must be called before {@link getTools}.
+     *
+     * @throws If the MCP server cannot be reached or the SDK is not installed
+     */
+    async connect() {
+        if (this.connected)
+            return;
+        // Build module paths at runtime so tsc does not attempt to resolve them at
+        // compile time. @modelcontextprotocol/sdk is an optional peer dependency and
+        // may not be installed on the build host.
+        const pkg = "@modelcontextprotocol/sdk";
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const { Client } = await Promise.resolve(`${`${pkg}/client/index.js`}`).then(s => __importStar(require(s)));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const sdkClient = new Client({ name: this.options.clientName, version: this.options.clientVersion }, { capabilities: {} });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let transport;
+        if (this.transportConfig.type === "stdio") {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const { StdioClientTransport } = await Promise.resolve(`${`${pkg}/client/stdio.js`}`).then(s => __importStar(require(s)));
+            transport = new StdioClientTransport({
+                command: this.transportConfig.config.command,
+                args: this.transportConfig.config.args ?? [],
+                env: this.transportConfig.config.env,
+            });
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const { StreamableHTTPClientTransport } = await Promise.resolve(`${`${pkg}/client/streamableHttp.js`}`).then(s => __importStar(require(s)));
+            const { url, headers, authProvider } = this.transportConfig.config;
+            transport = new StreamableHTTPClientTransport(new URL(url), {
+                ...(headers ? { requestInit: { headers } } : {}),
+                ...(authProvider ? { authProvider } : {}),
+            });
+        }
+        await sdkClient.connect(transport);
+        this.sdkClient = sdkClient;
+        this.sdkTransport = transport;
+        this.connected = true;
+        // Paginate through all tools
+        const allMcpTools = [];
+        let cursor;
+        do {
+            const response = await sdkClient.listTools(cursor ? { cursor } : {});
+            allMcpTools.push(...response.tools);
+            cursor = response.nextCursor;
+        } while (cursor);
+        this._tools = allMcpTools.map((mcpTool) => this.wrapMcpTool(mcpTool));
+    }
+    /**
+     * Return all tools discovered from the MCP server as agention-lib Tool instances.
+     *
+     * Returns an empty array if {@link connect} has not been called yet.
+     * The returned tools can be passed directly to any agent via the `tools` config
+     * option or {@link BaseAgent.addTools}.
+     */
+    getTools() {
+        return this._tools;
+    }
+    /**
+     * Disconnect from the MCP server and release all resources.
+     *
+     * This method is idempotent — calling it when not connected is a no-op.
+     * After disconnecting, {@link getTools} returns an empty array.
+     */
+    async disconnect() {
+        if (!this.connected)
+            return;
+        try {
+            if (this.transportConfig.type === "http" && this.sdkTransport) {
+                await this.sdkTransport.terminateSession?.();
+            }
+            if (this.sdkClient) {
+                await this.sdkClient.close();
+            }
+        }
+        finally {
+            this.sdkClient = null;
+            this.sdkTransport = null;
+            this._tools = [];
+            this.connected = false;
+        }
+    }
+    wrapMcpTool(mcpTool) {
+        const inputSchema = {
+            type: "object",
+            properties: mcpTool.inputSchema?.properties ?? {},
+            required: mcpTool.inputSchema?.required,
+        };
+        return new Tool_1.Tool({
+            name: mcpTool.name,
+            description: mcpTool.description ?? mcpTool.name,
+            inputSchema,
+            execute: async (input) => {
+                if (!this.connected || !this.sdkClient) {
+                    throw new Error(`MCPClient: Cannot execute tool "${mcpTool.name}" — client is not connected`);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let result;
+                try {
+                    result = await this.sdkClient.callTool({
+                        name: mcpTool.name,
+                        arguments: input,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    throw new Error(`MCPClient: Tool "${mcpTool.name}" execution failed: ${message}`);
+                }
+                // Extract text content items from MCP result
+                if (result?.content && Array.isArray(result.content)) {
+                    const textItems = result.content
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        .filter((item) => item.type === "text")
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        .map((item) => item.text);
+                    if (textItems.length > 0) {
+                        return textItems.length === 1 ? textItems[0] : textItems.join("\n");
+                    }
+                }
+                // Fall back to structured content or full JSON serialization
+                if (result?.structuredContent !== undefined) {
+                    return result.structuredContent;
+                }
+                return JSON.stringify(result ?? null);
+            },
+        });
+    }
+}
+exports.MCPClient = MCPClient;
+//# sourceMappingURL=MCPClient.js.map

package/dist/mcp/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * MCP (Model Context Protocol) support for agention-lib.
+ *
+ * Connects to any MCP server — local stdio processes or remote HTTP endpoints —
+ * and exposes their tools as agention-lib {@link Tool} instances compatible with
+ * all agent types (ClaudeAgent, OpenAiAgent, MistralAgent, GeminiAgent).
+ *
+ * @requires @modelcontextprotocol/sdk - Optional peer dependency, install when needed:
+ * ```
+ * npm install @modelcontextprotocol/sdk
+ * ```
+ *
+ * @example Stdio (local process)
+ * ```typescript
+ * import { MCPClient, ClaudeAgent } from "@agentionai/agents";
+ *
+ * const mcp = MCPClient.fromStdio({
+ *   command: "npx",
+ *   args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
+ * });
+ *
+ * await mcp.connect();
+ *
+ * const agent = new ClaudeAgent({
+ *   id: "file-agent",
+ *   name: "File Agent",
+ *   description: "An agent that can work with files",
+ *   apiKey: process.env.ANTHROPIC_API_KEY!,
+ *   tools: mcp.getTools(),
+ * });
+ *
+ * const result = await agent.execute("List the files in /tmp");
+ * await mcp.disconnect();
+ * ```
+ *
+ * @example HTTP with static API key
+ * ```typescript
+ * import { MCPClient } from "@agentionai/agents";
+ *
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   headers: { Authorization: "Bearer my-api-key" },
+ * });
+ *
+ * await mcp.connect();
+ * agent.addTools(mcp.getTools());
+ * await mcp.disconnect();
+ * ```
+ *
+ * @example HTTP with OAuth
+ * ```typescript
+ * import { MCPClient } from "@agentionai/agents";
+ * import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+ *
+ * // Implement OAuthClientProvider from the MCP SDK
+ * const myOAuthProvider: OAuthClientProvider = { ... };
+ *
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   authProvider: myOAuthProvider,
+ * });
+ * ```
+ */
+export { MCPClient } from "./MCPClient";
+export type { MCPStdioConfig, MCPHttpConfig, MCPClientOptions } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * MCP (Model Context Protocol) support for agention-lib.
+ *
+ * Connects to any MCP server — local stdio processes or remote HTTP endpoints —
+ * and exposes their tools as agention-lib {@link Tool} instances compatible with
+ * all agent types (ClaudeAgent, OpenAiAgent, MistralAgent, GeminiAgent).
+ *
+ * @requires @modelcontextprotocol/sdk - Optional peer dependency, install when needed:
+ * ```
+ * npm install @modelcontextprotocol/sdk
+ * ```
+ *
+ * @example Stdio (local process)
+ * ```typescript
+ * import { MCPClient, ClaudeAgent } from "@agentionai/agents";
+ *
+ * const mcp = MCPClient.fromStdio({
+ *   command: "npx",
+ *   args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
+ * });
+ *
+ * await mcp.connect();
+ *
+ * const agent = new ClaudeAgent({
+ *   id: "file-agent",
+ *   name: "File Agent",
+ *   description: "An agent that can work with files",
+ *   apiKey: process.env.ANTHROPIC_API_KEY!,
+ *   tools: mcp.getTools(),
+ * });
+ *
+ * const result = await agent.execute("List the files in /tmp");
+ * await mcp.disconnect();
+ * ```
+ *
+ * @example HTTP with static API key
+ * ```typescript
+ * import { MCPClient } from "@agentionai/agents";
+ *
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   headers: { Authorization: "Bearer my-api-key" },
+ * });
+ *
+ * await mcp.connect();
+ * agent.addTools(mcp.getTools());
+ * await mcp.disconnect();
+ * ```
+ *
+ * @example HTTP with OAuth
+ * ```typescript
+ * import { MCPClient } from "@agentionai/agents";
+ * import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+ *
+ * // Implement OAuthClientProvider from the MCP SDK
+ * const myOAuthProvider: OAuthClientProvider = { ... };
+ *
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   authProvider: myOAuthProvider,
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPClient = void 0;
+var MCPClient_1 = require("./MCPClient");
+Object.defineProperty(exports, "MCPClient", { enumerable: true, get: function () { return MCPClient_1.MCPClient; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Configuration for connecting to an MCP server via stdio (local process).
+ */
+export interface MCPStdioConfig {
+    /** The command to spawn (e.g. "node", "python", "npx") */
+    command: string;
+    /** Arguments to pass to the command */
+    args?: string[];
+    /** Environment variables for the spawned process */
+    env?: Record<string, string>;
+}
+/**
+ * Configuration for connecting to an MCP server via HTTP (remote URL).
+ */
+export interface MCPHttpConfig {
+    /** Full URL to the MCP endpoint */
+    url: string;
+    /** Optional HTTP headers for static auth tokens or API keys */
+    headers?: Record<string, string>;
+    /**
+     * Optional OAuth provider for dynamic authorization.
+     * Implement the `OAuthClientProvider` interface from `@modelcontextprotocol/sdk`
+     * and pass it here for OAuth 2.0 + PKCE flows.
+     *
+     * @example
+     * ```typescript
+     * import { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+     *
+     * const mcp = MCPClient.fromUrl("https://my-server.com/mcp", {
+     *   authProvider: myOAuthProvider,
+     * });
+     * ```
+     */
+    authProvider?: unknown;
+}
+/**
+ * Options shared by all MCPClient connection types.
+ */
+export interface MCPClientOptions {
+    /**
+     * Name to identify this MCP client (sent during SDK handshake).
+     * @default "agention-mcp-client"
+     */
+    clientName?: string;
+    /**
+     * Version string for the MCP client.
+     * @default "1.0.0"
+     */
+    clientVersion?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/mcp/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -110,6 +110,7 @@
     "@google/generative-ai": "^0.24.1",
     "@lancedb/lancedb": "^0.23.0",
     "@mistralai/mistralai": "^1.13.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "apache-arrow": "^18.0.0",
     "openai": "^6.16.0",
     "voyageai": "^0.0.3"
@@ -130,6 +131,9 @@
     "@anthropic-ai/sdk": {
       "optional": true
     },
+    "@modelcontextprotocol/sdk": {
+      "optional": true
+    },
     "openai": {
       "optional": true
     },