@agentionai/agents 1.0.2 → 1.2.0

package/dist/mcp/content.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderContentBlock = renderContentBlock;
+exports.renderToolResult = renderToolResult;
+/**
+ * Format the decoded size of a base64 payload for display.
+ */
+function formatBase64Size(data) {
+    const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+    const bytes = Math.max(0, Math.floor((data.length * 3) / 4) - padding);
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Render a single MCP content block as text.
+ *
+ * Text blocks are returned verbatim. Binary blocks (image, audio, blob
+ * resources) cannot be represented as text, so they are rendered as a
+ * descriptive placeholder carrying their mime type and size — enough for a model
+ * to know the content exists and to ask for it another way. Text-bearing
+ * resources are inlined under a header naming their URI.
+ *
+ * Unrecognised block types — content types added to the protocol after this
+ * release — are serialised as JSON rather than dropped.
+ */
+function renderContentBlock(block) {
+    switch (block.type) {
+        case "text": {
+            return block.text ?? "";
+        }
+        case "image": {
+            const image = block;
+            return `[image content: ${image.mimeType ?? "unknown"}, ${formatBase64Size(image.data ?? "")}]`;
+        }
+        case "audio": {
+            const audio = block;
+            return `[audio content: ${audio.mimeType ?? "unknown"}, ${formatBase64Size(audio.data ?? "")}]`;
+        }
+        case "resource": {
+            const { resource } = block;
+            if (!resource)
+                return "[resource]";
+            const mime = resource.mimeType ? `, ${resource.mimeType}` : "";
+            if (typeof resource.text === "string") {
+                return `[resource: ${resource.uri}${mime}]\n${resource.text}`;
+            }
+            return `[resource: ${resource.uri}${mime}, ${formatBase64Size(resource.blob ?? "")}]`;
+        }
+        case "resource_link": {
+            const link = block;
+            const name = link.name ? ` (${link.name})` : "";
+            const description = link.description ? ` — ${link.description}` : "";
+            return `[resource link: ${link.uri}${name}${description}]`;
+        }
+        default: {
+            return `[${block.type} content: ${JSON.stringify(block)}]`;
+        }
+    }
+}
+/**
+ * Convert a raw MCP `CallToolResult` into the value handed to the agent.
+ *
+ * Resolution order:
+ * 1. When the result has content blocks, every block is rendered and the
+ *    segments are joined with newlines. `structuredContent` is appended as JSON
+ *    when the result carries no text block, so structured output is never lost
+ *    behind a binary-only result.
+ * 2. Otherwise `structuredContent` is returned as-is, so tools with an
+ *    `outputSchema` keep giving the agent a real object.
+ * 3. Otherwise the whole result is JSON-serialised.
+ */
+function renderToolResult(result) {
+    const blocks = Array.isArray(result?.content) ? result.content : [];
+    if (blocks.length > 0) {
+        const segments = blocks.map(renderContentBlock);
+        const hasText = blocks.some((block) => block.type === "text");
+        if (!hasText && result?.structuredContent !== undefined) {
+            segments.push(JSON.stringify(result.structuredContent));
+        }
+        return segments.join("\n");
+    }
+    if (result?.structuredContent !== undefined) {
+        return result.structuredContent;
+    }
+    return JSON.stringify(result ?? null);
+}
+//# sourceMappingURL=content.js.map

package/dist/mcp/errors.d.ts

@@ -0,0 +1,62 @@
+import type { MCPCallToolResult } from "./types";
+/**
+ * Base error class for all MCP-related errors.
+ */
+export declare class MCPError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a tool is executed while the client has no usable connection —
+ * either because {@link MCPClient.connect} was never called, or because the
+ * transport dropped and could not be restored.
+ */
+export declare class MCPNotConnectedError extends MCPError {
+    /** Name of the tool that was called. */
+    toolName: string;
+    /** Connection state at the time of the call. */
+    state: string;
+    constructor(message: string, 
+    /** Name of the tool that was called. */
+    toolName: string, 
+    /** Connection state at the time of the call. */
+    state: string);
+}
+/**
+ * Thrown when a `tools/call` request fails at the transport or protocol level —
+ * a timeout, an aborted signal, or an error raised by the MCP SDK.
+ *
+ * The originating error is kept on {@link MCPCallError.cause}, which is how a host
+ * tells a deliberate cancellation (`cause.name === "AbortError"`) apart from a
+ * server-side failure.
+ */
+export declare class MCPCallError extends MCPError {
+    /** Name of the tool that was called. */
+    toolName: string;
+    /** The underlying error thrown by the MCP SDK, or the abort reason. */
+    cause?: unknown | undefined;
+    constructor(message: string, 
+    /** Name of the tool that was called. */
+    toolName: string, 
+    /** The underlying error thrown by the MCP SDK, or the abort reason. */
+    cause?: unknown | undefined);
+}
+/**
+ * Thrown when an MCP server returns a result flagged with `isError: true`.
+ *
+ * This is a *tool-level* failure: the call itself succeeded at the protocol
+ * level, but the tool reported that it could not do its job. Agents catch it and
+ * pass the message back to the model as a failed tool result, which is what
+ * distinguishes it from a result the model would otherwise read as success.
+ */
+export declare class MCPToolError extends MCPError {
+    /** Name of the tool that reported the failure. */
+    toolName: string;
+    /** The raw `CallToolResult`, including any non-text content blocks. */
+    result: MCPCallToolResult;
+    constructor(message: string, 
+    /** Name of the tool that reported the failure. */
+    toolName: string, 
+    /** The raw `CallToolResult`, including any non-text content blocks. */
+    result: MCPCallToolResult);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/mcp/errors.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPToolError = exports.MCPCallError = exports.MCPNotConnectedError = exports.MCPError = void 0;
+/**
+ * Base error class for all MCP-related errors.
+ */
+class MCPError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MCPError";
+    }
+}
+exports.MCPError = MCPError;
+/**
+ * Thrown when a tool is executed while the client has no usable connection —
+ * either because {@link MCPClient.connect} was never called, or because the
+ * transport dropped and could not be restored.
+ */
+class MCPNotConnectedError extends MCPError {
+    constructor(message, 
+    /** Name of the tool that was called. */
+    toolName, 
+    /** Connection state at the time of the call. */
+    state) {
+        super(message);
+        this.toolName = toolName;
+        this.state = state;
+        this.name = "MCPNotConnectedError";
+    }
+}
+exports.MCPNotConnectedError = MCPNotConnectedError;
+/**
+ * Thrown when a `tools/call` request fails at the transport or protocol level —
+ * a timeout, an aborted signal, or an error raised by the MCP SDK.
+ *
+ * The originating error is kept on {@link MCPCallError.cause}, which is how a host
+ * tells a deliberate cancellation (`cause.name === "AbortError"`) apart from a
+ * server-side failure.
+ */
+class MCPCallError extends MCPError {
+    constructor(message, 
+    /** Name of the tool that was called. */
+    toolName, 
+    /** The underlying error thrown by the MCP SDK, or the abort reason. */
+    cause) {
+        super(message);
+        this.toolName = toolName;
+        this.cause = cause;
+        this.name = "MCPCallError";
+    }
+}
+exports.MCPCallError = MCPCallError;
+/**
+ * Thrown when an MCP server returns a result flagged with `isError: true`.
+ *
+ * This is a *tool-level* failure: the call itself succeeded at the protocol
+ * level, but the tool reported that it could not do its job. Agents catch it and
+ * pass the message back to the model as a failed tool result, which is what
+ * distinguishes it from a result the model would otherwise read as success.
+ */
+class MCPToolError extends MCPError {
+    constructor(message, 
+    /** Name of the tool that reported the failure. */
+    toolName, 
+    /** The raw `CallToolResult`, including any non-text content blocks. */
+    result) {
+        super(message);
+        this.toolName = toolName;
+        this.result = result;
+        this.name = "MCPToolError";
+    }
+}
+exports.MCPToolError = MCPToolError;
+//# sourceMappingURL=errors.js.map

package/dist/mcp/index.d.ts

@@ -58,7 +58,25 @@
  *   authProvider: myOAuthProvider,
  * });
  * ```
+ *
+ * @example Cancellation, timeouts and a connection that drops
+ * ```typescript
+ * import { MCPClient, MCPClientEvent } from "@agentionai/agents";
+ *
+ * const turn = new AbortController();
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   callOptions: () => ({ signal: turn.signal, timeout: 20_000 }),
+ *   reconnect: { enabled: true, maxRetries: 10 },
+ * });
+ *
+ * mcp.on(MCPClientEvent.DISCONNECTED, ({ willReconnect }) => {
+ *   console.warn("MCP connection lost", { willReconnect });
+ * });
+ * mcp.on(MCPClientEvent.TOOLS_CHANGED, ({ tools }) => agent.addTools(tools));
+ * ```
  */
-export { MCPClient } from "./MCPClient";
-export type { MCPStdioConfig, MCPHttpConfig, MCPClientOptions } from "./types";
+export { MCPClient, MCPClientEvent } from "./MCPClient";
+export { MCPError, MCPCallError, MCPNotConnectedError, MCPToolError } from "./errors";
+export { renderContentBlock, renderToolResult } from "./content";
+export type { MCPStdioConfig, MCPHttpConfig, MCPClientOptions, MCPOAuthClientProvider, MCPCallOptionsSource, MCPToolCallOptions, MCPToolCallContext, MCPToolResultFormatter, MCPReconnectOptions, MCPConnectionState, MCPProgress, MCPCallToolResult, MCPContentBlock, MCPTextContent, MCPImageContent, MCPAudioContent, MCPEmbeddedResourceContent, MCPResourceLinkContent, MCPClientEventMap, MCPConnectedEvent, MCPDisconnectedEvent, MCPReconnectingEvent, MCPToolsChangedEvent, } from "./types";
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -59,9 +59,34 @@
  *   authProvider: myOAuthProvider,
  * });
  * ```
+ *
+ * @example Cancellation, timeouts and a connection that drops
+ * ```typescript
+ * import { MCPClient, MCPClientEvent } from "@agentionai/agents";
+ *
+ * const turn = new AbortController();
+ * const mcp = MCPClient.fromUrl("https://my-mcp-server.com/mcp", {
+ *   callOptions: () => ({ signal: turn.signal, timeout: 20_000 }),
+ *   reconnect: { enabled: true, maxRetries: 10 },
+ * });
+ *
+ * mcp.on(MCPClientEvent.DISCONNECTED, ({ willReconnect }) => {
+ *   console.warn("MCP connection lost", { willReconnect });
+ * });
+ * mcp.on(MCPClientEvent.TOOLS_CHANGED, ({ tools }) => agent.addTools(tools));
+ * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPClient = void 0;
+exports.renderToolResult = exports.renderContentBlock = exports.MCPToolError = exports.MCPNotConnectedError = exports.MCPCallError = exports.MCPError = exports.MCPClientEvent = exports.MCPClient = void 0;
 var MCPClient_1 = require("./MCPClient");
 Object.defineProperty(exports, "MCPClient", { enumerable: true, get: function () { return MCPClient_1.MCPClient; } });
+Object.defineProperty(exports, "MCPClientEvent", { enumerable: true, get: function () { return MCPClient_1.MCPClientEvent; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "MCPError", { enumerable: true, get: function () { return errors_1.MCPError; } });
+Object.defineProperty(exports, "MCPCallError", { enumerable: true, get: function () { return errors_1.MCPCallError; } });
+Object.defineProperty(exports, "MCPNotConnectedError", { enumerable: true, get: function () { return errors_1.MCPNotConnectedError; } });
+Object.defineProperty(exports, "MCPToolError", { enumerable: true, get: function () { return errors_1.MCPToolError; } });
+var content_1 = require("./content");
+Object.defineProperty(exports, "renderContentBlock", { enumerable: true, get: function () { return content_1.renderContentBlock; } });
+Object.defineProperty(exports, "renderToolResult", { enumerable: true, get: function () { return content_1.renderToolResult; } });
 //# sourceMappingURL=index.js.map

package/dist/mcp/types.d.ts

@@ -1,3 +1,4 @@
+import type { Tool } from "../tools/Tool";
 /**
  * Configuration for connecting to an MCP server via stdio (local process).
  */
@@ -9,6 +10,44 @@ export interface MCPStdioConfig {
     /** Environment variables for the spawned process */
     env?: Record<string, string>;
 }
+/**
+ * Structural equivalent of the MCP SDK's `OAuthClientProvider`.
+ *
+ * `@modelcontextprotocol/sdk` is an optional peer dependency, so this type is
+ * declared here rather than imported: a type-only import would still have to be
+ * resolved by `tsc`, which would break the build of every consumer that does not
+ * install the SDK. TypeScript's structural typing means an SDK
+ * `OAuthClientProvider` satisfies this interface directly — `MCPClient.spec.ts`
+ * asserts that at compile time so drift in the SDK is caught by the test run.
+ *
+ * @example
+ * ```typescript
+ * import { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+ *
+ * const myOAuthProvider: OAuthClientProvider = { ... };
+ * const mcp = MCPClient.fromUrl("https://my-server.com/mcp", {
+ *   authProvider: myOAuthProvider,
+ * });
+ * ```
+ */
+export interface MCPOAuthClientProvider {
+    /** URL the user agent is redirected to after authorization. */
+    readonly redirectUrl: string | URL | undefined;
+    /** Metadata describing this OAuth client. */
+    readonly clientMetadata: any;
+    /** Loads previously registered client information, if any. */
+    clientInformation(): any;
+    /** Loads the OAuth tokens for the current session, if any. */
+    tokens(): any;
+    /** Persists new OAuth tokens after a successful authorization. */
+    saveTokens(tokens: any): void | Promise<void>;
+    /** Redirects the user agent to begin the authorization flow. */
+    redirectToAuthorization(authorizationUrl: URL): void | Promise<void>;
+    /** Persists the PKCE code verifier for the current session. */
+    saveCodeVerifier(codeVerifier: string): void | Promise<void>;
+    /** Loads the PKCE code verifier for the current session. */
+    codeVerifier(): string | Promise<string>;
+}
 /**
  * Configuration for connecting to an MCP server via HTTP (remote URL).
  */
@@ -19,19 +58,165 @@ export interface MCPHttpConfig {
     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.
+     * Pass an `OAuthClientProvider` from `@modelcontextprotocol/sdk/client/auth.js`
+     * 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,
-     * });
-     * ```
+     * @see {@link MCPOAuthClientProvider}
+     */
+    authProvider?: MCPOAuthClientProvider;
+}
+/**
+ * Progress notification emitted by an MCP server during a long-running tool call.
+ */
+export interface MCPProgress {
+    /** Amount of work completed so far. */
+    progress: number;
+    /** Total amount of work, when the server knows it. */
+    total?: number;
+    /** Human-readable description of the current step. */
+    message?: string;
+}
+/**
+ * Per-request options forwarded to the MCP SDK's `Client.callTool()`.
+ *
+ * These map one-to-one onto the SDK's `RequestOptions`.
+ */
+export interface MCPToolCallOptions {
+    /**
+     * Cancels the in-flight call. The tool rejects with an abort error as soon as
+     * the signal fires, which lets a host interrupt an agent turn that is blocked
+     * on a hung server.
+     */
+    signal?: AbortSignal;
+    /**
+     * Timeout in milliseconds for this call.
+     * @default 60000 (the MCP SDK's `DEFAULT_REQUEST_TIMEOUT_MSEC`)
+     */
+    timeout?: number;
+    /** Reset the timeout every time a progress notification arrives. */
+    resetTimeoutOnProgress?: boolean;
+    /** Hard ceiling in milliseconds, regardless of progress notifications. */
+    maxTotalTimeout?: number;
+    /** Invoked for each progress notification the server sends. */
+    onprogress?: (progress: MCPProgress) => void;
+}
+/**
+ * Identifies the call that options or a formatter are being resolved for.
+ */
+export interface MCPToolCallContext {
+    /** Name of the MCP tool being called. */
+    toolName: string;
+    /** Arguments the agent passed to the tool. */
+    input: Record<string, unknown>;
+}
+/**
+ * Default call options for an {@link MCPClient} — either a fixed object or a
+ * function resolved fresh on every call.
+ *
+ * The function form is the one to reach for when the signal changes per agent
+ * turn: return the current turn's `AbortController.signal` and every subsequent
+ * tool call picks it up.
+ */
+export type MCPCallOptionsSource = MCPToolCallOptions | ((context: MCPToolCallContext) => MCPToolCallOptions | undefined);
+/** A text block in an MCP tool result. */
+export interface MCPTextContent {
+    type: "text";
+    text: string;
+}
+/** An image block in an MCP tool result. `data` is base64-encoded. */
+export interface MCPImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+/** An audio block in an MCP tool result. `data` is base64-encoded. */
+export interface MCPAudioContent {
+    type: "audio";
+    data: string;
+    mimeType: string;
+}
+/** A resource embedded directly in an MCP tool result. */
+export interface MCPEmbeddedResourceContent {
+    type: "resource";
+    resource: {
+        uri: string;
+        mimeType?: string;
+        /** Present for text resources. */
+        text?: string;
+        /** Present for binary resources, base64-encoded. */
+        blob?: string;
+    };
+}
+/** A reference to a resource the client can read separately. */
+export interface MCPResourceLinkContent {
+    type: "resource_link";
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+}
+/**
+ * A single block of an MCP tool result. The open-ended member keeps forward
+ * compatibility with content types added to the protocol later.
+ */
+export type MCPContentBlock = MCPTextContent | MCPImageContent | MCPAudioContent | MCPEmbeddedResourceContent | MCPResourceLinkContent | {
+    type: string;
+    [key: string]: unknown;
+};
+/**
+ * The raw `CallToolResult` returned by an MCP server.
+ */
+export interface MCPCallToolResult {
+    /** Content blocks produced by the tool. */
+    content?: MCPContentBlock[];
+    /** Structured output, when the tool declares an `outputSchema`. */
+    structuredContent?: Record<string, unknown>;
+    /** Set by the server when the tool itself failed. */
+    isError?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Converts a raw MCP tool result into the value the agent receives.
+ *
+ * Supply one to take full control of how results reach the model — for example
+ * to turn image blocks into multimodal content instead of text placeholders.
+ * Returning from the formatter suppresses the built-in rendering entirely;
+ * throwing surfaces as a tool error.
+ */
+export type MCPToolResultFormatter = (result: MCPCallToolResult, context: MCPToolCallContext) => unknown;
+/**
+ * Automatic reconnection behaviour for a dropped transport.
+ */
+export interface MCPReconnectOptions {
+    /**
+     * Reconnect automatically when the transport closes unexpectedly.
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Maximum number of consecutive reconnect attempts before giving up.
+     * Pass `Infinity` to retry forever.
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Delay before the first retry, in milliseconds. Subsequent delays grow by
+     * {@link MCPReconnectOptions.backoffFactor} up to
+     * {@link MCPReconnectOptions.maxDelayMs}.
+     * @default 500
+     */
+    initialDelayMs?: number;
+    /**
+     * Upper bound for the backoff delay, in milliseconds.
+     * @default 30000
      */
-    authProvider?: unknown;
+    maxDelayMs?: number;
+    /**
+     * Multiplier applied to the delay after each failed attempt.
+     * @default 2
+     */
+    backoffFactor?: number;
 }
 /**
  * Options shared by all MCPClient connection types.
@@ -47,5 +232,87 @@ export interface MCPClientOptions {
      * @default "1.0.0"
      */
     clientVersion?: string;
+    /**
+     * Default options applied to every tool call — most importantly `signal` and
+     * `timeout`. Pass a function to resolve them per call.
+     *
+     * @see {@link MCPClient.setCallOptions} to change them after construction.
+     */
+    callOptions?: MCPCallOptionsSource;
+    /**
+     * Throw when a server marks a result with `isError: true`.
+     *
+     * Agents catch tool errors and hand the message back to the model as a failed
+     * tool result, so leaving this on means a tool-level failure is never mistaken
+     * for a successful one. Set to `false` to receive the rendered error content
+     * as an ordinary return value instead.
+     *
+     * @default true
+     */
+    throwOnToolError?: boolean;
+    /**
+     * Override how a raw MCP result is converted into the agent-visible value.
+     */
+    formatResult?: MCPToolResultFormatter;
+    /**
+     * Automatic reconnection after an unexpected transport close.
+     * @default { enabled: false }
+     */
+    reconnect?: MCPReconnectOptions;
+    /**
+     * Re-run tool discovery when the server sends `notifications/tools/list_changed`.
+     * @default true
+     */
+    refreshToolsOnListChanged?: boolean;
+}
+/**
+ * Lifecycle state of an {@link MCPClient}'s connection.
+ *
+ * - `disconnected` — never connected, or disconnected on purpose
+ * - `connecting` — {@link MCPClient.connect} is in flight
+ * - `connected` — usable
+ * - `reconnecting` — the transport dropped and a retry is scheduled or running
+ * - `failed` — the transport dropped and reconnection gave up
+ */
+export type MCPConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting" | "failed";
+/** Payload of {@link MCPClientEvent.CONNECTED}. */
+export interface MCPConnectedEvent {
+    tools: Tool<unknown>[];
+}
+/** Payload of {@link MCPClientEvent.DISCONNECTED}. */
+export interface MCPDisconnectedEvent {
+    /** The transport error, when the close was caused by one. */
+    error?: Error;
+    /** `true` when the close was requested via {@link MCPClient.disconnect}. */
+    deliberate: boolean;
+    /** `true` when a reconnect attempt has been scheduled. */
+    willReconnect: boolean;
+}
+/** Payload of {@link MCPClientEvent.RECONNECTING}. */
+export interface MCPReconnectingEvent {
+    /** 1-based attempt counter. */
+    attempt: number;
+    /** Delay waited before this attempt, in milliseconds. */
+    delayMs: number;
+}
+/** Payload of {@link MCPClientEvent.TOOLS_CHANGED}. */
+export interface MCPToolsChangedEvent {
+    /** The full, current tool list. */
+    tools: Tool<unknown>[];
+    /** Names present now that were not present before. */
+    added: string[];
+    /** Names present before that are gone now. */
+    removed: string[];
+}
+/**
+ * Maps each {@link MCPClientEvent} name to its listener payload.
+ */
+export interface MCPClientEventMap {
+    connected: MCPConnectedEvent;
+    disconnected: MCPDisconnectedEvent;
+    reconnecting: MCPReconnectingEvent;
+    reconnected: MCPConnectedEvent;
+    toolsChanged: MCPToolsChangedEvent;
+    error: Error;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -113,6 +113,7 @@
     "@google/generative-ai": "^0.24.1",
     "@lancedb/lancedb": "^0.23.0",
     "@mistralai/mistralai": "^1.13.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
     "apache-arrow": "^18.1.0",