@agentionai/agents 0.6.1 → 0.8.0

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