@agentionai/agents 0.6.0 → 0.7.0

package/dist/agents/AgentConfig.d.ts

@@ -6,24 +6,43 @@ export type AgentVendor = "openai" | "anthropic" | "mistral" | "gemini";
  * Common configuration shared by all agents
  */
 export interface CommonAgentConfig {
+    /** Unique identifier for the agent instance */
     id: string;
+    /** Human-readable name for the agent */
     name: string;
+    /** Description of the agent's purpose and capabilities */
     description: string;
+    /** API key for authenticating with the LLM provider */
     apiKey: string;
+    /** Enable debug logging for troubleshooting (default: false) */
     debug?: boolean;
+    /** Maximum number of messages to retain in conversation history */
     maxHistoryLength?: number;
+    /** Model identifier (e.g., "claude-3-5-sonnet-20241022", "gpt-4") */
     model?: string;
+    /** Array of tools the agent can use during execution */
     tools?: Tool<unknown>[];
+    /** Array of sub-agents this agent can delegate tasks to */
     agents?: BaseAgent[];
+    /** Maximum number of tokens to generate in the response */
     maxTokens?: number;
+    /** Sampling temperature (0.0-1.0). Higher values increase randomness */
     temperature?: number;
+    /** Nucleus sampling threshold (0.0-1.0). Considers tokens with top cumulative probability */
     topP?: number;
+    /** Top-K sampling. Only considers the K most likely tokens (Anthropic, Gemini) */
     topK?: number;
+    /** Sequences that will stop generation when encountered */
     stopSequences?: string[];
+    /** Request timeout in milliseconds */
     timeout?: number;
+    /** Maximum number of retry attempts on API failures */
     maxRetries?: number;
+    /** Random seed for deterministic outputs (when supported by vendor) */
     seed?: number;
+    /** Penalty for using tokens that already appear in the text (-2.0 to 2.0) */
     presencePenalty?: number;
+    /** Penalty based on token frequency in the text (-2.0 to 2.0) */
     frequencyPenalty?: number;
 }
 /**

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/embeddings/VoyageAIEmbeddings.js

@@ -103,6 +103,7 @@ class VoyageAIEmbeddings extends Embeddings_1.Embeddings {
             return [];
         }
         // Dynamic import to keep voyageai optional at module load time
+        // @ts-ignore - voyageai is an optional peer dependency
         const { VoyageAIClient } = await Promise.resolve().then(() => __importStar(require("voyageai")));
         const client = new VoyageAIClient({
             apiKey: this.apiKey,

package/dist/history/History.js

@@ -62,6 +62,9 @@ class History extends events_1.default {
             ...entry,
             __metadata,
         });
+        if (this.options.maxLength && this._entries.length > this.options.maxLength) {
+            this._entries = this._entries.slice(this._entries.length - this.options.maxLength);
+        }
         this.emit("entry", entry);
     }
     /**

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.0",
+  "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
     },