@mcp-use/client 2.2.4 → 2.2.5

package/dist/code-mode/executor.d.ts

@@ -0,0 +1,81 @@
+import type { Tool } from "@modelcontextprotocol/client";
+import type { CodeExecutorFunction, MCPClient } from "../core/node.js";
+export interface ExecutionResult {
+    result: unknown;
+    logs: string[];
+    error: string | null;
+    execution_time: number;
+}
+interface ToolSearchResult {
+    name: string;
+    server: string;
+    description?: string;
+    input_schema?: Tool["inputSchema"];
+}
+interface ToolSearchMeta {
+    total_tools: number;
+    namespaces: string[];
+    result_count: number;
+}
+export interface ToolSearchResponse {
+    meta: ToolSearchMeta;
+    results: ToolSearchResult[];
+}
+type SearchToolsFunction = (query?: string, detailLevel?: "names" | "descriptions" | "full") => Promise<ToolSearchResponse>;
+interface ToolNamespaceInfo {
+    serverName: string;
+    tools: Tool[];
+    session: any;
+}
+/**
+ * Abstract base class for code executors.
+ * Provides shared functionality for connecting to MCP servers and building tool contexts.
+ */
+export declare abstract class BaseCodeExecutor {
+    protected client: MCPClient;
+    protected _connecting: boolean;
+    constructor(client: MCPClient);
+    /**
+     * Execute code with access to MCP tools.
+     * @param code - The code to execute
+     * @param timeout - Execution timeout in milliseconds
+     */
+    abstract execute(code: string, timeout?: number): Promise<ExecutionResult>;
+    /**
+     * Clean up resources used by the executor.
+     * Should be called when the executor is no longer needed.
+     */
+    abstract cleanup(): Promise<void>;
+    /**
+     * Ensure all configured MCP servers are connected before execution.
+     * Prevents race conditions with a connection lock.
+     */
+    protected ensureServersConnected(): Promise<void>;
+    /**
+     * Get tool namespace information from all active MCP sessions.
+     * Filters out the internal code_mode server.
+     */
+    protected getToolNamespaces(): ToolNamespaceInfo[];
+    /**
+     * Create a search function for discovering available MCP tools.
+     * Used by code execution environments to find tools at runtime.
+     */
+    createSearchToolsFunction(): SearchToolsFunction;
+}
+/**
+ * Adapts a plain `(code, timeout) => Promise<ExecutionResult>` function to the
+ * {@link BaseCodeExecutor} interface so a custom executor participates in the
+ * normal executor lifecycle (`searchTools`, `close()` cleanup).
+ *
+ * The function is invoked with the `MCPClient` as its `this`, matching how a
+ * custom executor was called before this adapter existed. Cleanup is a no-op:
+ * the caller owns whatever runtime the function wraps.
+ */
+export declare class FunctionCodeExecutor extends BaseCodeExecutor {
+    private fn;
+    constructor(client: MCPClient, fn: CodeExecutorFunction);
+    execute(code: string, timeout?: number): Promise<ExecutionResult>;
+    cleanup(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=executor.d.ts.map

package/dist/code-mode/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/code-mode/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGvE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;CACpC;AAED,UAAU,cAAc;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED,KAAK,mBAAmB,GAAG,CACzB,KAAK,CAAC,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,KAC5C,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,UAAU,iBAAiB;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,OAAO,EAAE,GAAG,CAAC;CACd;AAED;;;GAGG;AACH,8BAAsB,gBAAgB;IACpC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC;IAC5B,SAAS,CAAC,WAAW,EAAE,OAAO,CAAS;gBAE3B,MAAM,EAAE,SAAS;IAI7B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAE1E;;;OAGG;IACH,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAEjC;;;OAGG;cACa,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BvD;;;OAGG;IACH,SAAS,CAAC,iBAAiB,IAAI,iBAAiB,EAAE;IA6BlD;;;OAGG;IACI,yBAAyB,IAAI,mBAAmB;CAoExD;AAED;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;IACxD,OAAO,CAAC,EAAE,CAAuB;gBAErB,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,oBAAoB;IAKjD,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAIjE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/core/base.d.ts

@@ -0,0 +1,423 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/client";
+import type { BaseConnector } from "../transport/base.js";
+import type { AutoOAuthOptions, MCPClientConfigShape, ServerConfig } from "./config.js";
+import { MCPSession } from "./session.js";
+import type { MCPConnection } from "./session.js";
+/**
+ * Base MCPClient class with shared functionality across all environments.
+ *
+ * This abstract class provides the core client logic for managing MCP servers,
+ * sessions, and configurations. It works in both Node.js and browser environments
+ * by delegating platform-specific operations to concrete implementations.
+ *
+ * Platform-specific implementations such as the Node.js `MCPClient` should
+ * extend this class and override the abstract {@link createConnectorFromConfig}
+ * method to provide environment-specific connector creation.
+ *
+ * @example
+ * ```typescript
+ * // Typically used through concrete implementations
+ * import { MCPClient } from "@mcp-use/client";
+ *
+ * const client = new MCPClient({
+ *   mcpServers: {
+ *     'my-server': {
+ *       command: 'node',
+ *       args: ['server.js']
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link MCPSession} for session management
+ */
+export declare abstract class BaseMCPClient {
+    /**
+     * Internal configuration object containing MCP server definitions.
+     */
+    protected config: MCPClientConfigShape;
+    /**
+     * Map of server names to their active sessions.
+     */
+    protected sessions: Record<string, MCPSession>;
+    /**
+     * Tracks teardown by session identity so overlapping cleanup paths share the
+     * same disconnect. In particular, createSession() can replace a session while
+     * closeSession() is already disconnecting it.
+     */
+    private readonly sessionDisconnects;
+    /**
+     * List of server names that have active sessions.
+     * This array is kept in sync with the sessions map and can be used
+     * to iterate over active connections.
+     *
+     * @example
+     * ```typescript
+     * console.log(`Active servers: ${client.activeSessions.join(', ')}`);
+     * ```
+     */
+    activeSessions: string[];
+    /**
+     * Creates a new BaseMCPClient instance.
+     *
+     * @param config - Optional configuration object with MCP server definitions
+     *
+     * @example
+     * ```typescript
+     * const client = new MCPClient({
+     *   mcpServers: {
+     *     'example': {
+     *       command: 'node',
+     *       args: ['server.js']
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    constructor(config?: MCPClientConfigShape);
+    private disconnectSession;
+    /**
+     * Creates a client instance from a configuration dictionary.
+     *
+     * This static factory method must be implemented by concrete subclasses
+     * to provide proper type information and platform-specific initialization.
+     *
+     * @param _cfg - Configuration dictionary
+     * @returns Client instance
+     * @throws If called on the base class instead of a concrete implementation
+     *
+     * @example
+     * ```typescript
+     * const client = MCPClient.fromDict({
+     *   mcpServers: {
+     *     'my-server': { command: 'node', args: ['server.js'] }
+     *   }
+     * });
+     * ```
+     */
+    static fromDict(_cfg: MCPClientConfigShape): BaseMCPClient;
+    /**
+     * Adds a new MCP server configuration to the client.
+     *
+     * This method adds or updates a server configuration dynamically without
+     * needing to restart the client. The server can then be used to create
+     * new sessions.
+     *
+     * @param name - Unique name for the server
+     * @param serverConfig - Server configuration object (connector type, command, args, etc.)
+     *
+     * @example
+     * ```typescript
+     * client.addServer('new-server', {
+     *   command: 'python',
+     *   args: ['server.py']
+     * });
+     *
+     * // Now you can create a session
+     * const session = await client.createSession('new-server');
+     * ```
+     *
+     * @see {@link removeServer} for removing servers
+     * @see {@link getServerConfig} for retrieving configurations
+     */
+    addServer(name: string, serverConfig: ServerConfig): void;
+    /**
+     * Removes an MCP server configuration from the client.
+     *
+     * This method removes a server configuration and cleans up any active
+     * sessions associated with that server. If there's an active session,
+     * it will be removed from the active sessions list.
+     *
+     * @param name - Name of the server to remove
+     *
+     * @example
+     * ```typescript
+     * // Remove a server configuration
+     * await client.removeServer('old-server');
+     *
+     * // The server name will no longer appear in getServerNames()
+     * console.log(client.getServerNames()); // 'old-server' is gone
+     * ```
+     *
+     * @see {@link addServer} for adding servers
+     * @see {@link closeSession} for properly closing sessions before removal
+     */
+    removeServer(name: string): Promise<void>;
+    /**
+     * Gets the names of all configured MCP servers.
+     *
+     * @returns Array of server names defined in the configuration
+     *
+     * @example
+     * ```typescript
+     * const serverNames = client.getServerNames();
+     * console.log(`Configured servers: ${serverNames.join(', ')}`);
+     *
+     * // Create sessions for all servers
+     * for (const name of serverNames) {
+     *   await client.createSession(name);
+     * }
+     * ```
+     *
+     * @see {@link activeSessions} for servers with active sessions
+     */
+    getServerNames(): string[];
+    /**
+     * Gets the configuration for a specific MCP server.
+     *
+     * @param name - Name of the server
+     * @returns Server configuration object, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const config = client.getServerConfig('my-server');
+     * if (config) {
+     *   console.log(`Command: ${config.command}`);
+     *   console.log(`Args: ${config.args.join(' ')}`);
+     * }
+     * ```
+     *
+     * @see {@link getConfig} for retrieving the entire configuration
+     */
+    getServerConfig(name: string): ServerConfig | undefined;
+    /**
+     * Gets the complete client configuration.
+     *
+     * @returns Complete configuration object including all server definitions
+     *
+     * @example
+     * ```typescript
+     * const config = client.getConfig();
+     * console.log(`Total servers: ${Object.keys(config.mcpServers).length}`);
+     * ```
+     *
+     * @see {@link getServerConfig} for retrieving individual server configurations
+     */
+    getConfig(): MCPClientConfigShape;
+    /**
+     * Creates a connector from server configuration.
+     *
+     * This abstract method must be implemented by platform-specific subclasses
+     * to create the appropriate connector type (Stdio, HTTP, WebSocket, etc.)
+     * based on the server configuration and runtime environment.
+     *
+     * @param serverConfig - Server configuration object
+     * @returns Platform-specific connector instance
+     */
+    protected abstract createConnectorFromConfig(serverConfig: ServerConfig): BaseConnector | Promise<BaseConnector>;
+    /**
+     * Platform OAuth provider used when an HTTP server has no bearer token /
+     * `authProvider`. Node and browser entries implement this via their
+     * `createOAuthProvider` export.
+     */
+    protected abstract createDefaultOAuthProvider(serverUrl: string, options?: AutoOAuthOptions): Promise<OAuthClientProvider>;
+    /**
+     * Creates a new session for connecting to an MCP server.
+     *
+     * @deprecated Use {@link connect}; modern MCP servers are sessionless.
+     *
+     * This method initializes a connection to the specified server using the
+     * configuration provided during client construction. Sessions manage the
+     * lifecycle of connections and provide methods for calling tools, listing
+     * resources, and more.
+     *
+     * If a session already exists for the server, it will be replaced with a new
+     * one and the previous session is disconnected; any previously returned
+     * reference to it becomes unusable.
+     *
+     * @param serverName - The name of the server as defined in the client configuration
+     * @param autoInitialize - Whether to automatically initialize the session (default: true)
+     * @returns A promise that resolves to the created MCPSession instance
+     * @throws If the server is not found in the configuration
+     *
+     * @example
+     * ```typescript
+     * // Create and initialize a session
+     * const session = await client.createSession('my-server');
+     * const tools = await session.listTools();
+     *
+     * // Create without auto-initialization
+     * const session = await client.createSession('my-server', false);
+     * await session.connect();
+     * await session.initialize();
+     * ```
+     *
+     * @see {@link MCPSession} for session management methods
+     * @see {@link closeSession} for closing sessions
+     * @see {@link getSession} for retrieving existing sessions
+     */
+    createSession(serverName: string, autoInitialize?: boolean): Promise<MCPSession>;
+    /**
+     * Connect to a configured MCP server and return a ready, protocol-neutral
+     * connection.
+     *
+     * The returned connection represents either a legacy sessionful server or a
+     * modern sessionless server uniformly. Inspect {@link MCPConnection.info} for
+     * the negotiated protocol version and normalized server metadata.
+     *
+     * @param serverName - The configured server name.
+     */
+    connect(serverName: string): Promise<MCPConnection>;
+    /**
+     * Creates sessions for all configured MCP servers.
+     *
+     * This is a convenience method that iterates through all servers in the
+     * configuration and creates a session for each one. Sessions are created
+     * sequentially to avoid overwhelming the system.
+     *
+     * @param autoInitialize - Whether to automatically initialize each session (default: true)
+     * @returns A promise that resolves to a map of server names to sessions
+     *
+     * @example
+     * ```typescript
+     * // Create sessions for all configured servers
+     * const sessions = await client.createAllSessions();
+     * console.log(`Created ${Object.keys(sessions).length} sessions`);
+     *
+     * // List tools from all servers
+     * for (const [name, session] of Object.entries(sessions)) {
+     *   const tools = await session.listTools();
+     *   console.log(`${name}: ${tools.length} tools`);
+     * }
+     * ```
+     *
+     * @see {@link createSession} for creating individual sessions
+     * @see {@link closeAllSessions} for closing all sessions
+     */
+    createAllSessions(autoInitialize?: boolean): Promise<Record<string, MCPSession>>;
+    /**
+     * Connect to every configured server sequentially.
+     *
+     * Each result uses the same {@link MCPConnection} API regardless of whether
+     * the negotiated protocol is legacy/sessionful or modern/sessionless.
+     */
+    connectAll(): Promise<Record<string, MCPConnection>>;
+    /**
+     * Retrieves an existing session by server name.
+     *
+     * This method returns null if no session exists, making it safe for
+     * checking session existence without throwing errors.
+     *
+     * @param serverName - Name of the server
+     * @returns The session instance or null if not found
+     *
+     * @example
+     * ```typescript
+     * const session = client.getSession('my-server');
+     * if (session) {
+     *   const tools = await session.listTools();
+     * } else {
+     *   console.log('Session not found, creating...');
+     *   await client.createSession('my-server');
+     * }
+     * ```
+     *
+     * @see {@link requireSession} for getting a session that throws if not found
+     * @see {@link createSession} for creating sessions
+     */
+    getSession(serverName: string): MCPSession | null;
+    /**
+     * Retrieves an existing session by server name, throwing if not found.
+     *
+     * This method is useful when you need to ensure a session exists before
+     * proceeding. It throws a descriptive error if the session is not found.
+     *
+     * @param serverName - Name of the server
+     * @returns The session instance
+     * @throws If the session is not found
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const session = client.requireSession('my-server');
+     *   const tools = await session.listTools();
+     * } catch (error) {
+     *   console.error('Session not found:', error.message);
+     * }
+     * ```
+     *
+     * @see {@link getSession} for a null-returning alternative
+     * @see {@link createSession} for creating sessions
+     */
+    requireSession(serverName: string): MCPSession;
+    /**
+     * Gets all active sessions as a map of server names to sessions.
+     *
+     * @returns Map of server names to their active sessions
+     *
+     * @example
+     * ```typescript
+     * const sessions = client.getAllActiveSessions();
+     *
+     * // Iterate over all active sessions
+     * for (const [name, session] of Object.entries(sessions)) {
+     *   console.log(`Server: ${name}`);
+     *   const tools = await session.listTools();
+     *   console.log(`  Tools: ${tools.length}`);
+     * }
+     * ```
+     *
+     * @see {@link activeSessions} for just the list of server names
+     * @see {@link getSession} for retrieving individual sessions
+     */
+    getAllActiveSessions(): Record<string, MCPSession>;
+    /**
+     * Closes a session and cleans up its resources.
+     *
+     * This method gracefully disconnects from the server and removes the
+     * session from the active sessions list. It's safe to call even if
+     * the session doesn't exist.
+     *
+     * @param serverName - Name of the server whose session should be closed
+     *
+     * @example
+     * ```typescript
+     * // Close a specific session
+     * await client.closeSession('my-server');
+     *
+     * // Verify it's closed
+     * console.log(client.activeSessions.includes('my-server')); // false
+     * ```
+     *
+     * @see {@link closeAllSessions} for closing all sessions at once
+     * @see {@link createSession} for creating new sessions
+     */
+    closeSession(serverName: string): Promise<void>;
+    /**
+     * Closes all active sessions and cleans up their resources.
+     *
+     * This method iterates through all sessions and attempts to close each one
+     * gracefully. If any session fails to close, the error is logged but the
+     * method continues to close remaining sessions.
+     *
+     * This is particularly useful for cleanup on application shutdown.
+     *
+     * @example
+     * ```typescript
+     * // Clean shutdown
+     * try {
+     *   await client.closeAllSessions();
+     *   console.log('All sessions closed successfully');
+     * } catch (error) {
+     *   console.error('Error during cleanup:', error);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Use in application shutdown handler
+     * process.on('SIGINT', async () => {
+     *   console.log('Shutting down...');
+     *   await client.closeAllSessions();
+     *   process.exit(0);
+     * });
+     * ```
+     *
+     * @see {@link closeSession} for closing individual sessions
+     * @see {@link createAllSessions} for creating sessions
+     */
+    closeAllSessions(): Promise<void>;
+    /** Close every active MCP connection. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/core/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/core/base.ts"],"names":[],"mappings":"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"}

package/dist/core/browser.d.ts

@@ -0,0 +1,32 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/client";
+import type { AutoOAuthOptions } from "./config.js";
+import type { BaseConnector } from "../transport/base.js";
+import { BaseMCPClient } from "./base.js";
+export declare class BrowserMCPClient extends BaseMCPClient {
+    /**
+     * Returns the installed `@mcp-use/client` package version.
+     *
+     * @returns The package version string.
+     */
+    static getPackageVersion(): string;
+    /**
+     * Creates a browser MCP client.
+     *
+     * @param config - Client configuration containing an optional `mcpServers` map.
+     */
+    constructor(config?: Record<string, any>);
+    /**
+     * Creates a browser client from an inline configuration object.
+     *
+     * @param cfg - Client configuration containing an optional `mcpServers` map.
+     * @returns A browser client initialized with `cfg`.
+     */
+    static fromDict(cfg: Record<string, any>): BrowserMCPClient;
+    protected createDefaultOAuthProvider(serverUrl: string, options?: AutoOAuthOptions): Promise<OAuthClientProvider>;
+    /**
+     * Create a connector from server configuration (Browser version)
+     * Supports HTTP connector only
+     */
+    protected createConnectorFromConfig(serverConfig: Record<string, any>): BaseConnector;
+}
+//# sourceMappingURL=browser.d.ts.map

package/dist/core/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/core/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,aAAa,CAAC;AAEpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAS1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AA0B1C,qBAAa,gBAAiB,SAAQ,aAAa;IACjD;;;;OAIG;WACW,iBAAiB,IAAI,MAAM;IAIzC;;;;OAIG;gBACS,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAKxC;;;;;OAKG;WACW,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,gBAAgB;cAIlD,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,mBAAmB,CAAC;IAI/B;;;OAGG;IACH,SAAS,CAAC,yBAAyB,CACjC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,aAAa;CA2DjB"}