mcp-use 1.34.2 → 1.34.3

package/dist/chunk-NQYSWKWJ.js

@@ -0,0 +1,2609 @@
+import {
+  ConnectionManager
+} from "./chunk-GKPKUKD6.js";
+import {
+  CodeModeConnector
+} from "./chunk-J67NWN5H.js";
+import {
+  BaseConnector
+} from "./chunk-PSD6ATRG.js";
+import {
+  Tel,
+  getPackageVersion
+} from "./chunk-BJIP3NFE.js";
+import {
+  JSONSchemaToZod
+} from "./chunk-LG5NSHEL.js";
+import {
+  logger
+} from "./chunk-QWQYAQCK.js";
+import {
+  __name,
+  __require
+} from "./chunk-3GQAWCBQ.js";
+
+// src/client.ts
+import fs from "fs";
+import path from "path";
+
+// src/session.ts
+var MCPSession = class {
+  static {
+    __name(this, "MCPSession");
+  }
+  /**
+   * The underlying connector managing the transport layer.
+   * This is the Stdio, HTTP, or WebSocket connector handling actual communication.
+   */
+  connector;
+  /**
+   * Whether to automatically connect when initializing.
+   * @internal
+   */
+  autoConnect;
+  /**
+   * Creates a new MCP session.
+   *
+   * @param connector - The connector to use for communication (Stdio, HTTP, WebSocket)
+   * @param autoConnect - Whether to automatically connect during initialization (default: true)
+   *
+   * @example
+   * ```typescript
+   * const connector = new HttpConnector({ url: 'http://localhost:3000/mcp' });
+   * const session = new MCPSession(connector);
+   * await session.initialize(); // Auto-connects and initializes
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Manual connection control
+   * const session = new MCPSession(connector, false);
+   * await session.connect();
+   * await session.initialize();
+   * ```
+   */
+  constructor(connector, autoConnect = true) {
+    this.connector = connector;
+    this.autoConnect = autoConnect;
+  }
+  /**
+   * Establishes the connection to the MCP server.
+   *
+   * This method starts the underlying transport (spawns process for Stdio,
+   * opens WebSocket, etc.) but does not perform the MCP initialization
+   * handshake. Call {@link initialize} after connecting.
+   *
+   * @returns Promise that resolves when connected
+   *
+   * @example
+   * ```typescript
+   * await session.connect();
+   * await session.initialize();
+   * ```
+   *
+   * @see {@link initialize} for performing the MCP handshake
+   * @see {@link disconnect} for closing the connection
+   */
+  async connect() {
+    await this.connector.connect();
+  }
+  /**
+   * Closes the connection to the MCP server.
+   *
+   * This method gracefully shuts down the transport and cleans up resources.
+   * After disconnecting, the session cannot be used until reconnected.
+   *
+   * @returns Promise that resolves when disconnected
+   *
+   * @example
+   * ```typescript
+   * await session.disconnect();
+   * console.log('Session closed');
+   * ```
+   *
+   * @see {@link connect} for establishing connections
+   */
+  async disconnect() {
+    await this.connector.disconnect();
+  }
+  /**
+   * Initializes the MCP session with the server.
+   *
+   * This method performs the MCP initialization handshake, exchanging
+   * capabilities and metadata with the server. If `autoConnect` is true
+   * and the session is not yet connected, it will connect first.
+   *
+   * After initialization, you can list and call tools, read resources, etc.
+   *
+   * @returns Promise that resolves when initialized
+   *
+   * @example
+   * ```typescript
+   * const session = await client.createSession('my-server', false);
+   * await session.connect();
+   * await session.initialize();
+   * // Now ready to use
+   * const tools = await session.listTools();
+   * ```
+   *
+   * @see {@link connect} for establishing the connection first
+   */
+  async initialize() {
+    if (!this.isConnected && this.autoConnect) {
+      await this.connect();
+    }
+    await this.connector.initialize();
+  }
+  /**
+   * Checks if the session is currently connected to the server.
+   *
+   * @returns True if connected, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (session.isConnected) {
+   *   const tools = await session.listTools();
+   * }
+   * ```
+   */
+  get isConnected() {
+    return this.connector && this.connector.isClientConnected;
+  }
+  /**
+   * Register an event handler for session events
+   *
+   * @param event - The event type to listen for
+   * @param handler - The handler function to call when the event occurs
+   *
+   * @example
+   * ```typescript
+   * session.on("notification", async (notification) => {
+   *   console.log(`Received: ${notification.method}`, notification.params);
+   *
+   *   if (notification.method === "notifications/tools/list_changed") {
+   *     // Refresh tools list
+   *   }
+   * });
+   * ```
+   */
+  on(event, handler) {
+    if (event === "notification") {
+      this.connector.onNotification(handler);
+    }
+  }
+  /**
+   * Set roots and notify the server.
+   * Roots represent directories or files that the client has access to.
+   *
+   * @param roots - Array of Root objects with `uri` (must start with "file://") and optional `name`
+   *
+   * @example
+   * ```typescript
+   * await session.setRoots([
+   *   { uri: "file:///home/user/project", name: "My Project" },
+   *   { uri: "file:///home/user/data" }
+   * ]);
+   * ```
+   */
+  async setRoots(roots) {
+    return this.connector.setRoots(roots);
+  }
+  /**
+   * Gets the current roots advertised to the server.
+   *
+   * Roots represent directories or files that the client has provided access to.
+   * The server may use this information to scope its operations.
+   *
+   * @returns Array of Root objects
+   *
+   * @example
+   * ```typescript
+   * const roots = session.getRoots();
+   * console.log(`Current roots: ${roots.map(r => r.uri).join(', ')}`);
+   * ```
+   *
+   * @see {@link setRoots} for updating roots
+   */
+  getRoots() {
+    return this.connector.getRoots();
+  }
+  /**
+   * Get the cached list of tools from the server.
+   *
+   * @returns Array of available tools
+   *
+   * @example
+   * ```typescript
+   * const tools = session.tools;
+   * console.log(`Available tools: ${tools.map(t => t.name).join(", ")}`);
+   * ```
+   */
+  get tools() {
+    return this.connector.tools;
+  }
+  /**
+   * List all available tools from the MCP server.
+   * This method fetches fresh tools from the server, unlike the `tools` getter which returns cached tools.
+   *
+   * @param options - Optional request options
+   * @returns Array of available tools
+   *
+   * @example
+   * ```typescript
+   * const tools = await session.listTools();
+   * console.log(`Available tools: ${tools.map(t => t.name).join(", ")}`);
+   * ```
+   */
+  async listTools(options) {
+    return this.connector.listTools(options);
+  }
+  /**
+   * Get the server capabilities advertised during initialization.
+   *
+   * @returns Server capabilities object
+   */
+  get serverCapabilities() {
+    return this.connector.serverCapabilities;
+  }
+  /**
+   * Get the server information (name and version).
+   *
+   * @returns Server info object or null if not available
+   */
+  get serverInfo() {
+    return this.connector.serverInfo;
+  }
+  /**
+   * Call a tool on the server.
+   *
+   * @param name - Name of the tool to call
+   * @param args - Arguments to pass to the tool (defaults to empty object)
+   * @param options - Optional request options (timeout, progress handlers, etc.)
+   * @returns Result from the tool execution
+   *
+   * @example
+   * ```typescript
+   * const result = await session.callTool("add", { a: 5, b: 3 });
+   * console.log(`Result: ${result.content[0].text}`);
+   * ```
+   */
+  async callTool(name, args = {}, options) {
+    return this.connector.callTool(name, args, options);
+  }
+  /**
+   * List resources from the server with optional pagination.
+   *
+   * @param cursor - Optional cursor for pagination
+   * @param options - Request options
+   * @returns Resource list with optional nextCursor for pagination
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listResources();
+   * console.log(`Found ${result.resources.length} resources`);
+   * ```
+   */
+  async listResources(cursor, options) {
+    return this.connector.listResources(cursor, options);
+  }
+  /**
+   * List all resources from the server, automatically handling pagination.
+   *
+   * @param options - Request options
+   * @returns Complete list of all resources
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listAllResources();
+   * console.log(`Total resources: ${result.resources.length}`);
+   * ```
+   */
+  async listAllResources(options) {
+    return this.connector.listAllResources(options);
+  }
+  /**
+   * List resource templates from the server.
+   *
+   * @param options - Request options
+   * @returns List of available resource templates
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listResourceTemplates();
+   * console.log(`Available templates: ${result.resourceTemplates.length}`);
+   * ```
+   */
+  async listResourceTemplates(options) {
+    return this.connector.listResourceTemplates(options);
+  }
+  /**
+   * Request completion suggestions for a prompt or resource template argument.
+   *
+   * @param params - Completion request parameters
+   * @param options - Request options
+   * @returns Completion suggestions from the server
+   *
+   * @example
+   * ```typescript
+   * // Complete a prompt argument
+   * const result = await session.complete({
+   *   ref: { type: "ref/prompt", name: "my-prompt" },
+   *   argument: { name: "language", value: "py" }
+   * });
+   * console.log(result.completion.values); // ["python"]
+   * ```
+   */
+  async complete(params, options) {
+    return this.connector.complete(params, options);
+  }
+  /**
+   * Read a resource by URI.
+   *
+   * @param uri - URI of the resource to read
+   * @param options - Request options
+   * @returns Resource content
+   *
+   * @example
+   * ```typescript
+   * const resource = await session.readResource("file:///path/to/file.txt");
+   * console.log(resource.contents);
+   * ```
+   */
+  async readResource(uri, options) {
+    return this.connector.readResource(uri, options);
+  }
+  /**
+   * Subscribe to resource updates.
+   *
+   * @param uri - URI of the resource to subscribe to
+   * @param options - Request options
+   *
+   * @example
+   * ```typescript
+   * await session.subscribeToResource("file:///path/to/file.txt");
+   * // Now you'll receive notifications when this resource changes
+   * ```
+   */
+  async subscribeToResource(uri, options) {
+    return this.connector.subscribeToResource(uri, options);
+  }
+  /**
+   * Unsubscribe from resource updates.
+   *
+   * @param uri - URI of the resource to unsubscribe from
+   * @param options - Request options
+   *
+   * @example
+   * ```typescript
+   * await session.unsubscribeFromResource("file:///path/to/file.txt");
+   * ```
+   */
+  async unsubscribeFromResource(uri, options) {
+    return this.connector.unsubscribeFromResource(uri, options);
+  }
+  /**
+   * List available prompts from the server.
+   *
+   * @returns List of available prompts
+   *
+   * @example
+   * ```typescript
+   * const result = await session.listPrompts();
+   * console.log(`Available prompts: ${result.prompts.length}`);
+   * ```
+   */
+  async listPrompts() {
+    return this.connector.listPrompts();
+  }
+  /**
+   * Get a specific prompt with arguments.
+   *
+   * @param name - Name of the prompt to get
+   * @param args - Arguments for the prompt
+   * @returns Prompt result
+   *
+   * @example
+   * ```typescript
+   * const prompt = await session.getPrompt("greeting", { name: "Alice" });
+   * console.log(prompt.messages);
+   * ```
+   */
+  async getPrompt(name, args) {
+    return this.connector.getPrompt(name, args);
+  }
+  /**
+   * Send a raw request through the client.
+   *
+   * @param method - MCP method name
+   * @param params - Request parameters
+   * @param options - Request options
+   * @returns Response from the server
+   *
+   * @example
+   * ```typescript
+   * const result = await session.request("custom/method", { key: "value" });
+   * ```
+   */
+  async request(method, params = null, options) {
+    return this.connector.request(method, params, options);
+  }
+};
+
+// src/client/base.ts
+var BaseMCPClient = class {
+  static {
+    __name(this, "BaseMCPClient");
+  }
+  /**
+   * Internal configuration object containing MCP server definitions.
+   * @protected
+   */
+  config = {};
+  /**
+   * Map of server names to their active sessions.
+   * @protected
+   */
+  sessions = {};
+  /**
+   * 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 = [];
+  /**
+   * 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) {
+    if (config) {
+      this.config = config;
+    }
+  }
+  /**
+   * 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 {Error} 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) {
+    throw new Error("fromDict must be implemented by concrete class");
+  }
+  /**
+   * 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, serverConfig) {
+    this.config.mcpServers = this.config.mcpServers || {};
+    this.config.mcpServers[name] = serverConfig;
+    Tel.getInstance().trackClientAddServer(name, serverConfig);
+  }
+  /**
+   * 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
+   * 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) {
+    if (this.config.mcpServers?.[name]) {
+      delete this.config.mcpServers[name];
+      this.activeSessions = this.activeSessions.filter((n) => n !== name);
+      Tel.getInstance().trackClientRemoveServer(name);
+    }
+  }
+  /**
+   * 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() {
+    return Object.keys(this.config.mcpServers ?? {});
+  }
+  /**
+   * 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) {
+    return this.config.mcpServers?.[name];
+  }
+  /**
+   * 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() {
+    return this.config ?? {};
+  }
+  /**
+   * Creates a new session for connecting to an MCP server.
+   *
+   * 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.
+   *
+   * @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 {Error} 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
+   */
+  async createSession(serverName, autoInitialize = true) {
+    const servers = this.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      logger.warn("No MCP servers defined in config");
+    }
+    if (!servers[serverName]) {
+      throw new Error(`Server '${serverName}' not found in config`);
+    }
+    const connector = await Promise.resolve(
+      this.createConnectorFromConfig(servers[serverName])
+    );
+    const session = new MCPSession(connector);
+    if (autoInitialize) {
+      await session.initialize();
+    }
+    this.sessions[serverName] = session;
+    if (!this.activeSessions.includes(serverName)) {
+      this.activeSessions.push(serverName);
+    }
+    return session;
+  }
+  /**
+   * 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
+   */
+  async createAllSessions(autoInitialize = true) {
+    const servers = this.config.mcpServers ?? {};
+    if (Object.keys(servers).length === 0) {
+      logger.warn("No MCP servers defined in config");
+    }
+    for (const name of Object.keys(servers)) {
+      await this.createSession(name, autoInitialize);
+    }
+    return this.sessions;
+  }
+  /**
+   * 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) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      return null;
+    }
+    return session;
+  }
+  /**
+   * 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 {Error} 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) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      throw new Error(
+        `Session '${serverName}' not found. Available sessions: ${this.activeSessions.join(", ") || "none"}`
+      );
+    }
+    return session;
+  }
+  /**
+   * 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() {
+    return Object.fromEntries(
+      this.activeSessions.map((n) => [n, this.sessions[n]])
+    );
+  }
+  /**
+   * 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
+   */
+  async closeSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      logger.warn(
+        `No session exists for server ${serverName}, nothing to close`
+      );
+      return;
+    }
+    try {
+      logger.debug(`Closing session for server ${serverName}`);
+      await session.disconnect();
+    } catch (e) {
+      logger.error(`Error closing session for server '${serverName}': ${e}`);
+    } finally {
+      if (this.sessions[serverName] === session) {
+        delete this.sessions[serverName];
+        this.activeSessions = this.activeSessions.filter(
+          (n) => n !== serverName
+        );
+      }
+    }
+  }
+  /**
+   * 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
+   */
+  async closeAllSessions() {
+    const serverNames = Object.keys(this.sessions);
+    const errors = [];
+    for (const serverName of serverNames) {
+      try {
+        logger.debug(`Closing session for server ${serverName}`);
+        await this.closeSession(serverName);
+      } catch (e) {
+        const errorMsg = `Failed to close session for server '${serverName}': ${e}`;
+        logger.error(errorMsg);
+        errors.push(errorMsg);
+      }
+    }
+    if (errors.length) {
+      logger.error(
+        `Encountered ${errors.length} errors while closing sessions`
+      );
+    } else {
+      logger.debug("All sessions closed successfully");
+    }
+  }
+};
+
+// src/client/executors/base.ts
+var BaseCodeExecutor = class {
+  static {
+    __name(this, "BaseCodeExecutor");
+  }
+  client;
+  _connecting = false;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Ensure all configured MCP servers are connected before execution.
+   * Prevents race conditions with a connection lock.
+   */
+  async ensureServersConnected() {
+    const configuredServers = this.client.getServerNames();
+    const activeSessions = Object.keys(this.client.getAllActiveSessions());
+    const missingServers = configuredServers.filter(
+      (s) => !activeSessions.includes(s)
+    );
+    if (missingServers.length > 0 && !this._connecting) {
+      this._connecting = true;
+      try {
+        logger.debug(
+          `Connecting to configured servers for code execution: ${missingServers.join(", ")}`
+        );
+        await this.client.createAllSessions();
+      } finally {
+        this._connecting = false;
+      }
+    } else if (missingServers.length > 0 && this._connecting) {
+      logger.debug("Waiting for ongoing server connection...");
+      const startWait = Date.now();
+      while (this._connecting && Date.now() - startWait < 5e3) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+  }
+  /**
+   * Get tool namespace information from all active MCP sessions.
+   * Filters out the internal code_mode server.
+   */
+  getToolNamespaces() {
+    const namespaces = [];
+    const activeSessions = this.client.getAllActiveSessions();
+    for (const [serverName, session] of Object.entries(activeSessions)) {
+      if (serverName === "code_mode") continue;
+      try {
+        const connector = session.connector;
+        let tools;
+        try {
+          tools = connector.tools;
+        } catch (e) {
+          logger.warn(`Tools not available for server ${serverName}: ${e}`);
+          continue;
+        }
+        if (!tools || tools.length === 0) continue;
+        namespaces.push({ serverName, tools, session });
+      } catch (e) {
+        logger.warn(`Failed to load tools for server ${serverName}: ${e}`);
+      }
+    }
+    return namespaces;
+  }
+  /**
+   * Create a search function for discovering available MCP tools.
+   * Used by code execution environments to find tools at runtime.
+   */
+  createSearchToolsFunction() {
+    return async (query = "", detailLevel = "full") => {
+      const allTools = [];
+      const allNamespaces = /* @__PURE__ */ new Set();
+      const queryLower = query.toLowerCase();
+      const activeSessions = this.client.getAllActiveSessions();
+      for (const [serverName, session] of Object.entries(activeSessions)) {
+        if (serverName === "code_mode") continue;
+        try {
+          const tools = session.connector.tools;
+          if (tools && tools.length > 0) {
+            allNamespaces.add(serverName);
+          }
+          for (const tool of tools) {
+            if (detailLevel === "names") {
+              allTools.push({ name: tool.name, server: serverName });
+            } else if (detailLevel === "descriptions") {
+              allTools.push({
+                name: tool.name,
+                server: serverName,
+                description: tool.description
+              });
+            } else {
+              allTools.push({
+                name: tool.name,
+                server: serverName,
+                description: tool.description,
+                input_schema: tool.inputSchema
+              });
+            }
+          }
+        } catch (e) {
+          logger.warn(`Failed to search tools in server ${serverName}: ${e}`);
+        }
+      }
+      let filteredTools = allTools;
+      if (query) {
+        filteredTools = allTools.filter((tool) => {
+          const nameMatch = tool.name.toLowerCase().includes(queryLower);
+          const descMatch = tool.description?.toLowerCase().includes(queryLower);
+          const serverMatch = tool.server.toLowerCase().includes(queryLower);
+          return nameMatch || descMatch || serverMatch;
+        });
+      }
+      return {
+        meta: {
+          total_tools: allTools.length,
+          namespaces: Array.from(allNamespaces).sort(),
+          result_count: filteredTools.length
+        },
+        results: filteredTools
+      };
+    };
+  }
+};
+
+// src/client/executors/e2b.ts
+var E2BCodeExecutor = class extends BaseCodeExecutor {
+  static {
+    __name(this, "E2BCodeExecutor");
+  }
+  e2bApiKey;
+  codeExecSandbox = null;
+  SandboxClass = null;
+  timeoutMs;
+  constructor(client, options) {
+    super(client);
+    this.e2bApiKey = options.apiKey;
+    this.timeoutMs = options.timeoutMs ?? 3e5;
+  }
+  /**
+   * Lazy load E2B Sandbox class.
+   * This allows the library to work without E2B installed.
+   */
+  async ensureSandboxClass() {
+    if (this.SandboxClass) return;
+    try {
+      const e2b = await import("@e2b/code-interpreter");
+      this.SandboxClass = e2b.Sandbox;
+    } catch (error) {
+      throw new Error(
+        "@e2b/code-interpreter is not installed. The E2B code executor requires this optional dependency. Install it with: yarn add @e2b/code-interpreter"
+      );
+    }
+  }
+  /**
+   * Get or create a dedicated sandbox for code execution.
+   */
+  async getOrCreateCodeExecSandbox() {
+    if (this.codeExecSandbox) return this.codeExecSandbox;
+    await this.ensureSandboxClass();
+    logger.debug("Starting E2B sandbox for code execution...");
+    this.codeExecSandbox = await this.SandboxClass.create("base", {
+      apiKey: this.e2bApiKey,
+      timeoutMs: this.timeoutMs
+    });
+    return this.codeExecSandbox;
+  }
+  /**
+   * Generate the shim code that exposes tools to the sandbox environment.
+   * Creates a bridge that intercepts tool calls and sends them back to host.
+   */
+  generateShim(tools) {
+    let shim = `
+// MCP Bridge Shim
+global.__callMcpTool = async (server, tool, args) => {
+    const id = Math.random().toString(36).substring(7);
+    console.log(JSON.stringify({
+        type: '__MCP_TOOL_CALL__',
+        id,
+        server,
+        tool,
+        args
+    }));
+    
+    const resultPath = \`/tmp/mcp_result_\${id}.json\`;
+    const fs = require('fs');
+    
+    // Poll for result file
+    let attempts = 0;
+    while (attempts < 300) { // 30 seconds timeout
+        if (fs.existsSync(resultPath)) {
+            const content = fs.readFileSync(resultPath, 'utf8');
+            const result = JSON.parse(content);
+            fs.unlinkSync(resultPath); // Clean up
+            
+            if (result.error) {
+                throw new Error(result.error);
+            }
+            return result.data;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+        attempts++;
+    }
+    throw new Error('Tool execution timed out');
+};
+
+// Global search_tools helper
+global.search_tools = async (query, detailLevel = 'full') => {
+    const allTools = ${JSON.stringify(
+      Object.entries(tools).flatMap(
+        ([server, serverTools]) => serverTools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          server,
+          input_schema: tool.inputSchema
+        }))
+      )
+    )};
+    
+    const filtered = allTools.filter(tool => {
+        if (!query) return true;
+        const q = query.toLowerCase();
+        return tool.name.toLowerCase().includes(q) || 
+               (tool.description && tool.description.toLowerCase().includes(q));
+    });
+    
+    if (detailLevel === 'names') {
+        return filtered.map(t => ({ name: t.name, server: t.server }));
+    } else if (detailLevel === 'descriptions') {
+        return filtered.map(t => ({ name: t.name, server: t.server, description: t.description }));
+    }
+    return filtered;
+};
+`;
+    for (const [serverName, serverTools] of Object.entries(tools)) {
+      if (!serverTools || serverTools.length === 0) continue;
+      const safeServerName = serverName.replace(/[^a-zA-Z0-9_]/g, "_");
+      shim += `
+global['${serverName}'] = {`;
+      for (const tool of serverTools) {
+        shim += `
+    '${tool.name}': async (args) => await global.__callMcpTool('${serverName}', '${tool.name}', args),`;
+      }
+      shim += `
+};
+
+// Also expose as safe name if different
+if ('${safeServerName}' !== '${serverName}') {
+    global['${safeServerName}'] = global['${serverName}'];
+}
+`;
+    }
+    return shim;
+  }
+  /**
+   * Build the tool catalog for the shim.
+   * Returns a map of server names to their available tools.
+   */
+  buildToolCatalog() {
+    const catalog = {};
+    const namespaces = this.getToolNamespaces();
+    for (const { serverName, tools } of namespaces) {
+      catalog[serverName] = tools;
+    }
+    return catalog;
+  }
+  /**
+   * Execute JavaScript/TypeScript code in an E2B sandbox with MCP tool access.
+   * Tool calls are proxied back to the host via the bridge pattern.
+   *
+   * @param code - Code to execute
+   * @param timeout - Execution timeout in milliseconds (default: 30000)
+   */
+  async execute(code, timeout = 3e4) {
+    const startTime = Date.now();
+    let result = null;
+    let error = null;
+    let logs = [];
+    try {
+      await this.ensureServersConnected();
+      const sandbox = await this.getOrCreateCodeExecSandbox();
+      const toolCatalog = this.buildToolCatalog();
+      const shim = this.generateShim(toolCatalog);
+      const wrappedCode = `
+${shim}
+
+(async () => {
+    try {
+        const func = async () => {
+            ${code}
+        };
+        const result = await func();
+        console.log('__MCP_RESULT_START__');
+        console.log(JSON.stringify(result));
+        console.log('__MCP_RESULT_END__');
+    } catch (e) {
+        console.error(e);
+        process.exit(1);
+    }
+})();
+`;
+      const filename = `exec_${Date.now()}.js`;
+      await sandbox.files.write(filename, wrappedCode);
+      const execution = await sandbox.commands.run(`node ${filename}`, {
+        timeoutMs: timeout,
+        onStdout: /* @__PURE__ */ __name(async (data) => {
+          try {
+            const lines = data.split("\n");
+            for (const line of lines) {
+              if (line.trim().startsWith('{"type":"__MCP_TOOL_CALL__"')) {
+                const call = JSON.parse(line);
+                if (call.type === "__MCP_TOOL_CALL__") {
+                  try {
+                    logger.debug(
+                      `[E2B Bridge] Calling tool ${call.server}.${call.tool}`
+                    );
+                    const activeSessions = this.client.getAllActiveSessions();
+                    const session = activeSessions[call.server];
+                    if (!session) {
+                      throw new Error(`Server ${call.server} not found`);
+                    }
+                    const toolResult = await session.connector.callTool(
+                      call.tool,
+                      call.args
+                    );
+                    let extractedResult = toolResult;
+                    if (toolResult.content && toolResult.content.length > 0) {
+                      const item = toolResult.content[0];
+                      if (item.type === "text") {
+                        try {
+                          extractedResult = JSON.parse(item.text);
+                        } catch {
+                          extractedResult = item.text;
+                        }
+                      } else {
+                        extractedResult = item;
+                      }
+                    }
+                    const resultPath = `/tmp/mcp_result_${call.id}.json`;
+                    await sandbox.files.write(
+                      resultPath,
+                      JSON.stringify({ data: extractedResult })
+                    );
+                  } catch (err) {
+                    logger.error(
+                      `[E2B Bridge] Tool execution failed: ${err.message}`
+                    );
+                    const resultPath = `/tmp/mcp_result_${call.id}.json`;
+                    await sandbox.files.write(
+                      resultPath,
+                      JSON.stringify({
+                        error: err.message || String(err)
+                      })
+                    );
+                  }
+                }
+              }
+            }
+          } catch (e) {
+          }
+        }, "onStdout")
+      });
+      logs = [execution.stdout, execution.stderr].filter(Boolean);
+      if (execution.exitCode !== 0) {
+        error = execution.stderr || "Execution failed";
+      } else {
+        const stdout = execution.stdout;
+        const startMarker = "__MCP_RESULT_START__";
+        const endMarker = "__MCP_RESULT_END__";
+        const startIndex = stdout.indexOf(startMarker);
+        const endIndex = stdout.indexOf(endMarker);
+        if (startIndex !== -1 && endIndex !== -1) {
+          const jsonStr = stdout.substring(startIndex + startMarker.length, endIndex).trim();
+          try {
+            result = JSON.parse(jsonStr);
+          } catch (e) {
+            result = jsonStr;
+          }
+          logs = logs.map((log) => {
+            let cleaned = log.replace(
+              new RegExp(startMarker + "[\\s\\S]*?" + endMarker),
+              "[Result captured]"
+            );
+            cleaned = cleaned.split("\n").filter((l) => !l.includes("__MCP_TOOL_CALL__")).join("\n");
+            return cleaned;
+          });
+        }
+      }
+    } catch (e) {
+      error = e.message || String(e);
+      if (error && (error.includes("timeout") || error.includes("timed out"))) {
+        error = "Script execution timed out";
+      }
+    }
+    return {
+      result,
+      logs,
+      error,
+      execution_time: (Date.now() - startTime) / 1e3
+    };
+  }
+  /**
+   * Clean up the E2B sandbox.
+   * Should be called when the executor is no longer needed.
+   */
+  async cleanup() {
+    if (this.codeExecSandbox) {
+      try {
+        await this.codeExecSandbox.kill();
+        this.codeExecSandbox = null;
+        logger.debug("E2B code execution sandbox stopped");
+      } catch (error) {
+        logger.error("Failed to stop E2B code execution sandbox:", error);
+      }
+    }
+  }
+};
+
+// src/client/executors/vm.ts
+var vm = null;
+var vmCheckAttempted = false;
+function getVMModuleName() {
+  return ["node", "vm"].join(":");
+}
+__name(getVMModuleName, "getVMModuleName");
+function tryLoadVM() {
+  if (vmCheckAttempted) {
+    return vm !== null;
+  }
+  vmCheckAttempted = true;
+  try {
+    const nodeRequire = typeof __require !== "undefined" ? __require : null;
+    if (nodeRequire) {
+      vm = nodeRequire(getVMModuleName());
+      return true;
+    }
+  } catch (error) {
+    logger.debug("node:vm module not available via require");
+  }
+  return false;
+}
+__name(tryLoadVM, "tryLoadVM");
+async function tryLoadVMAsync() {
+  if (vm !== null) {
+    return true;
+  }
+  if (!vmCheckAttempted) {
+    if (tryLoadVM()) {
+      return true;
+    }
+  }
+  try {
+    vm = await import(
+      /* @vite-ignore */
+      getVMModuleName()
+    );
+    return true;
+  } catch (error) {
+    logger.debug(
+      "node:vm module not available in this environment (e.g., Deno)"
+    );
+    return false;
+  }
+}
+__name(tryLoadVMAsync, "tryLoadVMAsync");
+function isVMAvailable() {
+  tryLoadVM();
+  return vm !== null;
+}
+__name(isVMAvailable, "isVMAvailable");
+var VMCodeExecutor = class extends BaseCodeExecutor {
+  static {
+    __name(this, "VMCodeExecutor");
+  }
+  defaultTimeout;
+  memoryLimitMb;
+  constructor(client, options) {
+    super(client);
+    this.defaultTimeout = options?.timeoutMs ?? 3e4;
+    this.memoryLimitMb = options?.memoryLimitMb;
+    tryLoadVM();
+  }
+  /**
+   * Ensure VM module is loaded before execution
+   */
+  async ensureVMLoaded() {
+    if (vm !== null) {
+      return;
+    }
+    const loaded = await tryLoadVMAsync();
+    if (!loaded) {
+      throw new Error(
+        "node:vm module is not available in this environment. Please use E2B executor instead or run in a Node.js environment."
+      );
+    }
+  }
+  /**
+   * Execute JavaScript/TypeScript code with access to MCP tools.
+   *
+   * @param code - Code to execute
+   * @param timeout - Execution timeout in milliseconds (default: configured timeout or 30000)
+   */
+  async execute(code, timeout) {
+    const effectiveTimeout = timeout ?? this.defaultTimeout;
+    await this.ensureVMLoaded();
+    await this.ensureServersConnected();
+    const logs = [];
+    const startTime = Date.now();
+    let result = null;
+    let error = null;
+    try {
+      const context = await this._buildContext(logs);
+      const wrappedCode = `
+        (async () => {
+          try {
+            ${code}
+          } catch (e) {
+            throw e;
+          }
+        })()
+      `;
+      const script = new vm.Script(wrappedCode, {
+        filename: "agent_code.js"
+      });
+      const promise = script.runInNewContext(context, {
+        timeout: effectiveTimeout,
+        displayErrors: true
+      });
+      result = await promise;
+    } catch (e) {
+      error = e.message || String(e);
+      if (e.code === "ERR_SCRIPT_EXECUTION_TIMEOUT" || e.message === "Script execution timed out." || typeof error === "string" && (error.includes("timed out") || error.includes("timeout"))) {
+        error = "Script execution timed out";
+      }
+      if (e.stack) {
+        logger.debug(`Code execution error stack: ${e.stack}`);
+      }
+    }
+    const executionTime = (Date.now() - startTime) / 1e3;
+    return {
+      result,
+      logs,
+      error,
+      execution_time: executionTime
+    };
+  }
+  /**
+   * Build the VM execution context with MCP tools and standard globals.
+   *
+   * @param logs - Array to capture console output
+   */
+  async _buildContext(logs) {
+    const logHandler = /* @__PURE__ */ __name((...args) => {
+      logs.push(
+        args.map(
+          (arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)
+        ).join(" ")
+      );
+    }, "logHandler");
+    const sandbox = {
+      console: {
+        log: logHandler,
+        error: /* @__PURE__ */ __name((...args) => {
+          logHandler("[ERROR]", ...args);
+        }, "error"),
+        warn: /* @__PURE__ */ __name((...args) => {
+          logHandler("[WARN]", ...args);
+        }, "warn"),
+        info: logHandler,
+        debug: logHandler
+      },
+      // Standard globals
+      Object,
+      Array,
+      String,
+      Number,
+      Boolean,
+      Date,
+      Math,
+      JSON,
+      RegExp,
+      Map,
+      Set,
+      Promise,
+      parseInt,
+      parseFloat,
+      isNaN,
+      isFinite,
+      encodeURI,
+      decodeURI,
+      encodeURIComponent,
+      decodeURIComponent,
+      setTimeout,
+      clearTimeout,
+      // Helper for tools
+      search_tools: this.createSearchToolsFunction(),
+      __tool_namespaces: []
+    };
+    const toolNamespaces = {};
+    const namespaceInfos = this.getToolNamespaces();
+    for (const { serverName, tools, session } of namespaceInfos) {
+      const serverNamespace = {};
+      for (const tool of tools) {
+        const toolName = tool.name;
+        serverNamespace[toolName] = async (args) => {
+          const result = await session.connector.callTool(toolName, args || {});
+          if (result.content && result.content.length > 0) {
+            const item = result.content[0];
+            if (item.type === "text") {
+              try {
+                return JSON.parse(item.text);
+              } catch {
+                return item.text;
+              }
+            }
+            return item;
+          }
+          return result;
+        };
+      }
+      sandbox[serverName] = serverNamespace;
+      toolNamespaces[serverName] = true;
+    }
+    sandbox.__tool_namespaces = Object.keys(toolNamespaces);
+    return vm.createContext(sandbox);
+  }
+  /**
+   * Clean up resources.
+   * VM executor doesn't need cleanup, but method kept for interface consistency.
+   */
+  async cleanup() {
+  }
+};
+
+// src/connectors/http.ts
+import {
+  Client
+} from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/task_managers/sse.ts
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+var SseConnectionManager = class extends ConnectionManager {
+  static {
+    __name(this, "SseConnectionManager");
+  }
+  url;
+  opts;
+  _transport = null;
+  reinitializing = false;
+  /**
+   * Create an SSE connection manager.
+   *
+   * @param url  The SSE endpoint URL.
+   * @param opts Optional transport options (auth, headers, etc.).
+   */
+  constructor(url, opts) {
+    super();
+    this.url = typeof url === "string" ? new URL(url) : url;
+    this.opts = opts;
+  }
+  /**
+   * Spawn a new `SSEClientTransport` and wrap it with 404 handling.
+   * Per MCP spec, clients MUST re-initialize when receiving 404 for stale sessions.
+   */
+  async establishConnection() {
+    const transport = new SSEClientTransport(this.url, this.opts);
+    const originalSend = transport.send.bind(transport);
+    transport.send = async (message) => {
+      const sendMessage = /* @__PURE__ */ __name(async (msg) => {
+        if (Array.isArray(msg)) {
+          for (const singleMsg of msg) {
+            await originalSend(singleMsg);
+          }
+        } else {
+          await originalSend(msg);
+        }
+      }, "sendMessage");
+      try {
+        await sendMessage(message);
+      } catch (error) {
+        if (error?.code === 404 && transport.sessionId && !this.reinitializing) {
+          logger.warn(
+            `[SSE] Session not found (404), re-initializing per MCP spec...`
+          );
+          this.reinitializing = true;
+          try {
+            transport.sessionId = void 0;
+            await this.reinitialize(transport);
+            logger.debug(
+              `[SSE] Re-initialization successful, retrying request`
+            );
+            await sendMessage(message);
+          } finally {
+            this.reinitializing = false;
+          }
+        } else {
+          throw error;
+        }
+      }
+    };
+    this._transport = transport;
+    logger.debug(`${this.constructor.name} connected successfully`);
+    return transport;
+  }
+  /**
+   * Re-initialize the transport with a new session
+   * This is called when the server returns 404 for a stale session
+   */
+  async reinitialize(transport) {
+    logger.debug(`[SSE] Re-initialization triggered`);
+  }
+  /**
+   * Close the underlying transport and clean up resources.
+   */
+  async closeConnection(_connection) {
+    if (this._transport) {
+      try {
+        await this._transport.close();
+      } catch (e) {
+        logger.warn(`Error closing SSE transport: ${e}`);
+      } finally {
+        this._transport = null;
+      }
+    }
+  }
+};
+
+// src/connectors/http.ts
+var HttpConnector = class extends BaseConnector {
+  static {
+    __name(this, "HttpConnector");
+  }
+  baseUrl;
+  headers;
+  timeout;
+  sseReadTimeout;
+  customFetch;
+  clientInfo;
+  preferSse;
+  disableSseFallback;
+  gatewayUrl;
+  serverId;
+  reconnectionOptions;
+  transportType = null;
+  streamableTransport = null;
+  constructor(baseUrl, opts = {}) {
+    super(opts);
+    const originalUrl = baseUrl.replace(/\/$/, "");
+    this.gatewayUrl = opts.gatewayUrl;
+    this.serverId = opts.serverId;
+    if (this.gatewayUrl) {
+      this.baseUrl = this.gatewayUrl.replace(/\/$/, "");
+      this.headers = { ...opts.headers ?? {} };
+      this.headers["X-Target-URL"] = originalUrl;
+      if (this.serverId) {
+        this.headers["X-Server-Id"] = this.serverId;
+      }
+    } else {
+      this.baseUrl = originalUrl;
+      this.headers = { ...opts.headers ?? {} };
+    }
+    if (opts.authToken) {
+      this.headers.Authorization = `Bearer ${opts.authToken}`;
+    }
+    this.timeout = opts.timeout ?? 1e4;
+    this.sseReadTimeout = opts.sseReadTimeout ?? 3e5;
+    this.customFetch = opts.fetch;
+    this.clientInfo = opts.clientInfo ?? {
+      name: "http-connector",
+      version: "1.0.0"
+    };
+    this.preferSse = opts.preferSse ?? false;
+    this.disableSseFallback = opts.disableSseFallback ?? false;
+    this.reconnectionOptions = opts.reconnectionOptions;
+  }
+  buildClientOptions() {
+    return {
+      ...this.opts.clientOptions || {},
+      capabilities: {
+        ...this.opts.clientOptions?.capabilities || {},
+        roots: { listChanged: true },
+        ...this.opts.onSampling ? { sampling: {} } : {},
+        ...this.opts.onElicitation ?? this.opts.elicitationCallback ? { elicitation: { form: {}, url: {} } } : {}
+      }
+    };
+  }
+  unwrapStreamableError(err) {
+    if (err instanceof StreamableHTTPError) {
+      return err;
+    }
+    if (err instanceof Error && err.cause instanceof StreamableHTTPError) {
+      return err.cause;
+    }
+    return null;
+  }
+  classifyStreamableHttpFailure(err) {
+    let fallbackReason = "Unknown error";
+    let is401Error = false;
+    let httpStatusCode;
+    const streamableErr = this.unwrapStreamableError(err);
+    if (streamableErr) {
+      is401Error = streamableErr.code === 401;
+      httpStatusCode = streamableErr.code;
+      if (streamableErr.code === 400 && streamableErr.message.includes("Missing session ID")) {
+        fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
+        logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
+      } else if (streamableErr.code === 404 || streamableErr.code === 405) {
+        fallbackReason = `Server returned ${streamableErr.code} - server likely doesn't support streamable HTTP`;
+        logger.debug(fallbackReason);
+      } else {
+        fallbackReason = `Server returned ${streamableErr.code}: ${streamableErr.message}`;
+        logger.debug(fallbackReason);
+      }
+      return { fallbackReason, is401Error, httpStatusCode };
+    }
+    if (err instanceof Error) {
+      const errorStr = err.toString();
+      const errorMsg = err.message || "";
+      is401Error = errorStr.includes("401") || errorMsg.includes("Unauthorized");
+      if (errorStr.includes("Missing session ID") || errorStr.includes("Bad Request: Missing session ID") || errorMsg.includes("FastMCP session ID error")) {
+        fallbackReason = "Server requires session ID (FastMCP compatibility) - using SSE transport";
+        logger.warn(`\u26A0\uFE0F  ${fallbackReason}`);
+      } else if (errorStr.includes("405 Method Not Allowed") || errorStr.includes("404 Not Found")) {
+        fallbackReason = "Server doesn't support streamable HTTP (405/404)";
+        logger.debug(fallbackReason);
+      } else {
+        fallbackReason = `Streamable HTTP failed: ${err.message}`;
+        logger.debug(fallbackReason);
+      }
+    }
+    return { fallbackReason, is401Error, httpStatusCode };
+  }
+  /** Establish connection to the MCP implementation via HTTP (streamable or SSE). */
+  async connect() {
+    if (this.connected) {
+      logger.debug("Already connected to MCP implementation");
+      return;
+    }
+    const baseUrl = this.baseUrl;
+    if (this.preferSse) {
+      logger.debug(`Connecting to MCP implementation via HTTP/SSE: ${baseUrl}`);
+      await this.connectWithSse(baseUrl);
+      return;
+    }
+    logger.debug(`Connecting to MCP implementation via HTTP: ${baseUrl}`);
+    try {
+      logger.debug("\u{1F504} Attempting streamable HTTP transport...");
+      await this.connectWithStreamableHttp(baseUrl);
+      logger.debug("\u2705 Successfully connected via streamable HTTP");
+    } catch (err) {
+      logger.debug("Streamable HTTP connect failed", err);
+      const { fallbackReason, is401Error, httpStatusCode } = this.classifyStreamableHttpFailure(err);
+      if (is401Error) {
+        logger.info("Authentication required - skipping SSE fallback");
+        await this.cleanupResources();
+        const authError = new Error("Authentication required");
+        authError.code = 401;
+        throw authError;
+      }
+      if (this.disableSseFallback) {
+        logger.info("SSE fallback disabled - failing connection");
+        await this.cleanupResources();
+        throw new Error(`Streamable HTTP connection failed: ${fallbackReason}`);
+      }
+      logger.debug("\u{1F504} Falling back to SSE transport...");
+      try {
+        await this.connectWithSse(baseUrl);
+      } catch (sseErr) {
+        logger.error("Failed to connect with both transports:");
+        logger.error(`  Streamable HTTP: ${fallbackReason}`);
+        logger.error(`  SSE: ${sseErr}`);
+        await this.cleanupResources();
+        const sseIs401 = sseErr?.message?.includes("401") || sseErr?.message?.includes("Unauthorized");
+        if (sseIs401) {
+          const authError = new Error("Authentication required");
+          authError.code = 401;
+          throw authError;
+        }
+        const finalError = new Error(
+          `Could not connect to server with any available transport. Streamable HTTP: ${fallbackReason}`
+        );
+        if (httpStatusCode !== void 0) {
+          Object.defineProperty(finalError, "code", {
+            value: httpStatusCode,
+            writable: false,
+            enumerable: true,
+            configurable: true
+          });
+          logger.debug(
+            `Preserving HTTP status code ${httpStatusCode} in error for proxy fallback detection`
+          );
+        }
+        throw finalError;
+      }
+    }
+  }
+  async connectWithStreamableHttp(baseUrl) {
+    try {
+      logger.debug("[HttpConnector] Connecting with Streamable HTTP", {
+        baseUrl,
+        originalUrl: this.baseUrl,
+        gatewayUrl: this.gatewayUrl || "none",
+        authProviderUrl: this.opts.authProvider?.serverUrl || "none",
+        headers: this.headers
+      });
+      const streamableTransport = new StreamableHTTPClientTransport(
+        new URL(baseUrl),
+        {
+          authProvider: this.opts.authProvider,
+          // ← Pass OAuth provider to SDK
+          fetch: this.customFetch,
+          requestInit: {
+            headers: this.headers
+          },
+          reconnectionOptions: {
+            maxReconnectionDelay: 3e4,
+            initialReconnectionDelay: 1e3,
+            reconnectionDelayGrowFactor: 1.5,
+            maxRetries: 2,
+            ...this.reconnectionOptions
+          }
+          // Don't pass sessionId - let the SDK generate it automatically during connect()
+        }
+      );
+      let transport = streamableTransport;
+      if (this.opts.wrapTransport) {
+        const serverId = this.baseUrl;
+        transport = this.opts.wrapTransport(
+          transport,
+          serverId
+        );
+      }
+      const clientOptions = this.buildClientOptions();
+      logger.debug(
+        `Creating Client with capabilities:`,
+        JSON.stringify(clientOptions.capabilities, null, 2)
+      );
+      this.client = new Client(this.clientInfo, clientOptions);
+      this.setupRootsHandler();
+      logger.debug("Roots handler registered before connect");
+      try {
+        await this.client.connect(transport, {
+          timeout: this.timeout
+        });
+        const sessionId = streamableTransport.sessionId;
+        if (sessionId) {
+          logger.debug(`Session ID obtained: ${sessionId}`);
+        } else {
+          logger.warn(
+            "Session ID not available after connect - this may cause issues with SSE stream"
+          );
+        }
+      } catch (connectErr) {
+        if (connectErr instanceof Error) {
+          const errMsg = connectErr.message || connectErr.toString();
+          if (errMsg.includes("Missing session ID") || errMsg.includes("Bad Request: Missing session ID") || errMsg.includes("Mcp-Session-Id header is required")) {
+            const wrappedError = new Error(
+              `Session ID error: ${errMsg}. The SDK should automatically extract session ID from initialize response.`
+            );
+            wrappedError.cause = connectErr;
+            throw wrappedError;
+          }
+        }
+        throw connectErr;
+      }
+      this.streamableTransport = streamableTransport;
+      this.connectionManager = {
+        stop: /* @__PURE__ */ __name(async () => {
+          if (this.streamableTransport) {
+            try {
+              await this.streamableTransport.close();
+            } catch (e) {
+              logger.warn(`Error closing Streamable HTTP transport: ${e}`);
+            } finally {
+              this.streamableTransport = null;
+            }
+          }
+        }, "stop")
+      };
+      this.connected = true;
+      this.transportType = "streamable-http";
+      this.setupNotificationHandler();
+      this.setupSamplingHandler();
+      this.setupElicitationHandler();
+      logger.debug(
+        `Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`
+      );
+      this.trackConnectorInit({
+        serverUrl: this.baseUrl,
+        publicIdentifier: `${this.baseUrl} (streamable-http)`
+      });
+    } catch (err) {
+      await this.cleanupResources();
+      throw err;
+    }
+  }
+  async connectWithSse(baseUrl) {
+    try {
+      this.connectionManager = new SseConnectionManager(baseUrl, {
+        authProvider: this.opts.authProvider,
+        // ← Pass OAuth provider to SDK (same as streamable HTTP)
+        requestInit: {
+          headers: this.headers
+        }
+      });
+      let transport = await this.connectionManager.start();
+      if (this.opts.wrapTransport) {
+        const serverId = this.baseUrl;
+        transport = this.opts.wrapTransport(transport, serverId);
+      }
+      const clientOptions = this.buildClientOptions();
+      logger.debug(
+        `Creating Client with capabilities (SSE):`,
+        JSON.stringify(clientOptions.capabilities, null, 2)
+      );
+      this.client = new Client(this.clientInfo, clientOptions);
+      this.setupRootsHandler();
+      logger.debug("Roots handler registered before connect (SSE)");
+      await this.client.connect(transport);
+      this.connected = true;
+      this.transportType = "sse";
+      this.setupNotificationHandler();
+      this.setupSamplingHandler();
+      this.setupElicitationHandler();
+      logger.debug(
+        `Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`
+      );
+      this.trackConnectorInit({
+        serverUrl: this.baseUrl,
+        publicIdentifier: `${this.baseUrl} (sse)`
+      });
+    } catch (err) {
+      await this.cleanupResources();
+      throw err;
+    }
+  }
+  get publicIdentifier() {
+    return {
+      type: "http",
+      url: this.baseUrl,
+      transport: this.transportType || "unknown"
+    };
+  }
+  /**
+   * Get the transport type being used (streamable-http or sse)
+   */
+  getTransportType() {
+    return this.transportType;
+  }
+  // Send the streamable-HTTP DELETE *before* super.cleanupResources() invokes
+  // client.close(). The SDK's transport.close() aborts the shared abort
+  // controller, and terminateSession()'s DELETE fetch reuses that signal —
+  // running it after close() rejects immediately with AbortError.
+  async cleanupResources() {
+    if (this.streamableTransport) {
+      try {
+        await this.streamableTransport.terminateSession();
+      } catch (e) {
+        logger.debug(`Error terminating Streamable HTTP session: ${e}`);
+      }
+    }
+    await super.cleanupResources();
+  }
+};
+
+// src/config.ts
+function resolveCallbacks(perServer, globalDefaults) {
+  const pickSampling = perServer?.onSampling ?? perServer?.samplingCallback ?? globalDefaults?.onSampling ?? globalDefaults?.samplingCallback;
+  const pickElicitation = perServer?.onElicitation ?? perServer?.elicitationCallback ?? globalDefaults?.onElicitation ?? globalDefaults?.elicitationCallback;
+  const pickNotification = perServer?.onNotification ?? globalDefaults?.onNotification;
+  return {
+    onSampling: pickSampling,
+    onElicitation: pickElicitation,
+    onNotification: pickNotification
+  };
+}
+__name(resolveCallbacks, "resolveCallbacks");
+function getDefaultClientInfo() {
+  return {
+    name: "mcp-use",
+    title: "mcp-use",
+    version: getPackageVersion(),
+    description: "mcp-use is a complete TypeScript framework for building and using MCP",
+    icons: [
+      {
+        src: "https://mcp-use.com/logo.png"
+      }
+    ],
+    websiteUrl: "https://mcp-use.com"
+  };
+}
+__name(getDefaultClientInfo, "getDefaultClientInfo");
+function normalizeClientInfo(input) {
+  const fallback = getDefaultClientInfo();
+  if (!input || typeof input !== "object") return fallback;
+  const ci = input;
+  if (!ci.name || !ci.version) return fallback;
+  return { ...fallback, ...ci };
+}
+__name(normalizeClientInfo, "normalizeClientInfo");
+function createConnectorFromConfig(serverConfig, connectorOptions) {
+  const clientInfo = normalizeClientInfo(serverConfig.clientInfo);
+  if ("command" in serverConfig && "args" in serverConfig) {
+    throw new Error(
+      "Stdio connector is not supported in this environment. Stdio connections require Node.js and are only available in the Node.js MCPClient."
+    );
+  }
+  if ("url" in serverConfig) {
+    const transport = serverConfig.transport || "http";
+    return new HttpConnector(serverConfig.url, {
+      headers: serverConfig.headers,
+      fetch: serverConfig.fetch,
+      authToken: serverConfig.auth_token || serverConfig.authToken,
+      authProvider: serverConfig.authProvider,
+      // Only force SSE if explicitly requested
+      preferSse: serverConfig.preferSse || transport === "sse",
+      // Disable SSE fallback if explicitly disabled in config
+      disableSseFallback: serverConfig.disableSseFallback,
+      clientInfo,
+      ...connectorOptions
+    });
+  }
+  throw new Error("Cannot determine connector type from config");
+}
+__name(createConnectorFromConfig, "createConnectorFromConfig");
+
+// src/config-file.ts
+function loadConfigFile(filepath) {
+  const { readFileSync } = __require("fs");
+  const raw = readFileSync(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+__name(loadConfigFile, "loadConfigFile");
+
+// src/client/elicitation-helpers.ts
+function hasRequestedSchema(params) {
+  return "requestedSchema" in params && params.requestedSchema != null;
+}
+__name(hasRequestedSchema, "hasRequestedSchema");
+function getDefaults(params) {
+  const content = {};
+  if (!hasRequestedSchema(params)) return content;
+  const schema = params.requestedSchema;
+  const properties = schema.properties ?? {};
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    const field = fieldSchema;
+    if ("default" in field) {
+      const v = field.default;
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean" || Array.isArray(v) && v.every((x) => typeof x === "string")) {
+        content[fieldName] = v;
+      }
+    }
+  }
+  return content;
+}
+__name(getDefaults, "getDefaults");
+function applyDefaults(params, partial) {
+  const defaults = getDefaults(params);
+  if (partial == null) return defaults;
+  return { ...defaults, ...partial };
+}
+__name(applyDefaults, "applyDefaults");
+function acceptWithDefaults(params) {
+  return { action: "accept", content: getDefaults(params) };
+}
+__name(acceptWithDefaults, "acceptWithDefaults");
+function accept(content) {
+  return { action: "accept", content };
+}
+__name(accept, "accept");
+function decline(_reason) {
+  return { action: "decline" };
+}
+__name(decline, "decline");
+function cancel() {
+  return { action: "cancel" };
+}
+__name(cancel, "cancel");
+function reject(reason) {
+  return decline(reason);
+}
+__name(reject, "reject");
+function validate(params, content) {
+  if (!hasRequestedSchema(params)) {
+    return { valid: true };
+  }
+  try {
+    const zodSchema = JSONSchemaToZod.convert(
+      params.requestedSchema
+    );
+    const result = zodSchema.safeParse(content);
+    if (result.success) {
+      return { valid: true };
+    }
+    const messages = result.error.issues.map(
+      (i) => i.path.length > 0 ? `${i.path.join(".")}: ${i.message}` : i.message
+    );
+    return { valid: false, errors: messages };
+  } catch {
+    return { valid: false, errors: ["Unsupported or invalid schema"] };
+  }
+}
+__name(validate, "validate");
+
+// src/client.ts
+function trackNodeClientInit(config, codeMode, callbacks) {
+  const servers = Object.keys(config.mcpServers ?? {});
+  const hasSamplingCallback = !!(callbacks.onSampling ?? callbacks.samplingCallback);
+  const hasElicitationCallback = !!(callbacks.onElicitation ?? callbacks.elicitationCallback);
+  Tel.getInstance().trackMCPClientInit({
+    codeMode,
+    sandbox: false,
+    allCallbacks: hasSamplingCallback && hasElicitationCallback,
+    verify: false,
+    servers,
+    numServers: servers.length,
+    isBrowser: false
+  }).catch((e) => logger.debug(`Failed to track MCPClient init: ${e}`));
+}
+__name(trackNodeClientInit, "trackNodeClientInit");
+var MCPClient = class _MCPClient extends BaseMCPClient {
+  static {
+    __name(this, "MCPClient");
+  }
+  /**
+   * Gets the mcp-use package version.
+   *
+   * This static method returns the version string of the installed mcp-use package,
+   * which is useful for debugging and compatibility checks.
+   *
+   * @returns The package version string (e.g., "1.13.2")
+   *
+   * @example
+   * ```typescript
+   * console.log(`mcp-use version: ${MCPClient.getPackageVersion()}`);
+   * ```
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
+  /**
+   * Indicates whether code execution mode is enabled.
+   *
+   * When true, the client provides special tools for executing code dynamically
+   * through the {@link executeCode} and {@link searchTools} methods.
+   *
+   * @example
+   * ```typescript
+   * if (client.codeMode) {
+   *   const result = await client.executeCode('return 2 + 2');
+   *   console.log(result.output); // "4"
+   * }
+   * ```
+   */
+  codeMode = false;
+  _codeExecutor = null;
+  _customCodeExecutor = null;
+  _codeExecutorConfig = "vm";
+  _executorOptions;
+  _globalCallbacks;
+  /**
+   * Creates a new MCPClient instance.
+   *
+   * The client can be initialized with either a configuration object, a path to
+   * a configuration file, or no configuration at all (servers can be added later
+   * using {@link addServer}).
+   *
+   * @param config - Configuration object or path to JSON config file. If omitted,
+   *                 starts with empty configuration
+   * @param options - Optional client behavior configuration
+   * @param options.codeMode - Enable code execution mode (boolean or advanced config)
+   * @param options.onSampling - Callback for handling sampling requests from servers
+   * @param options.elicitationCallback - Callback for handling elicitation requests
+   *
+   * @example
+   * ```typescript
+   * // From config file
+   * const client = new MCPClient('./mcp-config.json');
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // From inline config
+   * const client = new MCPClient({
+   *   mcpServers: {
+   *     'my-server': {
+   *       command: 'node',
+   *       args: ['server.js']
+   *     }
+   *   }
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With code mode enabled
+   * const client = new MCPClient('./config.json', {
+   *   codeMode: true
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With sampling callback
+   * const client = new MCPClient('./config.json', {
+   *   onSampling: async (params) => {
+   *     // Call your LLM here
+   *     return anthropic.messages.create(params);
+   *   }
+   * });
+   * ```
+   *
+   * @see {@link fromDict} for creating from config object (alternative syntax)
+   * @see {@link fromConfigFile} for creating from file (alternative syntax)
+   */
+  constructor(config, options) {
+    if (config) {
+      if (typeof config === "string") {
+        super(loadConfigFile(config));
+      } else {
+        super(config);
+      }
+    } else {
+      super();
+    }
+    let codeModeEnabled = false;
+    let executorConfig = "vm";
+    let executorOptions;
+    if (options?.codeMode) {
+      if (typeof options.codeMode === "boolean") {
+        codeModeEnabled = options.codeMode;
+      } else {
+        codeModeEnabled = options.codeMode.enabled;
+        executorConfig = options.codeMode.executor ?? "vm";
+        executorOptions = options.codeMode.executorOptions;
+      }
+    }
+    this.codeMode = codeModeEnabled;
+    this._codeExecutorConfig = executorConfig;
+    this._executorOptions = executorOptions;
+    const configRoot = this.config;
+    this._globalCallbacks = {
+      onSampling: options?.onSampling ?? options?.samplingCallback ?? configRoot?.onSampling ?? configRoot?.samplingCallback,
+      samplingCallback: options?.samplingCallback ?? configRoot?.samplingCallback,
+      onElicitation: options?.onElicitation ?? options?.elicitationCallback ?? configRoot?.onElicitation ?? configRoot?.elicitationCallback,
+      elicitationCallback: options?.elicitationCallback ?? configRoot?.elicitationCallback,
+      onNotification: options?.onNotification ?? configRoot?.onNotification
+    };
+    if (options?.samplingCallback && !options?.onSampling) {
+      console.warn(
+        '[MCPClient] The "samplingCallback" option is deprecated. Use "onSampling" instead.'
+      );
+    }
+    if (options?.elicitationCallback && !options?.onElicitation) {
+      console.warn(
+        '[MCPClient] The "elicitationCallback" option is deprecated. Use "onElicitation" instead.'
+      );
+    }
+    if (this.codeMode) {
+      this._setupCodeModeConnector();
+    }
+    trackNodeClientInit(this.config, this.codeMode, this._globalCallbacks);
+  }
+  /**
+   * Creates a client instance from a configuration dictionary.
+   *
+   * This static factory method provides an alternative syntax for creating
+   * a client from an inline configuration object.
+   *
+   * @param cfg - Configuration dictionary with server definitions
+   * @param options - Optional client behavior configuration
+   * @returns New MCPClient instance
+   *
+   * @example
+   * ```typescript
+   * const client = MCPClient.fromDict({
+   *   mcpServers: {
+   *     'filesystem': {
+   *       command: 'npx',
+   *       args: ['-y', '@modelcontextprotocol/server-filesystem', '/tmp']
+   *     }
+   *   }
+   * });
+   * ```
+   *
+   * @see {@link constructor} for direct instantiation
+   * @see {@link fromConfigFile} for loading from file
+   */
+  static fromDict(cfg, options) {
+    return new _MCPClient(cfg, options);
+  }
+  /**
+   * Creates a client instance from a configuration file.
+   *
+   * This static factory method loads MCP server configurations from a JSON
+   * file and creates a new client instance.
+   *
+   * @param path - Path to the JSON configuration file
+   * @param options - Optional client behavior configuration
+   * @returns New MCPClient instance
+   * @throws {Error} If the file cannot be read or parsed
+   *
+   * @example
+   * ```typescript
+   * const client = MCPClient.fromConfigFile('./mcp-config.json');
+   * await client.createAllSessions();
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With code mode
+   * const client = MCPClient.fromConfigFile('./config.json', {
+   *   codeMode: true
+   * });
+   * ```
+   *
+   * @see {@link constructor} for direct instantiation
+   * @see {@link fromDict} for inline configuration
+   */
+  static fromConfigFile(path2, options) {
+    return new _MCPClient(loadConfigFile(path2), options);
+  }
+  /**
+   * Saves the current configuration to a file.
+   *
+   * This Node.js-specific method writes the client's current configuration
+   * (including all server definitions) to a JSON file. The directory will be
+   * created if it doesn't exist.
+   *
+   * @param filepath - Path where the configuration file should be saved
+   *
+   * @example
+   * ```typescript
+   * const client = new MCPClient();
+   * client.addServer('my-server', {
+   *   command: 'node',
+   *   args: ['server.js']
+   * });
+   *
+   * // Save configuration for later use
+   * client.saveConfig('./mcp-config.json');
+   * ```
+   *
+   * @see {@link fromConfigFile} for loading configurations
+   */
+  saveConfig(filepath) {
+    const dir = path.dirname(filepath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filepath, JSON.stringify(this.config, null, 2), "utf-8");
+  }
+  /**
+   * Create a connector from server configuration (Node.js version)
+   * Supports all connector types including StdioConnector (lazy-loaded to avoid pulling Node-only code into browser bundles).
+   */
+  async createConnectorFromConfig(serverConfig) {
+    const resolved = resolveCallbacks(
+      serverConfig,
+      this._globalCallbacks
+    );
+    const merged = {
+      ...serverConfig,
+      clientInfo: serverConfig.clientInfo ?? this.config.clientInfo
+    };
+    if ("command" in merged && "args" in merged) {
+      const { StdioConnector } = await import("./stdio-FUBSRH66.js");
+      const stdioConfig = merged;
+      return new StdioConnector({
+        command: stdioConfig.command,
+        args: stdioConfig.args,
+        env: stdioConfig.env,
+        cwd: stdioConfig.cwd,
+        clientInfo: normalizeClientInfo(merged.clientInfo),
+        onSampling: resolved.onSampling,
+        onElicitation: resolved.onElicitation,
+        onNotification: resolved.onNotification
+      });
+    }
+    return createConnectorFromConfig(merged, {
+      onSampling: resolved.onSampling,
+      onElicitation: resolved.onElicitation,
+      onNotification: resolved.onNotification
+    });
+  }
+  _setupCodeModeConnector() {
+    logger.debug("Code mode connector initialized as internal meta server");
+    const connector = new CodeModeConnector(this);
+    const session = new MCPSession(connector);
+    this.sessions["code_mode"] = session;
+    this.activeSessions.push("code_mode");
+  }
+  _ensureCodeExecutor() {
+    if (!this._codeExecutor) {
+      const config = this._codeExecutorConfig;
+      if (config instanceof BaseCodeExecutor) {
+        this._codeExecutor = config;
+      } else if (typeof config === "function") {
+        this._customCodeExecutor = config;
+        throw new Error(
+          "Custom executor function should be handled in executeCode"
+        );
+      } else if (config === "e2b") {
+        const opts = this._executorOptions;
+        if (!opts?.apiKey) {
+          logger.warn("E2B executor requires apiKey. Falling back to VM.");
+          try {
+            this._codeExecutor = new VMCodeExecutor(
+              this,
+              this._executorOptions
+            );
+          } catch (error) {
+            throw new Error(
+              "VM executor is not available in this environment and E2B API key is not provided. Please provide an E2B API key or run in a Node.js environment."
+            );
+          }
+        } else {
+          this._codeExecutor = new E2BCodeExecutor(this, opts);
+        }
+      } else {
+        try {
+          this._codeExecutor = new VMCodeExecutor(
+            this,
+            this._executorOptions
+          );
+        } catch (error) {
+          const e2bOpts = this._executorOptions;
+          const e2bApiKey = e2bOpts?.apiKey || process.env.E2B_API_KEY;
+          if (e2bApiKey) {
+            logger.info(
+              "VM executor not available in this environment. Falling back to E2B."
+            );
+            this._codeExecutor = new E2BCodeExecutor(this, {
+              ...e2bOpts,
+              apiKey: e2bApiKey
+            });
+          } else {
+            throw new Error(
+              "VM executor is not available in this environment. Please provide an E2B API key via executorOptions or E2B_API_KEY environment variable, or run in a Node.js environment."
+            );
+          }
+        }
+      }
+    }
+    return this._codeExecutor;
+  }
+  /**
+   * Executes JavaScript/TypeScript code in a sandboxed environment.
+   *
+   * This method is only available when code mode is enabled. It executes the
+   * provided code in an isolated environment (VM or E2B sandbox) and returns
+   * the results including stdout, stderr, and return value.
+   *
+   * @param code - JavaScript/TypeScript code to execute
+   * @param timeout - Optional execution timeout in milliseconds
+   * @returns Execution result with output, errors, and return value
+   * @throws {Error} If code mode is not enabled
+   *
+   * @example
+   * ```typescript
+   * const client = new MCPClient('./config.json', { codeMode: true });
+   *
+   * const result = await client.executeCode(`
+   *   console.log('Hello, world!');
+   *   return 2 + 2;
+   * `);
+   *
+   * console.log(result.stdout);      // "Hello, world!\n"
+   * console.log(result.returnValue); // 4
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With timeout
+   * try {
+   *   const result = await client.executeCode('while(true) {}', 1000);
+   * } catch (error) {
+   *   console.log('Execution timed out');
+   * }
+   * ```
+   *
+   * @see {@link searchTools} for discovering available tools in code mode
+   */
+  async executeCode(code, timeout) {
+    if (!this.codeMode) {
+      throw new Error("Code execution mode is not enabled");
+    }
+    if (this._customCodeExecutor) {
+      return this._customCodeExecutor(code, timeout);
+    }
+    return this._ensureCodeExecutor().execute(code, timeout);
+  }
+  /**
+   * Searches for available tools across all MCP servers.
+   *
+   * This method is only available when code mode is enabled. It searches
+   * through tools from all active servers and returns matching tools based
+   * on the query and detail level.
+   *
+   * @param query - Optional search query to filter tools (defaults to empty string for all tools)
+   * @param detailLevel - Level of detail to return: "names", "descriptions", or "full"
+   * @returns Tool search results with matching tools
+   * @throws {Error} If code mode is not enabled
+   *
+   * @example
+   * ```typescript
+   * const client = new MCPClient('./config.json', { codeMode: true });
+   * await client.createAllSessions();
+   *
+   * // Search for all tools
+   * const allTools = await client.searchTools();
+   * console.log(`Found ${allTools.tools.length} tools`);
+   *
+   * // Search for specific tools
+   * const fileTools = await client.searchTools('file', 'descriptions');
+   * ```
+   *
+   * @see {@link executeCode} for executing code in code mode
+   */
+  async searchTools(query = "", detailLevel = "full") {
+    if (!this.codeMode) {
+      throw new Error("Code execution mode is not enabled");
+    }
+    return this._ensureCodeExecutor().createSearchToolsFunction()(
+      query,
+      detailLevel
+    );
+  }
+  /**
+   * Gets the names of all configured MCP servers (excluding internal servers).
+   *
+   * This method overrides the base implementation to filter out internal
+   * meta-servers like the code mode server, which is an implementation detail
+   * not intended for direct user interaction.
+   *
+   * @returns Array of user-configured server names
+   *
+   * @example
+   * ```typescript
+   * const names = client.getServerNames();
+   * console.log(`User servers: ${names.join(', ')}`);
+   * // Note: 'code_mode' is excluded even if code mode is enabled
+   * ```
+   *
+   * @see {@link activeSessions} for servers with active sessions
+   */
+  getServerNames() {
+    const isCodeModeEnabled = this.codeMode;
+    return super.getServerNames().filter((name) => {
+      return !isCodeModeEnabled || name !== "code_mode";
+    });
+  }
+  /**
+   * Closes the client and cleans up all resources.
+   *
+   * This method performs a complete cleanup by:
+   * 1. Shutting down code executors (VM or E2B sandboxes)
+   * 2. Closing all active MCP sessions
+   * 3. Releasing any other held resources
+   *
+   * Always call this method when you're done with the client to ensure
+   * proper resource cleanup, especially when using E2B sandboxes which
+   * have associated costs.
+   *
+   * @example
+   * ```typescript
+   * const client = new MCPClient('./config.json', { codeMode: true });
+   * await client.createAllSessions();
+   *
+   * // Do work...
+   *
+   * // Clean up
+   * await client.close();
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Use in shutdown handler
+   * process.on('SIGINT', async () => {
+   *   console.log('Shutting down...');
+   *   await client.close();
+   *   process.exit(0);
+   * });
+   * ```
+   *
+   * @see {@link closeAllSessions} for closing just the sessions
+   */
+  async close() {
+    if (this._codeExecutor) {
+      await this._codeExecutor.cleanup();
+      this._codeExecutor = null;
+    }
+    await this.closeAllSessions();
+  }
+};
+
+export {
+  MCPSession,
+  BaseMCPClient,
+  BaseCodeExecutor,
+  E2BCodeExecutor,
+  isVMAvailable,
+  VMCodeExecutor,
+  HttpConnector,
+  resolveCallbacks,
+  normalizeClientInfo,
+  loadConfigFile,
+  getDefaults,
+  applyDefaults,
+  acceptWithDefaults,
+  accept,
+  decline,
+  cancel,
+  reject,
+  validate,
+  MCPClient
+};