mcp-use 1.10.5 → 1.11.0-canary.10

package/dist/src/agents/index.cjs

@@ -35,9 +35,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 async function getNodeModules() {
   if (typeof process !== "undefined" && process.platform) {
     try {
-      const fs = await import("fs");
-      const path = await import("path");
-      return { fs: fs.default, path: path.default };
+      const fs2 = await import("fs");
+      const path2 = await import("path");
+      return { fs: fs2.default, path: path2.default };
     } catch {
       return { fs: null, path: null };
     }
@@ -198,7 +198,7 @@ var init_logging = __esm({
               timestamp({ format: "HH:mm:ss" }),
               this.getFormatter()
             ),
-            transports: []
+            transports: [new winston.transports.Console()]
           });
         }
         return this.instances[name];
@@ -1417,7 +1417,7 @@ __name(generateUUID, "generateUUID");
 init_logging();
 
 // src/version.ts
-var VERSION = "1.10.5";
+var VERSION = "1.11.0-canary.10";
 function getPackageVersion() {
   return VERSION;
 }
@@ -1738,26 +1738,26 @@ var Telemetry = class _Telemetry {
    * Get or create user ID from filesystem (Node.js/Bun)
    */
   _getUserIdFromFilesystem() {
-    const fs = require("fs");
+    const fs2 = require("fs");
     const os = require("os");
-    const path = require("path");
+    const path2 = require("path");
     if (!this._userIdPath) {
-      this._userIdPath = path.join(
-        this._getCacheHome(os, path),
+      this._userIdPath = path2.join(
+        this._getCacheHome(os, path2),
         "mcp_use_3",
         "telemetry_user_id"
       );
     }
-    const isFirstTime = !fs.existsSync(this._userIdPath);
+    const isFirstTime = !fs2.existsSync(this._userIdPath);
     if (isFirstTime) {
       logger.debug(`Creating user ID path: ${this._userIdPath}`);
-      fs.mkdirSync(path.dirname(this._userIdPath), { recursive: true });
+      fs2.mkdirSync(path2.dirname(this._userIdPath), { recursive: true });
       const newUserId = generateUUID();
-      fs.writeFileSync(this._userIdPath, newUserId);
+      fs2.writeFileSync(this._userIdPath, newUserId);
       logger.debug(`User ID path created: ${this._userIdPath}`);
       return newUserId;
     }
-    return fs.readFileSync(this._userIdPath, "utf-8").trim();
+    return fs2.readFileSync(this._userIdPath, "utf-8").trim();
   }
   /**
    * Get or create user ID from localStorage (Browser)
@@ -1776,9 +1776,9 @@ var Telemetry = class _Telemetry {
       return `session-${generateUUID()}`;
     }
   }
-  _getCacheHome(os, path) {
+  _getCacheHome(os, path2) {
     const envVar = process.env.XDG_CACHE_HOME;
-    if (envVar && path.isAbsolute(envVar)) {
+    if (envVar && path2.isAbsolute(envVar)) {
       return envVar;
     }
     const platform = process.platform;
@@ -1788,11 +1788,11 @@ var Telemetry = class _Telemetry {
       if (appdata) {
         return appdata;
       }
-      return path.join(homeDir, "AppData", "Local");
+      return path2.join(homeDir, "AppData", "Local");
     } else if (platform === "darwin") {
-      return path.join(homeDir, "Library", "Caches");
+      return path2.join(homeDir, "Library", "Caches");
     } else {
-      return path.join(homeDir, ".cache");
+      return path2.join(homeDir, ".cache");
     }
   }
   async capture(event) {
@@ -1866,12 +1866,12 @@ var Telemetry = class _Telemetry {
       return;
     }
     try {
-      const fs = require("fs");
-      const path = require("path");
+      const fs2 = require("fs");
+      const path2 = require("path");
       const os = require("os");
       if (!this._versionDownloadPath) {
-        this._versionDownloadPath = path.join(
-          this._getCacheHome(os, path),
+        this._versionDownloadPath = path2.join(
+          this._getCacheHome(os, path2),
           "mcp_use",
           "download_version"
         );
@@ -1879,19 +1879,19 @@ var Telemetry = class _Telemetry {
       const currentVersion = getPackageVersion();
       let shouldTrack = false;
       let firstDownload = false;
-      if (!fs.existsSync(this._versionDownloadPath)) {
+      if (!fs2.existsSync(this._versionDownloadPath)) {
         shouldTrack = true;
         firstDownload = true;
-        fs.mkdirSync(path.dirname(this._versionDownloadPath), {
+        fs2.mkdirSync(path2.dirname(this._versionDownloadPath), {
           recursive: true
         });
-        fs.writeFileSync(this._versionDownloadPath, currentVersion);
+        fs2.writeFileSync(this._versionDownloadPath, currentVersion);
       } else {
-        const savedVersion = fs.readFileSync(this._versionDownloadPath, "utf-8").trim();
+        const savedVersion = fs2.readFileSync(this._versionDownloadPath, "utf-8").trim();
         if (currentVersion > savedVersion) {
           shouldTrack = true;
           firstDownload = false;
-          fs.writeFileSync(this._versionDownloadPath, currentVersion);
+          fs2.writeFileSync(this._versionDownloadPath, currentVersion);
         }
       }
       if (shouldTrack) {
@@ -2084,6 +2084,480 @@ var Telemetry = class _Telemetry {
     }
   }
 };
+var Tel = Telemetry;
+
+// src/connectors/base.ts
+var BaseConnector = class {
+  static {
+    __name(this, "BaseConnector");
+  }
+  client = null;
+  connectionManager = null;
+  toolsCache = null;
+  capabilitiesCache = null;
+  serverInfoCache = null;
+  connected = false;
+  opts;
+  notificationHandlers = [];
+  rootsCache = [];
+  constructor(opts = {}) {
+    this.opts = opts;
+    if (opts.roots) {
+      this.rootsCache = [...opts.roots];
+    }
+  }
+  /**
+   * Track connector initialization event
+   * Should be called by subclasses after successful connection
+   */
+  trackConnectorInit(data) {
+    const connectorType = this.constructor.name;
+    Telemetry.getInstance().trackConnectorInit({
+      connectorType,
+      ...data
+    }).catch((e) => logger.debug(`Failed to track connector init: ${e}`));
+  }
+  /**
+   * Register a handler for server notifications
+   *
+   * @param handler - Function to call when a notification is received
+   *
+   * @example
+   * ```typescript
+   * connector.onNotification((notification) => {
+   *   console.log(`Received: ${notification.method}`, notification.params);
+   * });
+   * ```
+   */
+  onNotification(handler) {
+    this.notificationHandlers.push(handler);
+    if (this.client) {
+      this.setupNotificationHandler();
+    }
+  }
+  /**
+   * Internal: wire notification handlers to the SDK client
+   * Includes automatic handling for list_changed notifications per MCP spec
+   */
+  setupNotificationHandler() {
+    if (!this.client) return;
+    this.client.fallbackNotificationHandler = async (notification) => {
+      switch (notification.method) {
+        case "notifications/tools/list_changed":
+          await this.refreshToolsCache();
+          break;
+        case "notifications/resources/list_changed":
+          await this.onResourcesListChanged();
+          break;
+        case "notifications/prompts/list_changed":
+          await this.onPromptsListChanged();
+          break;
+        default:
+          break;
+      }
+      for (const handler of this.notificationHandlers) {
+        try {
+          await handler(notification);
+        } catch (err) {
+          logger.error("Error in notification handler:", err);
+        }
+      }
+    };
+  }
+  /**
+   * Auto-refresh tools cache when server sends tools/list_changed notification
+   */
+  async refreshToolsCache() {
+    if (!this.client) return;
+    try {
+      logger.debug(
+        "[Auto] Refreshing tools cache due to list_changed notification"
+      );
+      const result = await this.client.listTools();
+      this.toolsCache = result.tools ?? [];
+      logger.debug(
+        `[Auto] Refreshed tools cache: ${this.toolsCache.length} tools`
+      );
+    } catch (err) {
+      logger.warn("[Auto] Failed to refresh tools cache:", err);
+    }
+  }
+  /**
+   * Called when server sends resources/list_changed notification
+   * Resources aren't cached by default, but we log for user awareness
+   */
+  async onResourcesListChanged() {
+    logger.debug(
+      "[Auto] Resources list changed - clients should re-fetch if needed"
+    );
+  }
+  /**
+   * Called when server sends prompts/list_changed notification
+   * Prompts aren't cached by default, but we log for user awareness
+   */
+  async onPromptsListChanged() {
+    logger.debug(
+      "[Auto] Prompts list changed - clients should re-fetch if needed"
+    );
+  }
+  /**
+   * 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 connector.setRoots([
+   *   { uri: "file:///home/user/project", name: "My Project" },
+   *   { uri: "file:///home/user/data" }
+   * ]);
+   * ```
+   */
+  async setRoots(roots) {
+    this.rootsCache = [...roots];
+    if (this.client) {
+      logger.debug(
+        `Sending roots/list_changed notification with ${roots.length} root(s)`
+      );
+      await this.client.sendRootsListChanged();
+    }
+  }
+  /**
+   * Get the current roots.
+   */
+  getRoots() {
+    return [...this.rootsCache];
+  }
+  /**
+   * Internal: set up roots/list request handler.
+   * This is called after the client connects to register the handler for server requests.
+   */
+  setupRootsHandler() {
+    if (!this.client) return;
+    this.client.setRequestHandler(
+      import_types.ListRootsRequestSchema,
+      async (_request, _extra) => {
+        logger.debug(
+          `Server requested roots list, returning ${this.rootsCache.length} root(s)`
+        );
+        return { roots: this.rootsCache };
+      }
+    );
+  }
+  /**
+   * Internal: set up sampling/createMessage request handler.
+   * This is called after the client connects to register the handler for sampling requests.
+   */
+  setupSamplingHandler() {
+    if (!this.client) {
+      logger.debug("setupSamplingHandler: No client available");
+      return;
+    }
+    if (!this.opts.samplingCallback) {
+      logger.debug("setupSamplingHandler: No sampling callback provided");
+      return;
+    }
+    logger.debug("setupSamplingHandler: Setting up sampling request handler");
+    this.client.setRequestHandler(
+      import_types.CreateMessageRequestSchema,
+      async (request, _extra) => {
+        logger.debug("Server requested sampling, forwarding to callback");
+        return await this.opts.samplingCallback(request.params);
+      }
+    );
+    logger.debug(
+      "setupSamplingHandler: Sampling handler registered successfully"
+    );
+  }
+  /**
+   * Internal: set up elicitation/create request handler.
+   * This is called after the client connects to register the handler for elicitation requests.
+   */
+  setupElicitationHandler() {
+    if (!this.client) {
+      logger.debug("setupElicitationHandler: No client available");
+      return;
+    }
+    if (!this.opts.elicitationCallback) {
+      logger.debug("setupElicitationHandler: No elicitation callback provided");
+      return;
+    }
+    logger.debug(
+      "setupElicitationHandler: Setting up elicitation request handler"
+    );
+    this.client.setRequestHandler(
+      import_types.ElicitRequestSchema,
+      async (request, _extra) => {
+        logger.debug("Server requested elicitation, forwarding to callback");
+        return await this.opts.elicitationCallback(request.params);
+      }
+    );
+    logger.debug(
+      "setupElicitationHandler: Elicitation handler registered successfully"
+    );
+  }
+  /** Disconnect and release resources. */
+  async disconnect() {
+    if (!this.connected) {
+      logger.debug("Not connected to MCP implementation");
+      return;
+    }
+    logger.debug("Disconnecting from MCP implementation");
+    await this.cleanupResources();
+    this.connected = false;
+    logger.debug("Disconnected from MCP implementation");
+  }
+  /** Check if the client is connected */
+  get isClientConnected() {
+    return this.client != null;
+  }
+  /**
+   * Initialise the MCP session **after** `connect()` has succeeded.
+   *
+   * In the SDK, `Client.connect(transport)` automatically performs the
+   * protocol‑level `initialize` handshake, so we only need to cache the list of
+   * tools and expose some server info.
+   */
+  async initialize(defaultRequestOptions = this.opts.defaultRequestOptions ?? {}) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Caching server capabilities & tools");
+    const capabilities = this.client.getServerCapabilities();
+    this.capabilitiesCache = capabilities || null;
+    const serverInfo = this.client.getServerVersion();
+    this.serverInfoCache = serverInfo || null;
+    const listToolsRes = await this.client.listTools(
+      void 0,
+      defaultRequestOptions
+    );
+    this.toolsCache = listToolsRes.tools ?? [];
+    logger.debug(`Fetched ${this.toolsCache.length} tools from server`);
+    logger.debug("Server capabilities:", capabilities);
+    logger.debug("Server info:", serverInfo);
+    return capabilities;
+  }
+  /** Lazily expose the cached tools list. */
+  get tools() {
+    if (!this.toolsCache) {
+      throw new Error("MCP client is not initialized; call initialize() first");
+    }
+    return this.toolsCache;
+  }
+  /** Expose cached server capabilities. */
+  get serverCapabilities() {
+    return this.capabilitiesCache || {};
+  }
+  /** Expose cached server info. */
+  get serverInfo() {
+    return this.serverInfoCache;
+  }
+  /** Call a tool on the server. */
+  async callTool(name, args, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    const enhancedOptions = options ? { ...options } : void 0;
+    if (enhancedOptions?.resetTimeoutOnProgress && !enhancedOptions.onprogress) {
+      enhancedOptions.onprogress = () => {
+      };
+      logger.debug(
+        `[BaseConnector] Added onprogress callback for tool '${name}' to enable progressToken`
+      );
+    }
+    logger.debug(`Calling tool '${name}' with args`, args);
+    const res = await this.client.callTool(
+      { name, arguments: args },
+      void 0,
+      enhancedOptions
+    );
+    logger.debug(`Tool '${name}' returned`, res);
+    return res;
+  }
+  /**
+   * 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
+   */
+  async listTools(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    const result = await this.client.listTools(void 0, options);
+    return result.tools ?? [];
+  }
+  /**
+   * 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
+   */
+  async listResources(cursor, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Listing resources", cursor ? `with cursor: ${cursor}` : "");
+    return await this.client.listResources({ cursor }, options);
+  }
+  /**
+   * List all resources from the server, automatically handling pagination
+   *
+   * @param options - Request options
+   * @returns Complete list of all resources
+   */
+  async listAllResources(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    if (!this.capabilitiesCache?.resources) {
+      logger.debug("Server does not advertise resources capability, skipping");
+      return { resources: [] };
+    }
+    try {
+      logger.debug("Listing all resources (with auto-pagination)");
+      const allResources = [];
+      let cursor = void 0;
+      do {
+        const result = await this.client.listResources({ cursor }, options);
+        allResources.push(...result.resources || []);
+        cursor = result.nextCursor;
+      } while (cursor);
+      return { resources: allResources };
+    } catch (err) {
+      const error = err;
+      if (error.code === -32601) {
+        logger.debug("Server advertised resources but method not found");
+        return { resources: [] };
+      }
+      throw err;
+    }
+  }
+  /**
+   * List resource templates from the server
+   *
+   * @param options - Request options
+   * @returns List of available resource templates
+   */
+  async listResourceTemplates(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Listing resource templates");
+    return await this.client.listResourceTemplates(void 0, options);
+  }
+  /** Read a resource by URI. */
+  async readResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Reading resource ${uri}`);
+    const res = await this.client.readResource({ uri }, options);
+    return res;
+  }
+  /**
+   * Subscribe to resource updates
+   *
+   * @param uri - URI of the resource to subscribe to
+   * @param options - Request options
+   */
+  async subscribeToResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Subscribing to resource: ${uri}`);
+    return await this.client.subscribeResource({ uri }, options);
+  }
+  /**
+   * Unsubscribe from resource updates
+   *
+   * @param uri - URI of the resource to unsubscribe from
+   * @param options - Request options
+   */
+  async unsubscribeFromResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Unsubscribing from resource: ${uri}`);
+    return await this.client.unsubscribeResource({ uri }, options);
+  }
+  async listPrompts() {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    if (!this.capabilitiesCache?.prompts) {
+      logger.debug("Server does not advertise prompts capability, skipping");
+      return { prompts: [] };
+    }
+    try {
+      logger.debug("Listing prompts");
+      return await this.client.listPrompts();
+    } catch (err) {
+      const error = err;
+      if (error.code === -32601) {
+        logger.debug("Server advertised prompts but method not found");
+        return { prompts: [] };
+      }
+      throw err;
+    }
+  }
+  async getPrompt(name, args) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Getting prompt ${name}`);
+    return await this.client.getPrompt({ name, arguments: args });
+  }
+  /** Send a raw request through the client. */
+  async request(method, params = null, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Sending raw request '${method}' with params`, params);
+    return await this.client.request(
+      { method, params: params ?? {} },
+      void 0,
+      options
+    );
+  }
+  /**
+   * Helper to tear down the client & connection manager safely.
+   */
+  async cleanupResources() {
+    const issues = [];
+    if (this.client) {
+      try {
+        if (typeof this.client.close === "function") {
+          await this.client.close();
+        }
+      } catch (e) {
+        const msg = `Error closing client: ${e}`;
+        logger.warn(msg);
+        issues.push(msg);
+      } finally {
+        this.client = null;
+      }
+    }
+    if (this.connectionManager) {
+      try {
+        await this.connectionManager.stop();
+      } catch (e) {
+        const msg = `Error stopping connection manager: ${e}`;
+        logger.warn(msg);
+        issues.push(msg);
+      } finally {
+        this.connectionManager = null;
+      }
+    }
+    this.toolsCache = null;
+    if (issues.length) {
+      logger.warn(`Resource cleanup finished with ${issues.length} issue(s)`);
+    }
+  }
+};
 
 // src/client/connectors/codeMode.ts
 var CODE_MODE_AGENT_PROMPT = `
@@ -2173,6 +2647,110 @@ return {
 
 Remember: Always discover and understand available tools before attempting to use them in code execution.
 `;
+var CodeModeConnector = class extends BaseConnector {
+  static {
+    __name(this, "CodeModeConnector");
+  }
+  mcpClient;
+  _tools;
+  constructor(client) {
+    super();
+    this.mcpClient = client;
+    this.connected = true;
+    this._tools = this._createToolsList();
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  get publicIdentifier() {
+    return { name: "code_mode", version: "1.0.0" };
+  }
+  _createToolsList() {
+    return [
+      {
+        name: "execute_code",
+        description: "Execute JavaScript/TypeScript code with access to MCP tools. This is the PRIMARY way to interact with MCP servers in code mode. Write code that discovers tools using search_tools(), calls tools as async functions (e.g., await github.get_pull_request(...)), processes data efficiently, and returns results. Use 'await' for async operations and 'return' to return values. Available in code: search_tools(), __tool_namespaces, and server.tool_name() functions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "JavaScript/TypeScript code to execute. Use 'await' for async operations. Use 'return' to return a value. Available: search_tools(), server.tool_name(), __tool_namespaces"
+            },
+            timeout: {
+              type: "number",
+              description: "Execution timeout in milliseconds",
+              default: 3e4
+            }
+          },
+          required: ["code"]
+        }
+      },
+      {
+        name: "search_tools",
+        description: "Search and discover available MCP tools across all servers. Use this to find out what tools are available before writing code. Returns tool information including names, descriptions, and schemas. Can filter by query and control detail level.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query to filter tools by name or description",
+              default: ""
+            },
+            detail_level: {
+              type: "string",
+              description: "Detail level: 'names', 'descriptions', or 'full'",
+              enum: ["names", "descriptions", "full"],
+              default: "full"
+            }
+          }
+        }
+      }
+    ];
+  }
+  // Override tools getter to return static list immediately
+  get tools() {
+    return this._tools;
+  }
+  async initialize() {
+    this.toolsCache = this._tools;
+    return { capabilities: {}, version: "1.0.0" };
+  }
+  async callTool(name, args) {
+    if (name === "execute_code") {
+      const code = args.code;
+      const timeout = args.timeout || 3e4;
+      const result = await this.mcpClient.executeCode(code, timeout);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    } else if (name === "search_tools") {
+      const query = args.query || "";
+      const detailLevel = args.detail_level;
+      const result = await this.mcpClient.searchTools(
+        query,
+        detailLevel && detailLevel in ["names", "descriptions", "full"] ? detailLevel : "full"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+  }
+};
 
 // src/client/prompts.ts
 var PROMPTS = {
@@ -2974,6 +3552,98 @@ var BaseAdapter = class {
     logger.debug(`Available tools: ${tools.length}`);
     return tools;
   }
+  /**
+   * Dynamically load resources for a specific connector.
+   *
+   * @param connector The connector to load resources for.
+   * @returns         The list of resources that were loaded in the target framework's format.
+   */
+  async loadResourcesForConnector(connector) {
+    const connectorResources = [];
+    const success = await this.ensureConnectorInitialized(connector);
+    if (!success) {
+      return [];
+    }
+    try {
+      const resourcesResult = await connector.listAllResources();
+      const resources = resourcesResult?.resources || [];
+      if (this.convertResource) {
+        for (const resource of resources) {
+          const converted = this.convertResource(resource, connector);
+          if (converted) {
+            connectorResources.push(converted);
+          }
+        }
+      }
+      logger.debug(
+        `Loaded ${connectorResources.length} new resources for connector: ${connectorResources.map((r) => r?.name ?? String(r)).join(", ")}`
+      );
+    } catch (err) {
+      logger.warn(`Error loading resources for connector: ${err}`);
+    }
+    return connectorResources;
+  }
+  /**
+   * Dynamically load prompts for a specific connector.
+   *
+   * @param connector The connector to load prompts for.
+   * @returns         The list of prompts that were loaded in the target framework's format.
+   */
+  async loadPromptsForConnector(connector) {
+    const connectorPrompts = [];
+    const success = await this.ensureConnectorInitialized(connector);
+    if (!success) {
+      return [];
+    }
+    try {
+      const promptsResult = await connector.listPrompts();
+      const prompts = promptsResult?.prompts || [];
+      if (this.convertPrompt) {
+        for (const prompt of prompts) {
+          const converted = this.convertPrompt(prompt, connector);
+          if (converted) {
+            connectorPrompts.push(converted);
+          }
+        }
+      }
+      logger.debug(
+        `Loaded ${connectorPrompts.length} new prompts for connector: ${connectorPrompts.map((p) => p?.name ?? String(p)).join(", ")}`
+      );
+    } catch (err) {
+      logger.warn(`Error loading prompts for connector: ${err}`);
+    }
+    return connectorPrompts;
+  }
+  /**
+   * Create resources from MCP resources in all provided connectors.
+   *
+   * @param connectors List of MCP connectors to create resources from.
+   * @returns         A promise that resolves with all converted resources.
+   */
+  async createResourcesFromConnectors(connectors) {
+    const resources = [];
+    for (const connector of connectors) {
+      const connectorResources = await this.loadResourcesForConnector(connector);
+      resources.push(...connectorResources);
+    }
+    logger.debug(`Available resources: ${resources.length}`);
+    return resources;
+  }
+  /**
+   * Create prompts from MCP prompts in all provided connectors.
+   *
+   * @param connectors List of MCP connectors to create prompts from.
+   * @returns         A promise that resolves with all converted prompts.
+   */
+  async createPromptsFromConnectors(connectors) {
+    const prompts = [];
+    for (const connector of connectors) {
+      const connectorPrompts = await this.loadPromptsForConnector(connector);
+      prompts.push(...connectorPrompts);
+    }
+    logger.debug(`Available prompts: ${prompts.length}`);
+    return prompts;
+  }
   /**
    * Check if a connector is initialized and has tools.
    *
@@ -3000,57 +3670,2062 @@ var BaseAdapter = class {
         return false;
       }
     }
-    return true;
+    return true;
+  }
+};
+
+// src/adapters/langchain_adapter.ts
+function schemaToZod(schema) {
+  try {
+    return JSONSchemaToZod.convert(schema);
+  } catch (err) {
+    logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
+    return import_zod2.z.any();
+  }
+}
+__name(schemaToZod, "schemaToZod");
+var LangChainAdapter = class extends BaseAdapter {
+  static {
+    __name(this, "LangChainAdapter");
+  }
+  constructor(disallowedTools = []) {
+    super(disallowedTools);
+  }
+  /**
+   * Convert a single MCP tool specification into a LangChainJS structured tool.
+   */
+  convertTool(mcpTool, connector) {
+    if (this.disallowedTools.includes(mcpTool.name)) {
+      return null;
+    }
+    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : import_zod2.z.object({}).optional();
+    const tool = new import_tools.DynamicStructuredTool({
+      name: mcpTool.name ?? "NO NAME",
+      description: mcpTool.description ?? "",
+      // Blank is acceptable but discouraged.
+      schema: argsSchema,
+      func: /* @__PURE__ */ __name(async (input) => {
+        logger.debug(
+          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
+        );
+        try {
+          const result = await connector.callTool(
+            mcpTool.name,
+            input
+          );
+          return JSON.stringify(result);
+        } catch (err) {
+          logger.error(`Error executing MCP tool: ${err.message}`);
+          return `Error executing MCP tool: ${String(err)}`;
+        }
+      }, "func")
+    });
+    return tool;
+  }
+  /**
+   * Convert a single MCP resource into a LangChainJS structured tool.
+   * Each resource becomes an async tool that returns its content when called.
+   */
+  convertResource(mcpResource, connector) {
+    const sanitizeName = /* @__PURE__ */ __name((name) => {
+      return name.replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
+    }, "sanitizeName");
+    const resourceName = sanitizeName(
+      mcpResource.name || `resource_${mcpResource.uri}`
+    );
+    const resourceUri = mcpResource.uri;
+    const tool = new import_tools.DynamicStructuredTool({
+      name: resourceName,
+      description: mcpResource.description || `Return the content of the resource located at URI ${resourceUri}.`,
+      schema: import_zod2.z.object({}).optional(),
+      // Resources take no arguments
+      func: /* @__PURE__ */ __name(async () => {
+        logger.debug(`Resource tool: "${resourceName}" called`);
+        try {
+          const result = await connector.readResource(resourceUri);
+          if (result.contents && result.contents.length > 0) {
+            return result.contents.map((content) => {
+              if (typeof content === "string") {
+                return content;
+              }
+              if (content.text) {
+                return content.text;
+              }
+              if (content.uri) {
+                return content.uri;
+              }
+              return JSON.stringify(content);
+            }).join("\n");
+          }
+          return "Resource is empty or unavailable";
+        } catch (err) {
+          logger.error(`Error reading resource: ${err.message}`);
+          return `Error reading resource: ${String(err)}`;
+        }
+      }, "func")
+    });
+    return tool;
+  }
+  /**
+   * Convert a single MCP prompt into a LangChainJS structured tool.
+   * The resulting tool executes getPrompt on the connector with the prompt's name
+   * and the user-provided arguments (if any).
+   */
+  convertPrompt(mcpPrompt, connector) {
+    let argsSchema = import_zod2.z.object({}).optional();
+    if (mcpPrompt.arguments && mcpPrompt.arguments.length > 0) {
+      const schemaFields = {};
+      for (const arg of mcpPrompt.arguments) {
+        const zodType = import_zod2.z.string();
+        if (arg.required !== false) {
+          schemaFields[arg.name] = zodType;
+        } else {
+          schemaFields[arg.name] = zodType.optional();
+        }
+      }
+      argsSchema = Object.keys(schemaFields).length > 0 ? import_zod2.z.object(schemaFields) : import_zod2.z.object({}).optional();
+    }
+    const tool = new import_tools.DynamicStructuredTool({
+      name: mcpPrompt.name,
+      description: mcpPrompt.description || "",
+      schema: argsSchema,
+      func: /* @__PURE__ */ __name(async (input) => {
+        logger.debug(
+          `Prompt tool: "${mcpPrompt.name}" called with args: ${JSON.stringify(input)}`
+        );
+        try {
+          const result = await connector.getPrompt(mcpPrompt.name, input);
+          if (result.messages && result.messages.length > 0) {
+            return result.messages.map((msg) => {
+              if (typeof msg === "string") {
+                return msg;
+              }
+              if (msg.content) {
+                return typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+              }
+              return JSON.stringify(msg);
+            }).join("\n");
+          }
+          return "Prompt returned no messages";
+        } catch (err) {
+          logger.error(`Error getting prompt: ${err.message}`);
+          return `Error getting prompt: ${String(err)}`;
+        }
+      }, "func")
+    });
+    return tool;
+  }
+};
+
+// src/client.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// src/client/base.ts
+init_logging();
+
+// src/session.ts
+var MCPSession = class {
+  static {
+    __name(this, "MCPSession");
+  }
+  connector;
+  autoConnect;
+  constructor(connector, autoConnect = true) {
+    this.connector = connector;
+    this.autoConnect = autoConnect;
+  }
+  async connect() {
+    await this.connector.connect();
+  }
+  async disconnect() {
+    await this.connector.disconnect();
+  }
+  async initialize() {
+    if (!this.isConnected && this.autoConnect) {
+      await this.connect();
+    }
+    await this.connector.initialize();
+  }
+  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);
+  }
+  /**
+   * Get the current 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);
+  }
+  /**
+   * 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");
+  }
+  config = {};
+  sessions = {};
+  activeSessions = [];
+  constructor(config) {
+    if (config) {
+      this.config = config;
+    }
+  }
+  static fromDict(_cfg) {
+    throw new Error("fromDict must be implemented by concrete class");
+  }
+  addServer(name, serverConfig) {
+    this.config.mcpServers = this.config.mcpServers || {};
+    this.config.mcpServers[name] = serverConfig;
+    Tel.getInstance().trackClientAddServer(name, serverConfig);
+  }
+  removeServer(name) {
+    if (this.config.mcpServers?.[name]) {
+      delete this.config.mcpServers[name];
+      this.activeSessions = this.activeSessions.filter((n) => n !== name);
+      Tel.getInstance().trackClientRemoveServer(name);
+    }
+  }
+  getServerNames() {
+    return Object.keys(this.config.mcpServers ?? {});
+  }
+  getServerConfig(name) {
+    return this.config.mcpServers?.[name];
+  }
+  getConfig() {
+    return this.config ?? {};
+  }
+  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 = 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;
+  }
+  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;
+  }
+  getSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      return null;
+    }
+    return session;
+  }
+  requireSession(serverName) {
+    const session = this.sessions[serverName];
+    if (!session) {
+      throw new Error(
+        `Session '${serverName}' not found. Available sessions: ${this.activeSessions.join(", ") || "none"}`
+      );
+    }
+    return session;
+  }
+  getAllActiveSessions() {
+    return Object.fromEntries(
+      this.activeSessions.map((n) => [n, this.sessions[n]])
+    );
+  }
+  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 {
+      delete this.sessions[serverName];
+      this.activeSessions = this.activeSessions.filter((n) => n !== serverName);
+    }
+  }
+  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
+init_logging();
+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
+init_logging();
+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
+init_logging();
+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");
+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/config.ts
+var import_node_fs = require("fs");
+
+// src/connectors/http.ts
+var import_client = require("@mcp-use/modelcontextprotocol-sdk/client/index.js");
+var import_streamableHttp = require("@mcp-use/modelcontextprotocol-sdk/client/streamableHttp.js");
+init_logging();
+
+// src/task_managers/sse.ts
+var import_sse = require("@mcp-use/modelcontextprotocol-sdk/client/sse.js");
+init_logging();
+
+// src/task_managers/base.ts
+init_logging();
+var ConnectionManager = class {
+  static {
+    __name(this, "ConnectionManager");
+  }
+  _readyPromise;
+  _readyResolver;
+  _donePromise;
+  _doneResolver;
+  _exception = null;
+  _connection = null;
+  _task = null;
+  _abortController = null;
+  constructor() {
+    this.reset();
+  }
+  /**
+   * Start the connection manager and establish a connection.
+   *
+   * @returns The established connection.
+   * @throws If the connection cannot be established.
+   */
+  async start() {
+    this.reset();
+    logger.debug(`Starting ${this.constructor.name}`);
+    this._task = this.connectionTask();
+    await this._readyPromise;
+    if (this._exception) {
+      throw this._exception;
+    }
+    if (this._connection === null) {
+      throw new Error("Connection was not established");
+    }
+    return this._connection;
+  }
+  /**
+   * Stop the connection manager and close the connection.
+   */
+  async stop() {
+    if (this._task && this._abortController) {
+      logger.debug(`Cancelling ${this.constructor.name} task`);
+      this._abortController.abort();
+      try {
+        await this._task;
+      } catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
+          logger.debug(`${this.constructor.name} task aborted successfully`);
+        } else {
+          logger.warn(`Error stopping ${this.constructor.name} task: ${e}`);
+        }
+      }
+    }
+    await this._donePromise;
+    logger.debug(`${this.constructor.name} task completed`);
+  }
+  /**
+   * Reset all internal state.
+   */
+  reset() {
+    this._readyPromise = new Promise((res) => this._readyResolver = res);
+    this._donePromise = new Promise((res) => this._doneResolver = res);
+    this._exception = null;
+    this._connection = null;
+    this._task = null;
+    this._abortController = new AbortController();
+  }
+  /**
+   * The background task responsible for establishing and maintaining the
+   * connection until it is cancelled.
+   */
+  async connectionTask() {
+    logger.debug(`Running ${this.constructor.name} task`);
+    try {
+      this._connection = await this.establishConnection();
+      logger.debug(`${this.constructor.name} connected successfully`);
+      this._readyResolver();
+      await this.waitForAbort();
+    } catch (err) {
+      this._exception = err;
+      logger.error(`Error in ${this.constructor.name} task: ${err}`);
+      this._readyResolver();
+    } finally {
+      if (this._connection !== null) {
+        try {
+          await this.closeConnection(this._connection);
+        } catch (closeErr) {
+          logger.warn(
+            `Error closing connection in ${this.constructor.name}: ${closeErr}`
+          );
+        }
+        this._connection = null;
+      }
+      this._doneResolver();
+    }
+  }
+  /**
+   * Helper that returns a promise which resolves when the abort signal fires.
+   */
+  async waitForAbort() {
+    return new Promise((_resolve, _reject) => {
+      if (!this._abortController) {
+        return;
+      }
+      const signal = this._abortController.signal;
+      if (signal.aborted) {
+        _resolve();
+        return;
+      }
+      const onAbort = /* @__PURE__ */ __name(() => {
+        signal.removeEventListener("abort", onAbort);
+        _resolve();
+      }, "onAbort");
+      signal.addEventListener("abort", onAbort);
+    });
+  }
+};
+
+// src/task_managers/sse.ts
+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 import_sse.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.info(`[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;
+  clientInfo;
+  preferSse;
+  transportType = null;
+  streamableTransport = null;
+  constructor(baseUrl, opts = {}) {
+    super(opts);
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.headers = { ...opts.headers ?? {} };
+    if (opts.authToken) {
+      this.headers.Authorization = `Bearer ${opts.authToken}`;
+    }
+    this.timeout = opts.timeout ?? 3e4;
+    this.sseReadTimeout = opts.sseReadTimeout ?? 3e5;
+    this.clientInfo = opts.clientInfo ?? {
+      name: "http-connector",
+      version: "1.0.0"
+    };
+    this.preferSse = opts.preferSse ?? false;
+  }
+  /** 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.info("\u{1F504} Attempting streamable HTTP transport...");
+      await this.connectWithStreamableHttp(baseUrl);
+      logger.info("\u2705 Successfully connected via streamable HTTP");
+    } catch (err) {
+      let fallbackReason = "Unknown error";
+      let is401Error = false;
+      if (err instanceof import_streamableHttp.StreamableHTTPError) {
+        const streamableErr = err;
+        is401Error = streamableErr.code === 401;
+        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);
+        }
+      } else 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);
+        }
+      }
+      if (is401Error) {
+        logger.info("Authentication required - skipping SSE fallback");
+        await this.cleanupResources();
+        const authError = new Error("Authentication required");
+        authError.code = 401;
+        throw authError;
+      }
+      logger.info("\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;
+        }
+        throw new Error(
+          "Could not connect to server with any available transport"
+        );
+      }
+    }
+  }
+  async connectWithStreamableHttp(baseUrl) {
+    try {
+      const streamableTransport = new import_streamableHttp.StreamableHTTPClientTransport(
+        new URL(baseUrl),
+        {
+          authProvider: this.opts.authProvider,
+          // ← Pass OAuth provider to SDK
+          requestInit: {
+            headers: this.headers
+          },
+          // Pass through reconnection options
+          reconnectionOptions: {
+            maxReconnectionDelay: 3e4,
+            initialReconnectionDelay: 1e3,
+            reconnectionDelayGrowFactor: 1.5,
+            maxRetries: 2
+          }
+          // 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.opts.clientOptions || {},
+        capabilities: {
+          ...this.opts.clientOptions?.capabilities || {},
+          roots: { listChanged: true },
+          // Always advertise roots capability
+          // Add sampling capability if callback is provided
+          ...this.opts.samplingCallback ? { sampling: {} } : {},
+          // Add elicitation capability if callback is provided
+          ...this.opts.elicitationCallback ? { elicitation: { form: {}, url: {} } } : {}
+        }
+      };
+      logger.debug(
+        `Creating Client with capabilities:`,
+        JSON.stringify(clientOptions.capabilities, null, 2)
+      );
+      this.client = new import_client.Client(this.clientInfo, clientOptions);
+      this.setupRootsHandler();
+      logger.debug("Roots handler registered before connect");
+      try {
+        await this.client.connect(transport, {
+          timeout: Math.min(this.timeout, 3e3)
+        });
+        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.terminateSession();
+              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.opts.clientOptions || {},
+        capabilities: {
+          ...this.opts.clientOptions?.capabilities || {},
+          roots: { listChanged: true },
+          // Always advertise roots capability
+          // Add sampling capability if callback is provided
+          ...this.opts.samplingCallback ? { sampling: {} } : {},
+          // Add elicitation capability if callback is provided
+          ...this.opts.elicitationCallback ? { elicitation: { form: {}, url: {} } } : {}
+        }
+      };
+      logger.debug(
+        `Creating Client with capabilities (SSE):`,
+        JSON.stringify(clientOptions.capabilities, null, 2)
+      );
+      this.client = new import_client.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;
+  }
+};
+
+// src/connectors/stdio.ts
+var import_node_process = __toESM(require("process"), 1);
+var import_client2 = require("@mcp-use/modelcontextprotocol-sdk/client/index.js");
+init_logging();
+
+// src/task_managers/stdio.ts
+var import_stdio = require("@mcp-use/modelcontextprotocol-sdk/client/stdio.js");
+init_logging();
+var StdioConnectionManager = class extends ConnectionManager {
+  static {
+    __name(this, "StdioConnectionManager");
+  }
+  serverParams;
+  errlog;
+  _transport = null;
+  /**
+   * Create a new stdio connection manager.
+   *
+   * @param serverParams Parameters for the stdio server process.
+   * @param errlog       Stream to which the server's stderr should be piped.
+   *                     Defaults to `process.stderr`.
+   */
+  constructor(serverParams, errlog = process.stderr) {
+    super();
+    this.serverParams = serverParams;
+    this.errlog = errlog;
+  }
+  /**
+   * Establish the stdio connection by spawning the server process and starting
+   * the SDK's transport. Returns the live `StdioClientTransport` instance.
+   */
+  async establishConnection() {
+    this._transport = new import_stdio.StdioClientTransport(this.serverParams);
+    if (this._transport.stderr && typeof this._transport.stderr.pipe === "function") {
+      this._transport.stderr.pipe(
+        this.errlog
+      );
+    }
+    logger.debug(`${this.constructor.name} connected successfully`);
+    return this._transport;
+  }
+  /**
+   * Close the stdio connection, making sure the transport cleans up the child
+   * process and associated resources.
+   */
+  async closeConnection(_connection) {
+    if (this._transport) {
+      try {
+        await this._transport.close();
+      } catch (e) {
+        logger.warn(`Error closing stdio transport: ${e}`);
+      } finally {
+        this._transport = null;
+      }
+    }
+  }
+};
+
+// src/connectors/stdio.ts
+var StdioConnector = class extends BaseConnector {
+  static {
+    __name(this, "StdioConnector");
+  }
+  command;
+  args;
+  env;
+  errlog;
+  clientInfo;
+  constructor({
+    command = "npx",
+    args = [],
+    env,
+    errlog = import_node_process.default.stderr,
+    ...rest
+  } = {}) {
+    super(rest);
+    this.command = command;
+    this.args = args;
+    this.env = env;
+    this.errlog = errlog;
+    this.clientInfo = rest.clientInfo ?? {
+      name: "stdio-connector",
+      version: "1.0.0"
+    };
+  }
+  /** Establish connection to the MCP implementation. */
+  async connect() {
+    if (this.connected) {
+      logger.debug("Already connected to MCP implementation");
+      return;
+    }
+    logger.debug(`Connecting to MCP implementation via stdio: ${this.command}`);
+    try {
+      let mergedEnv;
+      if (this.env) {
+        mergedEnv = {};
+        for (const [key, value] of Object.entries(import_node_process.default.env)) {
+          if (value !== void 0) {
+            mergedEnv[key] = value;
+          }
+        }
+        Object.assign(mergedEnv, this.env);
+      }
+      const serverParams = {
+        command: this.command,
+        args: this.args,
+        env: mergedEnv
+      };
+      this.connectionManager = new StdioConnectionManager(
+        serverParams,
+        this.errlog
+      );
+      const transport = await this.connectionManager.start();
+      const clientOptions = {
+        ...this.opts.clientOptions || {},
+        capabilities: {
+          ...this.opts.clientOptions?.capabilities || {},
+          roots: { listChanged: true },
+          // Always advertise roots capability
+          // Add sampling capability if callback is provided
+          ...this.opts.samplingCallback ? { sampling: {} } : {},
+          // Add elicitation capability if callback is provided
+          ...this.opts.elicitationCallback ? { elicitation: { form: {}, url: {} } } : {}
+        }
+      };
+      this.client = new import_client2.Client(this.clientInfo, clientOptions);
+      await this.client.connect(transport);
+      this.connected = true;
+      this.setupNotificationHandler();
+      this.setupRootsHandler();
+      this.setupSamplingHandler();
+      this.setupElicitationHandler();
+      logger.debug(
+        `Successfully connected to MCP implementation: ${this.command}`
+      );
+      this.trackConnectorInit({
+        serverCommand: this.command,
+        serverArgs: this.args,
+        publicIdentifier: `${this.command} ${this.args.join(" ")}`
+      });
+    } catch (err) {
+      logger.error(`Failed to connect to MCP implementation: ${err}`);
+      await this.cleanupResources();
+      throw err;
+    }
+  }
+  get publicIdentifier() {
+    return {
+      type: "stdio",
+      "command&args": `${this.command} ${this.args.join(" ")}`
+    };
   }
 };
 
-// src/adapters/langchain_adapter.ts
-function schemaToZod(schema) {
-  try {
-    return JSONSchemaToZod.convert(schema);
-  } catch (err) {
-    logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
-    return import_zod2.z.any();
+// src/config.ts
+function loadConfigFile(filepath) {
+  const raw = (0, import_node_fs.readFileSync)(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+__name(loadConfigFile, "loadConfigFile");
+function createConnectorFromConfig(serverConfig, connectorOptions) {
+  if ("command" in serverConfig && "args" in serverConfig) {
+    return new StdioConnector({
+      command: serverConfig.command,
+      args: serverConfig.args,
+      env: serverConfig.env,
+      ...connectorOptions
+    });
+  }
+  if ("url" in serverConfig) {
+    const transport = serverConfig.transport || "http";
+    return new HttpConnector(serverConfig.url, {
+      headers: serverConfig.headers,
+      authToken: serverConfig.auth_token || serverConfig.authToken,
+      // Only force SSE if explicitly requested
+      preferSse: serverConfig.preferSse || transport === "sse",
+      ...connectorOptions
+    });
   }
+  throw new Error("Cannot determine connector type from config");
 }
-__name(schemaToZod, "schemaToZod");
-var LangChainAdapter = class extends BaseAdapter {
+__name(createConnectorFromConfig, "createConnectorFromConfig");
+
+// src/client.ts
+init_logging();
+var MCPClient = class _MCPClient extends BaseMCPClient {
   static {
-    __name(this, "LangChainAdapter");
+    __name(this, "MCPClient");
   }
-  constructor(disallowedTools = []) {
-    super(disallowedTools);
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
+  codeMode = false;
+  _codeExecutor = null;
+  _customCodeExecutor = null;
+  _codeExecutorConfig = "vm";
+  _executorOptions;
+  _samplingCallback;
+  _elicitationCallback;
+  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;
+    this._samplingCallback = options?.samplingCallback;
+    this._elicitationCallback = options?.elicitationCallback;
+    if (this.codeMode) {
+      this._setupCodeModeConnector();
+    }
+    this._trackClientInit();
+  }
+  _trackClientInit() {
+    const servers = Object.keys(this.config.mcpServers ?? {});
+    const hasSamplingCallback = !!this._samplingCallback;
+    const hasElicitationCallback = !!this._elicitationCallback;
+    Tel.getInstance().trackMCPClientInit({
+      codeMode: this.codeMode,
+      sandbox: false,
+      // Sandbox not supported in TS yet
+      allCallbacks: hasSamplingCallback && hasElicitationCallback,
+      verify: false,
+      // No verify option in TS client
+      servers,
+      numServers: servers.length,
+      isBrowser: false
+      // Node.js MCPClient
+    }).catch((e) => logger.debug(`Failed to track MCPClient init: ${e}`));
+  }
+  static fromDict(cfg, options) {
+    return new _MCPClient(cfg, options);
+  }
+  static fromConfigFile(path2, options) {
+    return new _MCPClient(loadConfigFile(path2), options);
   }
   /**
-   * Convert a single MCP tool specification into a LangChainJS structured tool.
+   * Save configuration to a file (Node.js only)
    */
-  convertTool(mcpTool, connector) {
-    if (this.disallowedTools.includes(mcpTool.name)) {
-      return null;
+  saveConfig(filepath) {
+    const dir = import_node_path.default.dirname(filepath);
+    if (!import_node_fs2.default.existsSync(dir)) {
+      import_node_fs2.default.mkdirSync(dir, { recursive: true });
     }
-    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : import_zod2.z.object({}).optional();
-    const tool = new import_tools.DynamicStructuredTool({
-      name: mcpTool.name ?? "NO NAME",
-      description: mcpTool.description ?? "",
-      // Blank is acceptable but discouraged.
-      schema: argsSchema,
-      func: /* @__PURE__ */ __name(async (input) => {
-        logger.debug(
-          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
+    import_node_fs2.default.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
+   */
+  createConnectorFromConfig(serverConfig) {
+    return createConnectorFromConfig(serverConfig, {
+      samplingCallback: this._samplingCallback,
+      elicitationCallback: this._elicitationCallback
+    });
+  }
+  _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 {
-          const result = await connector.callTool(
-            mcpTool.name,
-            input
+          this._codeExecutor = new VMCodeExecutor(
+            this,
+            this._executorOptions
           );
-          return JSON.stringify(result);
-        } catch (err) {
-          logger.error(`Error executing MCP tool: ${err.message}`);
-          return `Error executing MCP tool: ${String(err)}`;
+        } 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."
+            );
+          }
         }
-      }, "func")
+      }
+    }
+    return this._codeExecutor;
+  }
+  /**
+   * Execute code 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);
+  }
+  /**
+   * Search available tools (used by 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
+    );
+  }
+  /**
+   * Override getServerNames to exclude internal code_mode server
+   */
+  getServerNames() {
+    const isCodeModeEnabled = this.codeMode;
+    return super.getServerNames().filter((name) => {
+      return !isCodeModeEnabled || name !== "code_mode";
     });
-    return tool;
+  }
+  /**
+   * Close the client and clean up resources including code executors.
+   * This ensures E2B sandboxes and other resources are properly released.
+   */
+  async close() {
+    if (this._codeExecutor) {
+      await this._codeExecutor.cleanup();
+      this._codeExecutor = null;
+    }
+    await this.closeAllSessions();
   }
 };
 
@@ -3191,15 +5866,21 @@ var ConnectMCPServerTool = class extends MCPServerTool {
         session = await this.manager.client.createSession(serverName);
       }
       this.manager.activeServer = serverName;
-      if (this.manager.serverTools[serverName]) {
+      if (!this.manager.serverTools[serverName]) {
         const connector = session.connector;
         const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
-        this.manager.serverTools[serverName] = tools;
+        const resources = await this.manager.adapter.createResourcesFromConnectors([connector]);
+        const prompts = await this.manager.adapter.createPromptsFromConnectors([connector]);
+        const allItems = [...tools, ...resources, ...prompts];
+        this.manager.serverTools[serverName] = allItems;
         this.manager.initializedServers[serverName] = true;
+        logger.debug(
+          `Loaded ${allItems.length} items for server '${serverName}': ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`
+        );
       }
       const serverTools = this.manager.serverTools[serverName] || [];
       const numTools = serverTools.length;
-      return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
+      return `Connected to MCP server '${serverName}'. ${numTools} tools, resources, and prompts are now available.`;
     } catch (error) {
       logger.error(
         `Error connecting to server '${serverName}': ${String(error)}`
@@ -3361,21 +6042,30 @@ var ServerManager = class {
         if (session) {
           const connector = session.connector;
           let tools = [];
+          let resources = [];
+          let prompts = [];
           try {
             tools = await this.adapter.createToolsFromConnectors([connector]);
+            resources = await this.adapter.createResourcesFromConnectors([
+              connector
+            ]);
+            prompts = await this.adapter.createPromptsFromConnectors([
+              connector
+            ]);
           } catch (toolFetchError) {
             logger.error(
-              `Failed to create tools from connector for server '${serverName}': ${toolFetchError}`
+              `Failed to create tools/resources/prompts from connector for server '${serverName}': ${toolFetchError}`
             );
             continue;
           }
+          const allItems = [...tools, ...resources, ...prompts];
           const cachedTools = this.serverTools[serverName];
-          const toolsChanged = !cachedTools || !isEqual(cachedTools, tools);
+          const toolsChanged = !cachedTools || !isEqual(cachedTools, allItems);
           if (toolsChanged) {
-            this.serverTools[serverName] = tools;
+            this.serverTools[serverName] = allItems;
             this.initializedServers[serverName] = true;
             logger.debug(
-              `Prefetched ${tools.length} tools for server '${serverName}'.`
+              `Prefetched ${allItems.length} items for server '${serverName}': ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts.`
             );
           } else {
             logger.debug(
@@ -3703,6 +6393,26 @@ var import_zod8 = require("zod");
 init_logging();
 var API_CHATS_ENDPOINT = "/api/v1/chats";
 var API_CHAT_EXECUTE_ENDPOINT = "/api/v1/chats/{chat_id}/execute";
+function normalizeRemoteRunOptions(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+  if (typeof queryOrOptions === "object" && queryOrOptions !== null) {
+    const options = queryOrOptions;
+    return {
+      query: options.prompt,
+      maxSteps: options.maxSteps,
+      manageConnector: options.manageConnector,
+      externalHistory: options.externalHistory,
+      outputSchema: options.schema
+    };
+  }
+  return {
+    query: queryOrOptions,
+    maxSteps,
+    manageConnector,
+    externalHistory,
+    outputSchema
+  };
+}
+__name(normalizeRemoteRunOptions, "normalizeRemoteRunOptions");
 var RemoteAgent = class {
   static {
     __name(this, "RemoteAgent");
@@ -3799,8 +6509,20 @@ var RemoteAgent = class {
       throw new Error(`Failed to create chat session: ${String(e)}`);
     }
   }
-  async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-    if (externalHistory !== void 0) {
+  async run(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+    const {
+      query,
+      maxSteps: steps,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalizeRemoteRunOptions(
+      queryOrOptions,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
+    if (history !== void 0) {
       logger.warn("External history is not yet supported for remote execution");
     }
     try {
@@ -3811,10 +6533,10 @@ var RemoteAgent = class {
       const chatId = this.chatId;
       const executionPayload = {
         query,
-        max_steps: maxSteps ?? 10
+        max_steps: steps ?? 10
       };
-      if (outputSchema) {
-        executionPayload.output_schema = this.pydanticToJsonSchema(outputSchema);
+      if (schema) {
+        executionPayload.output_schema = this.pydanticToJsonSchema(schema);
         logger.info(`\u{1F527} Using structured output with schema`);
       }
       const headers = {
@@ -3888,8 +6610,8 @@ Raw error: ${result}`
           );
         }
       }
-      if (outputSchema) {
-        return this.parseStructuredResponse(result, outputSchema);
+      if (schema) {
+        return this.parseStructuredResponse(result, schema);
       }
       if (typeof result === "object" && result !== null && "result" in result) {
         return result.result;
@@ -3914,9 +6636,9 @@ Raw error: ${result}`
     }
   }
   // eslint-disable-next-line require-yield
-  async *stream(query, maxSteps, manageConnector, externalHistory, outputSchema) {
+  async *stream(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
     const result = await this.run(
-      query,
+      queryOrOptions,
       maxSteps,
       manageConnector,
       externalHistory,
@@ -3929,7 +6651,153 @@ Raw error: ${result}`
   }
 };
 
+// src/agents/utils/llm_provider.ts
+init_logging();
+var PROVIDER_CONFIG = {
+  openai: {
+    package: "@langchain/openai",
+    className: "ChatOpenAI",
+    envVars: ["OPENAI_API_KEY"],
+    defaultModel: "gpt-4o"
+  },
+  anthropic: {
+    package: "@langchain/anthropic",
+    className: "ChatAnthropic",
+    envVars: ["ANTHROPIC_API_KEY"],
+    defaultModel: "claude-3-5-sonnet-20241022"
+  },
+  google: {
+    package: "@langchain/google-genai",
+    className: "ChatGoogleGenerativeAI",
+    envVars: ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+    defaultModel: "gemini-pro"
+  },
+  groq: {
+    package: "@langchain/groq",
+    className: "ChatGroq",
+    envVars: ["GROQ_API_KEY"],
+    defaultModel: "llama-3.1-70b-versatile"
+  }
+};
+function parseLLMString(llmString) {
+  const parts = llmString.split("/");
+  if (parts.length !== 2) {
+    throw new Error(
+      `Invalid LLM string format. Expected 'provider/model', got '${llmString}'. Examples: 'openai/gpt-4', 'anthropic/claude-3-5-sonnet-20241022', 'google/gemini-pro', 'groq/llama-3.1-70b-versatile'`
+    );
+  }
+  const [provider, model] = parts;
+  if (!provider || !model) {
+    throw new Error(
+      `Invalid LLM string format. Both provider and model must be non-empty. Got '${llmString}'`
+    );
+  }
+  const normalizedProvider = provider.toLowerCase();
+  if (!(normalizedProvider in PROVIDER_CONFIG)) {
+    const supportedProviders = Object.keys(PROVIDER_CONFIG).join(", ");
+    throw new Error(
+      `Unsupported LLM provider '${provider}'. Supported providers: ${supportedProviders}`
+    );
+  }
+  return { provider: normalizedProvider, model };
+}
+__name(parseLLMString, "parseLLMString");
+function getAPIKey(provider, config) {
+  if (config?.apiKey) {
+    return config.apiKey;
+  }
+  const providerConfig = PROVIDER_CONFIG[provider];
+  for (const envVar of providerConfig.envVars) {
+    const apiKey = process.env[envVar];
+    if (apiKey) {
+      logger.debug(
+        `Using API key from environment variable ${envVar} for provider ${provider}`
+      );
+      return apiKey;
+    }
+  }
+  const envVarsStr = providerConfig.envVars.join(" or ");
+  throw new Error(
+    `API key not found for provider '${provider}'. Set ${envVarsStr} environment variable or pass apiKey in llmConfig. Example: new MCPAgent({ llm: '${provider}/model', llmConfig: { apiKey: 'your-key' } })`
+  );
+}
+__name(getAPIKey, "getAPIKey");
+async function createLLMFromString(llmString, config) {
+  logger.info(`Creating LLM from string: ${llmString}`);
+  const { provider, model } = parseLLMString(llmString);
+  const providerConfig = PROVIDER_CONFIG[provider];
+  const apiKey = getAPIKey(provider, config);
+  let providerModule;
+  try {
+    logger.debug(`Importing package ${providerConfig.package}...`);
+    providerModule = await import(providerConfig.package);
+  } catch (error) {
+    if (error?.code === "MODULE_NOT_FOUND" || error?.message?.includes("Cannot find module") || error?.message?.includes("Cannot find package")) {
+      throw new Error(
+        `Package '${providerConfig.package}' is not installed. Install it with: npm install ${providerConfig.package} or yarn add ${providerConfig.package}`
+      );
+    }
+    throw new Error(
+      `Failed to import ${providerConfig.package}: ${error?.message || error}`
+    );
+  }
+  const LLMClass = providerModule[providerConfig.className];
+  if (!LLMClass) {
+    throw new Error(
+      `Could not find ${providerConfig.className} in package ${providerConfig.package}. This might be a version compatibility issue.`
+    );
+  }
+  const llmConfig = {
+    model,
+    apiKey,
+    ...config
+  };
+  if (config?.apiKey) {
+    delete llmConfig.apiKey;
+    llmConfig.apiKey = apiKey;
+  }
+  if (provider === "anthropic") {
+    llmConfig.model = model;
+  } else if (provider === "google") {
+    llmConfig.model = model;
+  } else if (provider === "openai") {
+    llmConfig.model = model;
+  } else if (provider === "groq") {
+    llmConfig.model = model;
+  }
+  try {
+    const llmInstance = new LLMClass(llmConfig);
+    logger.info(`Successfully created ${provider} LLM with model ${model}`);
+    return llmInstance;
+  } catch (error) {
+    throw new Error(
+      `Failed to instantiate ${providerConfig.className} with model '${model}': ${error?.message || error}`
+    );
+  }
+}
+__name(createLLMFromString, "createLLMFromString");
+
 // src/agents/mcp_agent.ts
+function normalizeRunOptions(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+  if (typeof queryOrOptions === "object" && queryOrOptions !== null) {
+    const options = queryOrOptions;
+    return {
+      query: options.prompt,
+      maxSteps: options.maxSteps,
+      manageConnector: options.manageConnector,
+      externalHistory: options.externalHistory,
+      outputSchema: options.schema
+    };
+  }
+  return {
+    query: queryOrOptions,
+    maxSteps,
+    manageConnector,
+    externalHistory,
+    outputSchema
+  };
+}
+__name(normalizeRunOptions, "normalizeRunOptions");
 var MCPAgent = class {
   static {
     __name(this, "MCPAgent");
@@ -3975,6 +6843,12 @@ var MCPAgent = class {
   // Remote agent support
   isRemote = false;
   remoteAgent = null;
+  // Simplified mode support
+  isSimplifiedMode = false;
+  llmString;
+  llmConfig;
+  mcpServersConfig;
+  clientOwnedByAgent = false;
   constructor(options) {
     if (options.agentId) {
       this.isRemote = true;
@@ -4008,9 +6882,36 @@ var MCPAgent = class {
         "llm is required for local execution. For remote execution, provide agentId instead."
       );
     }
-    this.llm = options.llm;
-    this.client = options.client;
-    this.connectors = options.connectors ?? [];
+    const isSimplifiedMode = typeof options.llm === "string";
+    if (isSimplifiedMode) {
+      this.isSimplifiedMode = true;
+      this.llmString = options.llm;
+      this.llmConfig = options.llmConfig;
+      this.mcpServersConfig = options.mcpServers;
+      if (!this.mcpServersConfig || Object.keys(this.mcpServersConfig).length === 0) {
+        throw new Error(
+          "Simplified mode requires 'mcpServers' configuration. Provide an object with server configurations, e.g., { filesystem: { command: 'npx', args: [...] } }"
+        );
+      }
+      this.llm = void 0;
+      this.client = void 0;
+      this.clientOwnedByAgent = true;
+      this.connectors = [];
+      logger.info(
+        `\u{1F3AF} Simplified mode enabled: LLM will be created from '${this.llmString}'`
+      );
+    } else {
+      this.isSimplifiedMode = false;
+      this.llm = options.llm;
+      this.client = options.client;
+      this.connectors = options.connectors ?? [];
+      this.clientOwnedByAgent = false;
+      if (!this.client && this.connectors.length === 0) {
+        throw new Error(
+          "Explicit mode requires either 'client' or at least one 'connector'. Alternatively, use simplified mode with 'llm' as a string and 'mcpServers' config."
+        );
+      }
+    }
     this.maxSteps = options.maxSteps ?? 5;
     this.autoInitialize = options.autoInitialize ?? false;
     this.memoryEnabled = options.memoryEnabled ?? true;
@@ -4023,28 +6924,30 @@ var MCPAgent = class {
     this.useServerManager = options.useServerManager ?? false;
     this.verbose = options.verbose ?? false;
     this.observe = options.observe ?? true;
-    if (!this.client && this.connectors.length === 0) {
-      throw new Error(
-        "Either 'client' or at least one 'connector' must be provided."
-      );
-    }
-    if (this.useServerManager) {
-      if (!this.client) {
-        throw new Error(
-          "'client' must be provided when 'useServerManager' is true."
-        );
+    if (!this.isSimplifiedMode) {
+      if (this.useServerManager) {
+        if (!this.client) {
+          throw new Error(
+            "'client' must be provided when 'useServerManager' is true."
+          );
+        }
+        this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
+        this.serverManager = options.serverManagerFactory?.(this.client) ?? new ServerManager(this.client, this.adapter);
+      } else {
+        this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
+      }
+      this.telemetry = Telemetry.getInstance();
+      if (this.llm) {
+        const [provider, name] = extractModelInfo(this.llm);
+        this.modelProvider = provider;
+        this.modelName = name;
+      } else {
+        this.modelProvider = "unknown";
+        this.modelName = "unknown";
       }
-      this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
-      this.serverManager = options.serverManagerFactory?.(this.client) ?? new ServerManager(this.client, this.adapter);
     } else {
       this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
-    }
-    this.telemetry = Telemetry.getInstance();
-    if (this.llm) {
-      const [provider, name] = extractModelInfo(this.llm);
-      this.modelProvider = provider;
-      this.modelName = name;
-    } else {
+      this.telemetry = Telemetry.getInstance();
       this.modelProvider = "unknown";
       this.modelName = "unknown";
     }
@@ -4075,6 +6978,40 @@ var MCPAgent = class {
       return;
     }
     logger.info("\u{1F680} Initializing MCP agent and connecting to services...");
+    if (this.isSimplifiedMode) {
+      logger.info(
+        "\u{1F3AF} Simplified mode: Creating client and LLM from configuration..."
+      );
+      if (this.mcpServersConfig) {
+        logger.info(
+          `Creating MCPClient with ${Object.keys(this.mcpServersConfig).length} server(s)...`
+        );
+        this.client = new MCPClient({ mcpServers: this.mcpServersConfig });
+        logger.info("\u2705 MCPClient created successfully");
+      }
+      if (this.llmString) {
+        logger.info(`Creating LLM from string: ${this.llmString}...`);
+        try {
+          this.llm = await createLLMFromString(this.llmString, this.llmConfig);
+          logger.info("\u2705 LLM created successfully");
+          const [provider, name] = extractModelInfo(this.llm);
+          this.modelProvider = provider;
+          this.modelName = name;
+        } catch (error) {
+          throw new Error(
+            `Failed to create LLM from string '${this.llmString}': ${error?.message || error}`
+          );
+        }
+      }
+      if (this.useServerManager) {
+        if (!this.client) {
+          throw new Error(
+            "'client' must be available when 'useServerManager' is true."
+          );
+        }
+        this.serverManager = new ServerManager(this.client, this.adapter);
+      }
+    }
     this.callbacks = await this.observabilityManager.getCallbacks();
     const handlerNames = await this.observabilityManager.getHandlerNames();
     if (handlerNames.length > 0) {
@@ -4118,9 +7055,18 @@ var MCPAgent = class {
             );
           }
         } else {
-          this._tools = await LangChainAdapter.createTools(this.client);
+          const tools = await this.adapter.createToolsFromConnectors(
+            Object.values(this.sessions).map((session) => session.connector)
+          );
+          const resources = await this.adapter.createResourcesFromConnectors(
+            Object.values(this.sessions).map((session) => session.connector)
+          );
+          const prompts = await this.adapter.createPromptsFromConnectors(
+            Object.values(this.sessions).map((session) => session.connector)
+          );
+          this._tools = [...tools, ...resources, ...prompts];
           logger.info(
-            `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
+            `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain items from client: ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`
           );
         }
         this._tools.push(...this.additionalTools);
@@ -4133,12 +7079,19 @@ var MCPAgent = class {
             await connector.connect();
           }
         }
-        this._tools = await this.adapter.createToolsFromConnectors(
+        const tools = await this.adapter.createToolsFromConnectors(
+          this.connectors
+        );
+        const resources = await this.adapter.createResourcesFromConnectors(
+          this.connectors
+        );
+        const prompts = await this.adapter.createPromptsFromConnectors(
           this.connectors
         );
+        this._tools = [...tools, ...resources, ...prompts];
         this._tools.push(...this.additionalTools);
         logger.info(
-          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from connectors`
+          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain items from connectors: ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`
         );
       }
       logger.info(`\u{1F9F0} Found ${this._tools.length} tools across all connectors`);
@@ -4601,33 +7554,47 @@ var MCPAgent = class {
       }
     }
   }
-  async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-    if (this.isRemote && this.remoteAgent) {
-      return this.remoteAgent.run(
-        query,
-        maxSteps,
-        manageConnector,
-        externalHistory,
-        outputSchema
-      );
-    }
-    const generator = this.stream(
+  async run(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+    const {
       query,
+      maxSteps: steps,
+      manageConnector: manage,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalizeRunOptions(
+      queryOrOptions,
       maxSteps,
       manageConnector,
       externalHistory,
       outputSchema
     );
+    if (this.isRemote && this.remoteAgent) {
+      return this.remoteAgent.run(query, steps, manage, history, schema);
+    }
+    const generator = this.stream(query, steps, manage, history, schema);
     return this._consumeAndReturn(generator);
   }
-  async *stream(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+  async *stream(queryOrOptions, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+    const {
+      query,
+      maxSteps: steps,
+      manageConnector: manage,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalizeRunOptions(
+      queryOrOptions,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
     if (this.isRemote && this.remoteAgent) {
       const result = await this.remoteAgent.run(
         query,
-        maxSteps,
-        manageConnector,
-        externalHistory,
-        outputSchema
+        steps,
+        manage,
+        history,
+        schema
       );
       return result;
     }
@@ -4637,7 +7604,7 @@ var MCPAgent = class {
     let finalOutput = null;
     let stepsTaken = 0;
     try {
-      if (manageConnector && !this._initialized) {
+      if (manage && !this._initialized) {
         await this.initialize();
         initializedHere = true;
       } else if (!this._initialized && this.autoInitialize) {
@@ -4661,7 +7628,7 @@ var MCPAgent = class {
           this._agentExecutor = this.createAgent();
         }
       }
-      const historyToUse = externalHistory ?? this.conversationHistory;
+      const historyToUse = history ?? this.conversationHistory;
       const langchainHistory = [];
       for (const msg of historyToUse) {
         if (this._isHumanMessageLike(msg) || this._isAIMessageLike(msg) || this._isToolMessageLike(msg)) {
@@ -4802,13 +7769,13 @@ var MCPAgent = class {
           this.addToHistory(msg);
         }
       }
-      if (outputSchema && finalOutput) {
+      if (schema && finalOutput) {
         try {
           logger.info("\u{1F527} Attempting structured output...");
           const structuredResult = await this._attemptStructuredOutput(
             finalOutput,
             this.llm,
-            outputSchema
+            schema
           );
           if (this.memoryEnabled) {
             this.addToHistory(
@@ -4834,7 +7801,7 @@ var MCPAgent = class {
       return finalOutput || "No output generated";
     } catch (e) {
       logger.error(`\u274C Error running query: ${e}`);
-      if (initializedHere && manageConnector) {
+      if (initializedHere && manage) {
         logger.info("\u{1F9F9} Cleaning up resources after error");
         await this.close();
       }
@@ -4864,9 +7831,9 @@ var MCPAgent = class {
         maxStepsConfigured: this.maxSteps,
         memoryEnabled: this.memoryEnabled,
         useServerManager: this.useServerManager,
-        maxStepsUsed: maxSteps ?? null,
-        manageConnector,
-        externalHistoryUsed: externalHistory !== void 0,
+        maxStepsUsed: steps ?? null,
+        manageConnector: manage ?? true,
+        externalHistoryUsed: history !== void 0,
         stepsTaken,
         toolsUsedCount: this.toolsUsedNames.length,
         toolsUsedNames: this.toolsUsedNames,
@@ -4875,7 +7842,7 @@ var MCPAgent = class {
         errorType: success ? null : "execution_error",
         conversationHistoryLength
       });
-      if (manageConnector && !this.client && initializedHere) {
+      if (manage && !this.client && initializedHere) {
         logger.info("\u{1F9F9} Closing agent after stream completion");
         await this.close();
       }
@@ -4903,15 +7870,28 @@ var MCPAgent = class {
       this._agentExecutor = null;
       this._tools = [];
       if (this.client) {
-        logger.info("\u{1F504} Closing client and cleaning up resources");
-        await this.client.close();
-        this.sessions = {};
+        if (this.clientOwnedByAgent) {
+          logger.info(
+            "\u{1F504} Closing internally-created client (simplified mode) and cleaning up resources"
+          );
+          await this.client.close();
+          this.sessions = {};
+          this.client = void 0;
+        } else {
+          logger.info("\u{1F504} Closing client and cleaning up resources");
+          await this.client.close();
+          this.sessions = {};
+        }
       } else {
         for (const connector of this.connectors) {
           logger.info("\u{1F504} Disconnecting connector");
           await connector.disconnect();
         }
       }
+      if (this.isSimplifiedMode && this.llm) {
+        logger.debug("\u{1F504} Clearing LLM reference (simplified mode)");
+        this.llm = void 0;
+      }
       if ("connectorToolMap" in this.adapter) {
         this.adapter = new LangChainAdapter();
       }
@@ -4920,16 +7900,12 @@ var MCPAgent = class {
       logger.info("\u{1F44B} Agent closed successfully");
     }
   }
-  /**
-   * Yields with pretty-printed output for code mode.
-   * This method formats and displays tool executions in a user-friendly way with syntax highlighting.
-   */
-  async *prettyStreamEvents(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+  async *prettyStreamEvents(queryOrOptions, maxSteps, manageConnector = true, externalHistory, outputSchema) {
     const { prettyStreamEvents: prettyStream } = await Promise.resolve().then(() => (init_display(), display_exports));
     const finalResponse = "";
     for await (const _ of prettyStream(
       this.streamEvents(
-        query,
+        queryOrOptions,
         maxSteps,
         manageConnector,
         externalHistory,
@@ -4940,22 +7916,32 @@ var MCPAgent = class {
     }
     return finalResponse;
   }
-  /**
-   * Yields LangChain StreamEvent objects from the underlying streamEvents() method.
-   * This provides token-level streaming and fine-grained event updates.
-   */
-  async *streamEvents(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+  async *streamEvents(queryOrOptions, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+    const normalized = normalizeRunOptions(
+      queryOrOptions,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
+    let { query } = normalized;
+    const {
+      maxSteps: steps,
+      manageConnector: manage,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalized;
     let initializedHere = false;
     const startTime = Date.now();
     let success = false;
     let eventCount = 0;
     let totalResponseLength = 0;
     let finalResponse = "";
-    if (outputSchema) {
-      query = this._enhanceQueryWithSchema(query, outputSchema);
+    if (schema) {
+      query = this._enhanceQueryWithSchema(query, schema);
     }
     try {
-      if (manageConnector && !this._initialized) {
+      if (manage && !this._initialized) {
         await this.initialize();
         initializedHere = true;
       } else if (!this._initialized && this.autoInitialize) {
@@ -4966,14 +7952,14 @@ var MCPAgent = class {
       if (!agentExecutor) {
         throw new Error("MCP agent failed to initialize");
       }
-      this.maxSteps = maxSteps ?? this.maxSteps;
+      this.maxSteps = steps ?? this.maxSteps;
       const display_query = typeof query === "string" && query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : typeof query === "string" ? query.replace(/\n/g, " ") : String(query);
       logger.info(`\u{1F4AC} Received query for streamEvents: '${display_query}'`);
       if (this.memoryEnabled) {
         logger.info(`\u{1F504} Adding user message to history: ${display_query}`);
         this.addToHistory(new import_langchain2.HumanMessage({ content: query }));
       }
-      const historyToUse = externalHistory ?? this.conversationHistory;
+      const historyToUse = history ?? this.conversationHistory;
       const langchainHistory = [];
       for (const msg of historyToUse) {
         if (this._isHumanMessageLike(msg) || this._isAIMessageLike(msg) || this._isToolMessageLike(msg)) {
@@ -5040,17 +8026,13 @@ var MCPAgent = class {
           }
         }
       }
-      if (outputSchema && finalResponse) {
+      if (schema && finalResponse) {
         logger.info("\u{1F527} Attempting structured output conversion...");
         try {
           let conversionCompleted = false;
           let conversionResult = null;
           let conversionError = null;
-          this._attemptStructuredOutput(
-            finalResponse,
-            this.llm,
-            outputSchema
-          ).then((result) => {
+          this._attemptStructuredOutput(finalResponse, this.llm, schema).then((result) => {
             conversionCompleted = true;
             conversionResult = result;
             return result;
@@ -5105,7 +8087,7 @@ var MCPAgent = class {
       success = true;
     } catch (e) {
       logger.error(`\u274C Error during streamEvents: ${e}`);
-      if (initializedHere && manageConnector) {
+      if (initializedHere && manage) {
         logger.info(
           "\u{1F9F9} Cleaning up resources after initialization error in streamEvents"
         );
@@ -5136,15 +8118,15 @@ var MCPAgent = class {
         maxStepsConfigured: this.maxSteps,
         memoryEnabled: this.memoryEnabled,
         useServerManager: this.useServerManager,
-        maxStepsUsed: maxSteps ?? null,
-        manageConnector,
-        externalHistoryUsed: externalHistory !== void 0,
+        maxStepsUsed: steps ?? null,
+        manageConnector: manage ?? true,
+        externalHistoryUsed: history !== void 0,
         response: `[STREAMED RESPONSE - ${totalResponseLength} chars]`,
         executionTimeMs,
         errorType: success ? null : "streaming_error",
         conversationHistoryLength
       });
-      if (manageConnector && !this.client && initializedHere) {
+      if (manage && !this.client && initializedHere) {
         logger.info("\u{1F9F9} Closing agent after streamEvents completion");
         await this.close();
       }