mcp-use 1.10.6 → 1.11.0-canary.11

package/dist/src/browser.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];
@@ -1052,7 +1052,6 @@ __export(browser_exports, {
   BrowserOAuthClientProvider: () => BrowserOAuthClientProvider,
   BrowserTelemetry: () => Tel,
   HttpConnector: () => HttpConnector,
-  LangChainAdapter: () => LangChainAdapter,
   Logger: () => Logger,
   MCPAgent: () => MCPAgent,
   MCPClient: () => BrowserMCPClient,
@@ -1062,11 +1061,14 @@ __export(browser_exports, {
   Tel: () => Tel,
   Telemetry: () => Telemetry,
   VERSION: () => VERSION,
-  WebSocketConnector: () => WebSocketConnector,
+  createLLMFromString: () => createLLMFromString,
   createReadableStreamFromGenerator: () => createReadableStreamFromGenerator,
   getPackageVersion: () => getPackageVersion,
+  getSupportedProviders: () => getSupportedProviders,
+  isValidLLMString: () => isValidLLMString,
   logger: () => logger,
   onMcpAuthorization: () => onMcpAuthorization,
+  parseLLMString: () => parseLLMString,
   setBrowserTelemetrySource: () => setTelemetrySource,
   setTelemetrySource: () => setTelemetrySource,
   streamEventsToAISDK: () => streamEventsToAISDK,
@@ -1209,6 +1211,7 @@ var SseConnectionManager = class extends ConnectionManager {
   url;
   opts;
   _transport = null;
+  reinitializing = false;
   /**
    * Create an SSE connection manager.
    *
@@ -1221,12 +1224,53 @@ var SseConnectionManager = class extends ConnectionManager {
     this.opts = opts;
   }
   /**
-   * Spawn a new `SSEClientTransport` and start the connection.
+   * 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() {
-    this._transport = new import_sse.SSEClientTransport(this.url, this.opts);
+    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 this._transport;
+    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.
@@ -1607,7 +1651,7 @@ __name(generateUUID, "generateUUID");
 init_logging();
 
 // src/version.ts
-var VERSION = "1.10.6";
+var VERSION = "1.11.0-canary.11";
 function getPackageVersion() {
   return VERSION;
 }
@@ -1928,26 +1972,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)
@@ -1966,9 +2010,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;
@@ -1978,11 +2022,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) {
@@ -2056,12 +2100,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"
         );
@@ -2069,19 +2113,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) {
@@ -2569,6 +2613,20 @@ var BaseConnector = class {
     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
    *
@@ -3012,283 +3070,6 @@ var HttpConnector = class extends BaseConnector {
   }
 };
 
-// src/connectors/websocket.ts
-init_logging();
-
-// src/task_managers/websocket.ts
-var import_ws = __toESM(require("ws"), 1);
-init_logging();
-var WebSocketConnectionManager = class extends ConnectionManager {
-  static {
-    __name(this, "WebSocketConnectionManager");
-  }
-  url;
-  headers;
-  _ws = null;
-  /**
-   * @param url     The WebSocket URL to connect to.
-   * @param headers Optional headers to include in the connection handshake.
-   */
-  constructor(url, headers = {}) {
-    super();
-    this.url = url;
-    this.headers = headers;
-  }
-  /** Establish a WebSocket connection and wait until it is open. */
-  async establishConnection() {
-    logger.debug(`Connecting to WebSocket: ${this.url}`);
-    return new Promise((resolve, reject) => {
-      const ws = new import_ws.default(this.url, {
-        headers: this.headers
-      });
-      this._ws = ws;
-      const onOpen = /* @__PURE__ */ __name(() => {
-        cleanup();
-        logger.debug("WebSocket connected successfully");
-        resolve(ws);
-      }, "onOpen");
-      const onError = /* @__PURE__ */ __name((err) => {
-        cleanup();
-        logger.error(`Failed to connect to WebSocket: ${err}`);
-        reject(err);
-      }, "onError");
-      const cleanup = /* @__PURE__ */ __name(() => {
-        ws.off("open", onOpen);
-        ws.off("error", onError);
-      }, "cleanup");
-      ws.on("open", onOpen);
-      ws.on("error", onError);
-    });
-  }
-  /** Cleanly close the WebSocket connection. */
-  async closeConnection(connection) {
-    logger.debug("Closing WebSocket connection");
-    return new Promise((resolve) => {
-      const onClose = /* @__PURE__ */ __name(() => {
-        connection.off("close", onClose);
-        this._ws = null;
-        resolve();
-      }, "onClose");
-      if (connection.readyState === import_ws.default.CLOSED) {
-        onClose();
-        return;
-      }
-      connection.on("close", onClose);
-      try {
-        connection.close();
-      } catch (e) {
-        logger.warn(`Error closing WebSocket connection: ${e}`);
-        onClose();
-      }
-    });
-  }
-};
-
-// src/connectors/websocket.ts
-var WebSocketConnector = class extends BaseConnector {
-  static {
-    __name(this, "WebSocketConnector");
-  }
-  url;
-  headers;
-  connectionManager = null;
-  ws = null;
-  receiverTask = null;
-  pending = /* @__PURE__ */ new Map();
-  toolsCache = null;
-  constructor(url, opts = {}) {
-    super();
-    this.url = url;
-    this.headers = { ...opts.headers ?? {} };
-    if (opts.authToken) this.headers.Authorization = `Bearer ${opts.authToken}`;
-  }
-  async connect() {
-    if (this.connected) {
-      logger.debug("Already connected to MCP implementation");
-      return;
-    }
-    logger.debug(`Connecting via WebSocket: ${this.url}`);
-    try {
-      this.connectionManager = new WebSocketConnectionManager(
-        this.url,
-        this.headers
-      );
-      this.ws = await this.connectionManager.start();
-      this.receiverTask = this.receiveLoop();
-      this.connected = true;
-      logger.debug("WebSocket connected successfully");
-    } catch (e) {
-      logger.error(`Failed to connect: ${e}`);
-      await this.cleanupResources();
-      throw e;
-    }
-  }
-  async disconnect() {
-    if (!this.connected) {
-      logger.debug("Not connected to MCP implementation");
-      return;
-    }
-    logger.debug("Disconnecting \u2026");
-    await this.cleanupResources();
-    this.connected = false;
-  }
-  sendRequest(method, params = null) {
-    if (!this.ws) throw new Error("WebSocket is not connected");
-    const id = generateUUID();
-    const payload = JSON.stringify({ id, method, params: params ?? {} });
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-      this.ws.send(payload, (err) => {
-        if (err) {
-          this.pending.delete(id);
-          reject(err);
-        }
-      });
-    });
-  }
-  async receiveLoop() {
-    if (!this.ws) return;
-    const socket = this.ws;
-    const onMessage = /* @__PURE__ */ __name((msg) => {
-      let data;
-      try {
-        data = JSON.parse(msg.data ?? msg);
-      } catch (e) {
-        logger.warn("Received non\u2011JSON frame", e);
-        return;
-      }
-      const id = data.id;
-      if (id && this.pending.has(id)) {
-        const { resolve, reject } = this.pending.get(id);
-        this.pending.delete(id);
-        if ("result" in data) resolve(data.result);
-        else if ("error" in data) reject(data.error);
-      } else if (data.method && !data.id) {
-        logger.debug("Received notification", data.method, data.params);
-        this.handleNotification(data);
-      } else {
-        logger.debug("Received unsolicited message", data);
-      }
-    }, "onMessage");
-    if (socket.addEventListener) {
-      socket.addEventListener("message", onMessage);
-    } else {
-      socket.on("message", onMessage);
-    }
-    return new Promise((resolve) => {
-      const onClose = /* @__PURE__ */ __name(() => {
-        if (socket.removeEventListener) {
-          socket.removeEventListener("message", onMessage);
-        } else {
-          socket.off("message", onMessage);
-        }
-        this.rejectAll(new Error("WebSocket closed"));
-        resolve();
-      }, "onClose");
-      if (socket.addEventListener) {
-        socket.addEventListener("close", onClose);
-      } else {
-        socket.on("close", onClose);
-      }
-    });
-  }
-  rejectAll(err) {
-    for (const { reject } of this.pending.values()) reject(err);
-    this.pending.clear();
-  }
-  async handleNotification(data) {
-    switch (data.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({
-          method: data.method,
-          params: data.params
-        });
-      } catch (err) {
-        logger.error("Error in notification handler:", err);
-      }
-    }
-  }
-  /**
-   * Auto-refresh tools cache when server sends tools/list_changed notification
-   * Override to use WebSocket-specific listTools method
-   */
-  async refreshToolsCache() {
-    try {
-      logger.debug(
-        "[Auto] Refreshing tools cache due to list_changed notification"
-      );
-      const tools = await this.listTools();
-      this.toolsCache = tools.map((t) => t);
-      logger.debug(
-        `[Auto] Refreshed tools cache: ${this.toolsCache.length} tools`
-      );
-    } catch (err) {
-      logger.warn("[Auto] Failed to refresh tools cache:", err);
-    }
-  }
-  async initialize() {
-    logger.debug("Initializing MCP session over WebSocket");
-    const result = await this.sendRequest("initialize");
-    const toolsList = await this.listTools();
-    this.toolsCache = toolsList.map((t) => t);
-    logger.debug(`Initialized with ${this.toolsCache.length} tools`);
-    return result;
-  }
-  async listTools() {
-    const res = await this.sendRequest("tools/list");
-    return res.tools ?? [];
-  }
-  async callTool(name, args) {
-    return await this.sendRequest("tools/call", { name, arguments: args });
-  }
-  async listResources() {
-    const resources = await this.sendRequest("resources/list");
-    return { resources: Array.isArray(resources) ? resources : [] };
-  }
-  async readResource(uri) {
-    const res = await this.sendRequest("resources/read", { uri });
-    return res;
-  }
-  async request(method, params = null) {
-    return await this.sendRequest(method, params);
-  }
-  get tools() {
-    if (!this.toolsCache) throw new Error("MCP client is not initialized");
-    return this.toolsCache;
-  }
-  async cleanupResources() {
-    if (this.receiverTask) await this.receiverTask.catch(() => {
-    });
-    this.receiverTask = null;
-    this.rejectAll(new Error("WebSocket disconnected"));
-    if (this.connectionManager) {
-      await this.connectionManager.stop();
-      this.connectionManager = null;
-      this.ws = null;
-    }
-    this.toolsCache = null;
-  }
-  get publicIdentifier() {
-    return {
-      type: "websocket",
-      url: this.url
-    };
-  }
-};
-
 // src/client/browser.ts
 init_logging();
 
@@ -3380,6 +3161,22 @@ var MCPSession = class {
   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.
    *
@@ -3400,7 +3197,7 @@ var MCPSession = class {
    * Call a tool on the server.
    *
    * @param name - Name of the tool to call
-   * @param args - Arguments to pass to the tool
+   * @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
    *
@@ -3410,7 +3207,7 @@ var MCPSession = class {
    * console.log(`Result: ${result.content[0].text}`);
    * ```
    */
-  async callTool(name, args, options) {
+  async callTool(name, args = {}, options) {
     return this.connector.callTool(name, args, options);
   }
   /**
@@ -3625,6 +3422,15 @@ var BaseMCPClient = class {
     }
     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]])
@@ -3710,12 +3516,11 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
   }
   /**
    * Create a connector from server configuration (Browser version)
-   * Supports HTTP and WebSocket connectors only
+   * Supports HTTP connector only
    */
   createConnectorFromConfig(serverConfig) {
     const {
       url,
-      transport,
       headers,
       authToken,
       authProvider,
@@ -3751,13 +3556,7 @@ var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
         "[BrowserMCPClient] No clientOptions provided to connector!"
       );
     }
-    if (transport === "websocket" || url.startsWith("ws://") || url.startsWith("wss://")) {
-      return new WebSocketConnector(url, connectorOptions);
-    } else if (transport === "http" || url.startsWith("http://") || url.startsWith("https://")) {
-      return new HttpConnector(url, connectorOptions);
-    } else {
-      return new HttpConnector(url, connectorOptions);
-    }
+    return new HttpConnector(url, connectorOptions);
   }
 };
 
@@ -4542,6 +4341,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.
    *
@@ -4620,16 +4511,1238 @@ var LangChainAdapter = class extends BaseAdapter {
     });
     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/agents/mcp_agent.ts
-init_logging();
+// src/client.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
 
-// src/managers/server_manager.ts
+// src/client/executors/base.ts
 init_logging();
-
-// src/managers/tools/acquire_active_mcp_server.ts
-var import_zod3 = require("zod");
+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/client/connectors/codeMode.ts
+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/config.ts
+var import_node_fs = require("fs");
+
+// 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/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(createConnectorFromConfig, "createConnectorFromConfig");
+
+// src/client.ts
+init_logging();
+var MCPClient = class _MCPClient extends BaseMCPClient {
+  static {
+    __name(this, "MCPClient");
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Save configuration to a file (Node.js only)
+   */
+  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 });
+    }
+    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 {
+          this._codeExecutor = new VMCodeExecutor(
+            this,
+            this._executorOptions
+          );
+        } catch (error) {
+          const e2bOpts = this._executorOptions;
+          const e2bApiKey = e2bOpts?.apiKey || process.env.E2B_API_KEY;
+          if (e2bApiKey) {
+            logger.info(
+              "VM executor not available in this environment. Falling back to E2B."
+            );
+            this._codeExecutor = new E2BCodeExecutor(this, {
+              ...e2bOpts,
+              apiKey: e2bApiKey
+            });
+          } else {
+            throw new Error(
+              "VM executor is not available in this environment. Please provide an E2B API key via executorOptions or E2B_API_KEY environment variable, or run in a Node.js environment."
+            );
+          }
+        }
+      }
+    }
+    return this._codeExecutor;
+  }
+  /**
+   * 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";
+    });
+  }
+  /**
+   * 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();
+  }
+};
+
+// src/agents/mcp_agent.ts
+init_logging();
+
+// src/managers/server_manager.ts
+init_logging();
+
+// src/managers/tools/acquire_active_mcp_server.ts
+var import_zod3 = require("zod");
 
 // src/managers/tools/base.ts
 var import_tools2 = require("@langchain/core/tools");
@@ -4759,15 +5872,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)}`
@@ -4929,21 +6048,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(
@@ -5271,6 +6399,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");
@@ -5367,8 +6515,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 {
@@ -5379,10 +6539,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 = {
@@ -5456,8 +6616,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;
@@ -5482,9 +6642,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,
@@ -5497,7 +6657,166 @@ 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");
+function isValidLLMString(llmString) {
+  try {
+    parseLLMString(llmString);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isValidLLMString, "isValidLLMString");
+function getSupportedProviders() {
+  return Object.keys(PROVIDER_CONFIG);
+}
+__name(getSupportedProviders, "getSupportedProviders");
+
 // 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");
@@ -5543,6 +6862,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;
@@ -5576,9 +6901,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;
@@ -5591,28 +6943,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";
     }
@@ -5643,6 +6997,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) {
@@ -5686,9 +7074,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);
@@ -5701,12 +7098,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`);
@@ -6169,33 +7573,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;
     }
@@ -6205,7 +7623,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) {
@@ -6229,7 +7647,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)) {
@@ -6370,13 +7788,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(
@@ -6402,7 +7820,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();
       }
@@ -6432,9 +7850,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,
@@ -6443,7 +7861,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();
       }
@@ -6471,15 +7889,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();
       }
@@ -6488,16 +7919,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,
@@ -6508,22 +7935,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) {
@@ -6534,14 +7971,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)) {
@@ -6608,17 +8045,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;
@@ -6673,7 +8106,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"
         );
@@ -6704,15 +8137,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();
       }