mcp-use 1.3.4-canary.2 → 1.4.0

package/dist/index.cjs

@@ -559,6 +559,360 @@ var init_langfuse = __esm({
   }
 });
 
+// src/agents/display.ts
+var display_exports = {};
+__export(display_exports, {
+  extractCodeFromToolInput: () => extractCodeFromToolInput,
+  extractToolMessageContent: () => extractToolMessageContent,
+  formatSearchToolsAsTree: () => formatSearchToolsAsTree,
+  handleToolEnd: () => handleToolEnd,
+  handleToolStart: () => handleToolStart,
+  parseExecuteCodeResult: () => parseExecuteCodeResult,
+  prettyStreamEvents: () => prettyStreamEvents,
+  printBox: () => printBox,
+  renderContent: () => renderContent,
+  unwrapToolInput: () => unwrapToolInput
+});
+function stripAnsi(str) {
+  return (0, import_strip_ansi.default)(str);
+}
+function wrapAnsiLine(line, maxWidth) {
+  const stripped = stripAnsi(line);
+  if (stripped.length <= maxWidth) return [line];
+  const result = [];
+  let visibleCount = 0;
+  let current = "";
+  let i = 0;
+  while (i < line.length) {
+    const char = line[i];
+    if (char === "\x1B") {
+      let sequence = char;
+      i++;
+      while (i < line.length) {
+        const nextChar = line[i];
+        sequence += nextChar;
+        i++;
+        if (nextChar === "m") break;
+      }
+      current += sequence;
+      continue;
+    }
+    current += char;
+    visibleCount++;
+    i++;
+    if (visibleCount >= maxWidth) {
+      result.push(current);
+      current = "";
+      visibleCount = 0;
+    }
+  }
+  if (current) result.push(current);
+  return result;
+}
+function printBox(content, title, language, bgColor = false) {
+  const width = TERMINAL_WIDTH;
+  let displayContent = content;
+  if (language) {
+    try {
+      displayContent = (0, import_cli_highlight.highlight)(content, { language, ignoreIllegals: true });
+    } catch {
+    }
+  }
+  const lines = displayContent.split("\n").flatMap((line) => wrapAnsiLine(line, width - 4));
+  console.log(import_chalk.default.gray("\u250C" + "\u2500".repeat(width - 2) + "\u2510"));
+  if (title) {
+    const stripped = stripAnsi(title);
+    const lineText = `${title} `;
+    const padding = Math.max(0, width - 4 - stripped.length - 2);
+    console.log(
+      import_chalk.default.gray("\u2502 ") + import_chalk.default.bold.white(lineText) + " ".repeat(padding) + import_chalk.default.gray(" \u2502")
+    );
+    console.log(import_chalk.default.gray("\u251C" + "\u2500".repeat(width - 2) + "\u2524"));
+  }
+  lines.forEach((line) => {
+    const stripped = stripAnsi(line);
+    const padding = Math.max(0, width - 4 - stripped.length);
+    const finalLine = bgColor ? import_chalk.default.bgGray(line + " ".repeat(padding)) : line + " ".repeat(padding);
+    console.log(import_chalk.default.gray("\u2502 ") + finalLine + import_chalk.default.gray(" \u2502"));
+  });
+  console.log(import_chalk.default.gray("\u2514" + "\u2500".repeat(width - 2) + "\u2518"));
+}
+function extractCodeFromToolInput(input) {
+  if (typeof input === "object" && input !== null && "code" in input) {
+    const inputObj = input;
+    return typeof inputObj.code === "string" ? inputObj.code : null;
+  }
+  return null;
+}
+function isExecuteCodeResult(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const result = obj;
+  return "result" in result && "logs" in result && Array.isArray(result.logs) && "execution_time" in result && typeof result.execution_time === "number" && "error" in result && (typeof result.error === "string" || result.error === null);
+}
+function parseExecuteCodeResult(output) {
+  try {
+    if (typeof output === "string") {
+      const parsed = JSON.parse(output);
+      if (isExecuteCodeResult(parsed)) {
+        return parsed;
+      }
+    }
+    if (isExecuteCodeResult(output)) {
+      return output;
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function renderContent(content) {
+  if (content === null || content === void 0) {
+    return "null";
+  }
+  if (typeof content === "object") {
+    return JSON.stringify(content, null, 2);
+  }
+  return String(content);
+}
+function unwrapToolInput(input) {
+  if (typeof input === "object" && input !== null && "input" in input) {
+    const inputObj = input;
+    if (typeof inputObj.input === "string") {
+      try {
+        return JSON.parse(inputObj.input);
+      } catch (e) {
+        return inputObj.input;
+      }
+    }
+  }
+  return input;
+}
+function handleToolStart(event) {
+  const toolName = event.name || "unknown";
+  let input = event.data?.input || {};
+  input = unwrapToolInput(input);
+  const code = extractCodeFromToolInput(input);
+  if (code) {
+    printBox(code, `${toolName} - input`, "javascript", false);
+    const otherParams = { ...input };
+    delete otherParams.code;
+    if (Object.keys(otherParams).length > 0) {
+      printBox(renderContent(otherParams), "Other Parameters", "json", false);
+    }
+  } else {
+    printBox(renderContent(input), `${toolName} - input`, "json", false);
+  }
+}
+function extractToolMessageContent(output) {
+  try {
+    if (typeof output === "object" && output !== null && "name" in output && "content" in output) {
+      const outputObj = output;
+      const toolName = (typeof outputObj.name === "string" ? outputObj.name : null) || "unknown";
+      const lcKwargs = outputObj.lc_kwargs;
+      const status = lcKwargs?.status || outputObj.status || "unknown";
+      let content = outputObj.content;
+      if (typeof content === "string") {
+        try {
+          content = JSON.parse(content);
+        } catch (e) {
+        }
+      }
+      return { toolName, status, content };
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function formatSearchToolsAsTree(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return "(no tools found)";
+  }
+  const toolsByServer = {};
+  for (const tool of tools) {
+    const server = tool.server || "unknown";
+    if (!toolsByServer[server]) {
+      toolsByServer[server] = [];
+    }
+    toolsByServer[server].push(tool);
+  }
+  const lines = [];
+  const servers = Object.keys(toolsByServer).sort();
+  for (let i = 0; i < servers.length; i++) {
+    const server = servers[i];
+    const serverTools = toolsByServer[server];
+    const isLastServer = i === servers.length - 1;
+    const serverPrefix = isLastServer ? "\u2514\u2500" : "\u251C\u2500";
+    lines.push(
+      `${serverPrefix} ${import_chalk.default.cyan(server)} (${serverTools.length} tools)`
+    );
+    for (let j = 0; j < serverTools.length; j++) {
+      const tool = serverTools[j];
+      const isLastTool = j === serverTools.length - 1;
+      const indent = isLastServer ? "  " : "\u2502 ";
+      const toolPrefix = isLastTool ? "\u2514\u2500" : "\u251C\u2500";
+      let toolLine = `${indent}${toolPrefix} ${tool.name}`;
+      if (tool.description) {
+        toolLine += import_chalk.default.dim(` - ${tool.description}`);
+      }
+      lines.push(toolLine);
+    }
+  }
+  return lines.join("\n");
+}
+function handleToolEnd(event) {
+  const output = event.data?.output;
+  const toolMessage = extractToolMessageContent(output);
+  if (toolMessage) {
+    const { toolName, status, content } = toolMessage;
+    if (toolName === "execute_code") {
+      let actualContent = content;
+      if (typeof content === "object" && content !== null && "content" in content) {
+        const innerContent = content.content;
+        if (Array.isArray(innerContent) && innerContent.length > 0) {
+          if (innerContent[0].type === "text" && innerContent[0].text) {
+            actualContent = innerContent[0].text;
+          }
+        }
+      }
+      const execResult2 = parseExecuteCodeResult(actualContent);
+      if (execResult2) {
+        const timeMs = execResult2.execution_time ? Math.round(execResult2.execution_time * 1e3) : 0;
+        const timeStr = `${timeMs}ms`;
+        const isError2 = execResult2.error !== null && execResult2.error !== void 0 && execResult2.error !== "";
+        const statusText = isError2 ? import_chalk.default.red("error") : import_chalk.default.green("success");
+        const title2 = `${toolName} - ${statusText} - ${timeStr}`;
+        if (execResult2.result !== null && execResult2.result !== void 0) {
+          const resultStr = renderContent(execResult2.result);
+          const language3 = typeof execResult2.result === "object" ? "json" : void 0;
+          printBox(resultStr, title2, language3, false);
+        } else {
+          printBox("(no result)", title2, void 0, false);
+        }
+        if (execResult2.logs && execResult2.logs.length > 0) {
+          printBox(execResult2.logs.join("\n"), `Logs`, void 0, false);
+        }
+        if (execResult2.error) {
+          printBox(execResult2.error, import_chalk.default.red("Error"), void 0, false);
+        }
+        return;
+      }
+    }
+    if (toolName === "search_tools") {
+      let actualContent = content;
+      if (typeof content === "object" && content !== null && !Array.isArray(content) && "content" in content) {
+        const innerContent = content.content;
+        if (Array.isArray(innerContent) && innerContent.length > 0) {
+          if (innerContent[0].type === "text" && innerContent[0].text) {
+            try {
+              actualContent = JSON.parse(innerContent[0].text);
+            } catch (e) {
+              actualContent = innerContent[0].text;
+            }
+          }
+        }
+      }
+      if (Array.isArray(actualContent)) {
+        const treeStr = formatSearchToolsAsTree(actualContent);
+        const statusText = status === "success" ? import_chalk.default.green("Success") : import_chalk.default.red("Error");
+        const title2 = `${statusText}: ${toolName} - Result`;
+        printBox(treeStr, title2, void 0, false);
+        return;
+      }
+    }
+    const contentObj = typeof content === "object" && content !== null ? content : null;
+    const isError = contentObj && "isError" in contentObj && contentObj.isError === true || status === "error";
+    let displayContent = content;
+    if (typeof content === "object" && content !== null && "content" in content) {
+      displayContent = content.content;
+      if (Array.isArray(displayContent) && displayContent.length > 0) {
+        if (displayContent[0].type === "text" && displayContent[0].text) {
+          displayContent = displayContent[0].text;
+        }
+      }
+    }
+    const contentStr = renderContent(displayContent);
+    const language2 = typeof displayContent === "object" ? "json" : void 0;
+    const statusLabel = status === "success" ? import_chalk.default.green("Success") : isError ? import_chalk.default.red("Error") : "Result";
+    const title = `${statusLabel}: ${toolName} - Result`;
+    printBox(contentStr, title, language2, false);
+    return;
+  }
+  const execResult = parseExecuteCodeResult(output);
+  if (execResult) {
+    const timeMs = execResult.execution_time ? Math.round(execResult.execution_time * 1e3) : 0;
+    const timeStr = `${timeMs}ms`;
+    if (execResult.result !== null && execResult.result !== void 0) {
+      const resultStr = renderContent(execResult.result);
+      const language2 = typeof execResult.result === "object" ? "json" : void 0;
+      printBox(resultStr, `Result - ${timeStr}`, language2, false);
+    }
+    if (execResult.logs && execResult.logs.length > 0) {
+      printBox(execResult.logs.join("\n"), `Logs`, void 0, false);
+    }
+    if (execResult.error) {
+      printBox(execResult.error, import_chalk.default.red("Error"), void 0, false);
+    }
+    return;
+  }
+  const outputStr = renderContent(output);
+  const language = typeof output === "object" ? "json" : void 0;
+  printBox(outputStr, "Result", language, false);
+}
+async function* prettyStreamEvents(streamEventsGenerator) {
+  let finalResponse = "";
+  let isFirstTextChunk = true;
+  let hasStreamedText = false;
+  for await (const event of streamEventsGenerator) {
+    if (event.event === "on_tool_start") {
+      if (hasStreamedText) {
+        process.stdout.write("\n");
+        hasStreamedText = false;
+        isFirstTextChunk = true;
+      }
+      handleToolStart(event);
+    } else if (event.event === "on_tool_end") {
+      handleToolEnd(event);
+    } else if (event.event === "on_chat_model_stream") {
+      if (event.data?.chunk?.text) {
+        const text = event.data.chunk.text;
+        if (typeof text === "string" && text.length > 0) {
+          if (isFirstTextChunk) {
+            process.stdout.write("\n\u{1F916} ");
+            isFirstTextChunk = false;
+          }
+          process.stdout.write(text);
+          finalResponse += text;
+          hasStreamedText = true;
+        }
+      }
+    }
+    yield;
+  }
+  return finalResponse;
+}
+var import_chalk, import_cli_highlight, import_strip_ansi, TERMINAL_WIDTH;
+var init_display = __esm({
+  "src/agents/display.ts"() {
+    "use strict";
+    import_chalk = __toESM(require("chalk"), 1);
+    import_cli_highlight = require("cli-highlight");
+    import_strip_ansi = __toESM(require("strip-ansi"), 1);
+    TERMINAL_WIDTH = process.stdout.columns || 120;
+    __name(stripAnsi, "stripAnsi");
+    __name(wrapAnsiLine, "wrapAnsiLine");
+    __name(printBox, "printBox");
+    __name(extractCodeFromToolInput, "extractCodeFromToolInput");
+    __name(isExecuteCodeResult, "isExecuteCodeResult");
+    __name(parseExecuteCodeResult, "parseExecuteCodeResult");
+    __name(renderContent, "renderContent");
+    __name(unwrapToolInput, "unwrapToolInput");
+    __name(handleToolStart, "handleToolStart");
+    __name(extractToolMessageContent, "extractToolMessageContent");
+    __name(formatSearchToolsAsTree, "formatSearchToolsAsTree");
+    __name(handleToolEnd, "handleToolEnd");
+    __name(prettyStreamEvents, "prettyStreamEvents");
+  }
+});
+
 // index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -578,6 +932,7 @@ __export(index_exports, {
   MCPSession: () => MCPSession,
   OAuthHelper: () => OAuthHelper,
   ObservabilityManager: () => ObservabilityManager,
+  PROMPTS: () => PROMPTS,
   ReleaseMCPServerConnectionTool: () => ReleaseMCPServerConnectionTool,
   RemoteAgent: () => RemoteAgent,
   ServerManager: () => ServerManager,
@@ -2188,18 +2543,35 @@ var MCPAgent = class {
         logger.info(
           `\u{1F50C} Found ${Object.keys(this.sessions).length} existing sessions`
         );
-        if (Object.keys(this.sessions).length === 0) {
+        const nonCodeModeSessions = Object.keys(this.sessions).filter(
+          (name) => name !== "code_mode"
+        );
+        if (nonCodeModeSessions.length === 0) {
           logger.info("\u{1F504} No active sessions found, creating new ones...");
           this.sessions = await this.client.createAllSessions();
           logger.info(
             `\u2705 Created ${Object.keys(this.sessions).length} new sessions`
           );
         }
-        this._tools = await LangChainAdapter.createTools(this.client);
+        if (this.client.codeMode) {
+          const codeModeSession = this.sessions["code_mode"];
+          if (codeModeSession) {
+            this._tools = await this.adapter.createToolsFromConnectors([
+              codeModeSession.connector
+            ]);
+            logger.info(`\u{1F6E0}\uFE0F Created ${this._tools.length} code mode tools`);
+          } else {
+            throw new Error(
+              "Code mode enabled but code_mode session not found"
+            );
+          }
+        } else {
+          this._tools = await LangChainAdapter.createTools(this.client);
+          logger.info(
+            `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
+          );
+        }
         this._tools.push(...this.additionalTools);
-        logger.info(
-          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
-        );
       } else {
         logger.info(
           `\u{1F517} Connecting to ${this.connectors.length} direct connectors...`
@@ -2764,6 +3136,8 @@ var MCPAgent = class {
           tags: this.getTags(),
           // Set trace name for LangChain/Langfuse
           runName: this.metadata.trace_name || "mcp-use-agent",
+          // Set recursion limit to 3x maxSteps to account for model calls + tool executions
+          recursionLimit: this.maxSteps * 3,
           // Pass sessionId for Langfuse if present in metadata
           ...this.metadata.session_id && {
             sessionId: this.metadata.session_id
@@ -2977,8 +3351,8 @@ var MCPAgent = class {
       this._agentExecutor = null;
       this._tools = [];
       if (this.client) {
-        logger.info("\u{1F504} Closing sessions through client");
-        await this.client.closeAllSessions();
+        logger.info("\u{1F504} Closing client and cleaning up resources");
+        await this.client.close();
         this.sessions = {};
       } else {
         for (const connector of this.connectors) {
@@ -2994,6 +3368,26 @@ 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) {
+    const { prettyStreamEvents: prettyStream } = await Promise.resolve().then(() => (init_display(), display_exports));
+    const finalResponse = "";
+    for await (const _ of prettyStream(
+      this.streamEvents(
+        query,
+        maxSteps,
+        manageConnector,
+        externalHistory,
+        outputSchema
+      )
+    )) {
+      yield;
+    }
+    return finalResponse;
+  }
   /**
    * Yields LangChain StreamEvent objects from the underlying streamEvents() method.
    * This provides token-level streaming and fine-grained event updates.
@@ -3021,11 +3415,11 @@ var MCPAgent = class {
         throw new Error("MCP agent failed to initialize");
       }
       this.maxSteps = maxSteps ?? this.maxSteps;
-      const display_query = query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : query.replace(/\n/g, " ");
+      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: ${query}`);
-        this.addToHistory(new import_langchain2.HumanMessage(query));
+        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 langchainHistory = [];
@@ -3053,6 +3447,8 @@ var MCPAgent = class {
           tags: this.getTags(),
           // Set trace name for LangChain/Langfuse
           runName: this.metadata.trace_name || "mcp-use-agent",
+          // Set recursion limit to 3x maxSteps to account for model calls + tool executions
+          recursionLimit: this.maxSteps * 3,
           // Pass sessionId for Langfuse if present in metadata
           ...this.metadata.session_id && {
             sessionId: this.metadata.session_id
@@ -3152,6 +3548,7 @@ var MCPAgent = class {
       } else if (this.memoryEnabled && finalResponse) {
         this.addToHistory(new import_langchain2.AIMessage(finalResponse));
       }
+      console.log("\n\n");
       logger.info(`\u{1F389} StreamEvents complete - ${eventCount} events emitted`);
       success = true;
     } catch (e) {
@@ -3543,228 +3940,558 @@ var BaseMCPClient = class {
   }
 };
 
-// src/config.ts
-var import_node_fs = require("fs");
-
-// src/connectors/http.ts
-var import_client = require("@modelcontextprotocol/sdk/client/index.js");
-var import_streamableHttp2 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-init_logging();
-
-// src/task_managers/sse.ts
-var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
-init_logging();
-
-// src/task_managers/base.ts
+// src/client/executors/base.ts
 init_logging();
-var ConnectionManager = class {
+var BaseCodeExecutor = class {
   static {
-    __name(this, "ConnectionManager");
-  }
-  _readyPromise;
-  _readyResolver;
-  _donePromise;
-  _doneResolver;
-  _exception = null;
-  _connection = null;
-  _task = null;
-  _abortController = null;
-  constructor() {
-    this.reset();
+    __name(this, "BaseCodeExecutor");
   }
-  /**
-   * Start the connection manager and establish a connection.
-   *
-   * @returns The established connection.
-   * @throws If the connection cannot be established.
-   */
-  async start() {
-    this.reset();
-    logger.debug(`Starting ${this.constructor.name}`);
-    this._task = this.connectionTask();
-    await this._readyPromise;
-    if (this._exception) {
-      throw this._exception;
-    }
-    if (this._connection === null) {
-      throw new Error("Connection was not established");
-    }
-    return this._connection;
+  client;
+  _connecting = false;
+  constructor(client) {
+    this.client = client;
   }
   /**
-   * Stop the connection manager and close the connection.
+   * Ensure all configured MCP servers are connected before execution.
+   * Prevents race conditions with a connection lock.
    */
-  async stop() {
-    if (this._task && this._abortController) {
-      logger.debug(`Cancelling ${this.constructor.name} task`);
-      this._abortController.abort();
+  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 {
-        await this._task;
-      } catch (e) {
-        if (e instanceof Error && e.name === "AbortError") {
-          logger.debug(`${this.constructor.name} task aborted successfully`);
-        } else {
-          logger.warn(`Error stopping ${this.constructor.name} task: ${e}`);
-        }
+        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));
       }
     }
-    await this._donePromise;
-    logger.debug(`${this.constructor.name} task completed`);
-  }
-  /**
-   * Reset all internal state.
-   */
-  reset() {
-    this._readyPromise = new Promise((res) => this._readyResolver = res);
-    this._donePromise = new Promise((res) => this._doneResolver = res);
-    this._exception = null;
-    this._connection = null;
-    this._task = null;
-    this._abortController = new AbortController();
   }
   /**
-   * The background task responsible for establishing and maintaining the
-   * connection until it is cancelled.
+   * Get tool namespace information from all active MCP sessions.
+   * Filters out the internal code_mode server.
    */
-  async connectionTask() {
-    logger.debug(`Running ${this.constructor.name} task`);
-    try {
-      this._connection = await this.establishConnection();
-      logger.debug(`${this.constructor.name} connected successfully`);
-      this._readyResolver();
-      await this.waitForAbort();
-    } catch (err) {
-      this._exception = err;
-      logger.error(`Error in ${this.constructor.name} task: ${err}`);
-      this._readyResolver();
-    } finally {
-      if (this._connection !== null) {
+  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 {
-          await this.closeConnection(this._connection);
-        } catch (closeErr) {
-          logger.warn(
-            `Error closing connection in ${this.constructor.name}: ${closeErr}`
-          );
+          tools = connector.tools;
+        } catch (e) {
+          logger.warn(`Tools not available for server ${serverName}: ${e}`);
+          continue;
         }
-        this._connection = null;
+        if (!tools || tools.length === 0) continue;
+        namespaces.push({ serverName, tools, session });
+      } catch (e) {
+        logger.warn(`Failed to load tools for server ${serverName}: ${e}`);
       }
-      this._doneResolver();
     }
+    return namespaces;
   }
   /**
-   * Helper that returns a promise which resolves when the abort signal fires.
+   * Create a search function for discovering available MCP tools.
+   * Used by code execution environments to find tools at runtime.
    */
-  async waitForAbort() {
-    return new Promise((_resolve, _reject) => {
-      if (!this._abortController) {
-        return;
-      }
-      const signal = this._abortController.signal;
-      if (signal.aborted) {
-        _resolve();
-        return;
+  createSearchToolsFunction() {
+    return async (query = "", detailLevel = "full") => {
+      const allTools = [];
+      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;
+          for (const tool of tools) {
+            if (query) {
+              const nameMatch = tool.name.toLowerCase().includes(queryLower);
+              const descMatch = tool.description?.toLowerCase().includes(queryLower);
+              if (!nameMatch && !descMatch) continue;
+            }
+            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}`);
+        }
       }
-      const onAbort = /* @__PURE__ */ __name(() => {
-        signal.removeEventListener("abort", onAbort);
-        _resolve();
-      }, "onAbort");
-      signal.addEventListener("abort", onAbort);
-    });
+      return allTools;
+    };
   }
 };
 
-// src/task_managers/sse.ts
-var SseConnectionManager = class extends ConnectionManager {
+// src/client/executors/e2b.ts
+init_logging();
+var E2BCodeExecutor = class extends BaseCodeExecutor {
   static {
-    __name(this, "SseConnectionManager");
+    __name(this, "E2BCodeExecutor");
+  }
+  e2bApiKey;
+  codeExecSandbox = null;
+  SandboxClass = null;
+  timeoutMs;
+  constructor(client, options) {
+    super(client);
+    this.e2bApiKey = options.apiKey;
+    this.timeoutMs = options.timeoutMs ?? 3e5;
   }
-  url;
-  opts;
-  _transport = null;
   /**
-   * Create an SSE connection manager.
-   *
-   * @param url  The SSE endpoint URL.
-   * @param opts Optional transport options (auth, headers, etc.).
+   * Lazy load E2B Sandbox class.
+   * This allows the library to work without E2B installed.
    */
-  constructor(url, opts) {
-    super();
-    this.url = typeof url === "string" ? new URL(url) : url;
-    this.opts = opts;
+  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"
+      );
+    }
   }
   /**
-   * Spawn a new `SSEClientTransport` and start the connection.
+   * Get or create a dedicated sandbox for code execution.
    */
-  async establishConnection() {
-    this._transport = new import_sse.SSEClientTransport(this.url, this.opts);
-    logger.debug(`${this.constructor.name} connected successfully`);
-    return this._transport;
+  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;
   }
   /**
-   * Close the underlying transport and clean up resources.
+   * Generate the shim code that exposes tools to the sandbox environment.
+   * Creates a bridge that intercepts tool calls and sends them back to host.
    */
-  async closeConnection(_connection) {
-    if (this._transport) {
+  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._transport.close();
-      } catch (e) {
-        logger.warn(`Error closing SSE transport: ${e}`);
-      } finally {
-        this._transport = null;
+        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/task_managers/streamable_http.ts
-var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+// src/client/executors/vm.ts
+var import_node_vm = __toESM(require("vm"), 1);
 init_logging();
-var StreamableHttpConnectionManager = class extends ConnectionManager {
+var VMCodeExecutor = class extends BaseCodeExecutor {
   static {
-    __name(this, "StreamableHttpConnectionManager");
+    __name(this, "VMCodeExecutor");
   }
-  url;
-  opts;
-  _transport = null;
-  /**
-   * Create a Streamable HTTP connection manager.
-   *
-   * @param url  The HTTP endpoint URL.
-   * @param opts Optional transport options (auth, headers, etc.).
-   */
-  constructor(url, opts) {
-    super();
-    this.url = typeof url === "string" ? new URL(url) : url;
-    this.opts = opts;
+  defaultTimeout;
+  memoryLimitMb;
+  constructor(client, options) {
+    super(client);
+    this.defaultTimeout = options?.timeoutMs ?? 3e4;
+    this.memoryLimitMb = options?.memoryLimitMb;
   }
   /**
-   * Spawn a new `StreamableHTTPClientTransport` and return it.
-   * The Client.connect() method will handle starting the transport.
+   * 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 establishConnection() {
-    this._transport = new import_streamableHttp.StreamableHTTPClientTransport(this.url, this.opts);
-    logger.debug(`${this.constructor.name} created successfully`);
-    return this._transport;
+  async execute(code, timeout) {
+    const effectiveTimeout = timeout ?? this.defaultTimeout;
+    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 import_node_vm.default.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
+    };
   }
   /**
-   * Close the underlying transport and clean up resources.
+   * Build the VM execution context with MCP tools and standard globals.
+   *
+   * @param logs - Array to capture console output
    */
-  async closeConnection(_connection) {
-    if (this._transport) {
-      try {
-        await this._transport.close();
-      } catch (e) {
-        logger.warn(`Error closing Streamable HTTP transport: ${e}`);
-      } finally {
-        this._transport = null;
+  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 import_node_vm.default.createContext(sandbox);
   }
   /**
-   * Get the session ID from the transport if available.
+   * Clean up resources.
+   * VM executor doesn't need cleanup, but method kept for interface consistency.
    */
-  get sessionId() {
-    return this._transport?.sessionId;
+  async cleanup() {
   }
 };
 
@@ -3893,132 +4620,550 @@ var BaseConnector = class {
       } while (cursor);
       return { resources: allResources };
     } catch (err) {
-      if (err.code === -32601) {
-        logger.debug("Server advertised resources but method not found");
-        return { resources: [] };
+      if (err.code === -32601) {
+        logger.debug("Server advertised resources but method not found");
+        return { resources: [] };
+      }
+      throw err;
+    }
+  }
+  /**
+   * List resource templates from the server
+   *
+   * @param options - Request options
+   * @returns List of available resource templates
+   */
+  async listResourceTemplates(options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug("Listing resource templates");
+    return await this.client.listResourceTemplates(void 0, options);
+  }
+  /** Read a resource by URI. */
+  async readResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Reading resource ${uri}`);
+    const res = await this.client.readResource({ uri }, options);
+    return res;
+  }
+  /**
+   * Subscribe to resource updates
+   *
+   * @param uri - URI of the resource to subscribe to
+   * @param options - Request options
+   */
+  async subscribeToResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Subscribing to resource: ${uri}`);
+    return await this.client.subscribeResource({ uri }, options);
+  }
+  /**
+   * Unsubscribe from resource updates
+   *
+   * @param uri - URI of the resource to unsubscribe from
+   * @param options - Request options
+   */
+  async unsubscribeFromResource(uri, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Unsubscribing from resource: ${uri}`);
+    return await this.client.unsubscribeResource({ uri }, options);
+  }
+  async listPrompts() {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    if (!this.capabilitiesCache?.prompts) {
+      logger.debug("Server does not advertise prompts capability, skipping");
+      return { prompts: [] };
+    }
+    try {
+      logger.debug("Listing prompts");
+      return await this.client.listPrompts();
+    } catch (err) {
+      if (err.code === -32601) {
+        logger.debug("Server advertised prompts but method not found");
+        return { prompts: [] };
+      }
+      throw err;
+    }
+  }
+  async getPrompt(name, args) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Getting prompt ${name}`);
+    return await this.client.getPrompt({ name, arguments: args });
+  }
+  /** Send a raw request through the client. */
+  async request(method, params = null, options) {
+    if (!this.client) {
+      throw new Error("MCP client is not connected");
+    }
+    logger.debug(`Sending raw request '${method}' with params`, params);
+    return await this.client.request(
+      { method, params: params ?? {} },
+      void 0,
+      options
+    );
+  }
+  /**
+   * Helper to tear down the client & connection manager safely.
+   */
+  async cleanupResources() {
+    const issues = [];
+    if (this.client) {
+      try {
+        if (typeof this.client.close === "function") {
+          await this.client.close();
+        }
+      } catch (e) {
+        const msg = `Error closing client: ${e}`;
+        logger.warn(msg);
+        issues.push(msg);
+      } finally {
+        this.client = null;
+      }
+    }
+    if (this.connectionManager) {
+      try {
+        await this.connectionManager.stop();
+      } catch (e) {
+        const msg = `Error stopping connection manager: ${e}`;
+        logger.warn(msg);
+        issues.push(msg);
+      } finally {
+        this.connectionManager = null;
+      }
+    }
+    this.toolsCache = null;
+    if (issues.length) {
+      logger.warn(`Resource cleanup finished with ${issues.length} issue(s)`);
+    }
+  }
+};
+
+// src/client/connectors/codeMode.ts
+var CODE_MODE_AGENT_PROMPT = `
+## MCP Code Mode Tool Usage Guide
+
+You have access to an MCP Code Mode Client that allows you to execute JavaScript/TypeScript code with access to registered tools. Follow this workflow:
+
+### 1. Tool Discovery Phase
+**Always start by discovering available tools:**
+- Tools are organized by server namespace (e.g., \`server_name.tool_name\`)
+- Use the \`search_tools(query, detail_level)\` function to find available tools
+- You can access \`__tool_namespaces\` to see all available server namespaces
+
+\`\`\`javascript
+// Find all GitHub-related tools
+const tools = await search_tools("github");
+for (const tool of tools) {
+    console.log(\`\${tool.server}.\${tool.name}: \${tool.description}\`);
+}
+
+// Get only tool names for quick overview
+const tools = await search_tools("", "names");
+\`\`\`
+
+### 2. Interface Introspection
+**Understand tool contracts before using them:**
+- Use \`search_tools\` to get tool descriptions and input schemas
+- Look for "Access as: server.tool(args)" patterns in descriptions
+
+### 3. Code Execution Guidelines
+**When writing code:**
+- Use \`await server.tool({ param: value })\` syntax for all tool calls
+- Tools are async functions that return promises
+- You have access to standard JavaScript globals: \`console\`, \`JSON\`, \`Math\`, \`Date\`, etc.
+- All console output (\`console.log\`, \`console.error\`, etc.) is automatically captured and returned
+- Build properly structured input objects based on interface definitions
+- Handle errors appropriately with try/catch blocks
+- Chain tool calls by using results from previous calls
+
+### 4. Best Practices
+- **Discover first, code second**: Always explore available tools before writing execution code
+- **Respect namespaces**: Use full \`server.tool\` names to avoid conflicts
+- **Minimize Context**: Process large data in code, return only essential results
+- **Error handling**: Wrap tool calls in try/catch for robustness
+- **Data flow**: Chain tools by passing outputs as inputs to subsequent tools
+
+### 5. Available Runtime Context
+- \`search_tools(query, detail_level)\`: Function to discover tools
+- \`__tool_namespaces\`: Array of available server namespaces
+- All registered tools as \`server.tool\` functions
+- Standard JavaScript built-ins for data processing
+
+### Example Workflow
+
+\`\`\`javascript
+// 1. Discover available tools
+const github_tools = await search_tools("github pull request");
+console.log(\`Available GitHub PR tools: \${github_tools.map(t => t.name)}\`);
+
+// 2. Call tools with proper parameters
+const pr = await github.get_pull_request({
+    owner: "facebook",
+    repo: "react",
+    number: 12345
+});
+
+// 3. Process results
+let result;
+if (pr.state === 'open' && pr.labels.some(l => l.name === 'bug')) {
+    // 4. Chain with other tools
+    await slack.post_message({
+        channel: "#bugs",
+        text: \`\u{1F41B} Bug PR needs review: \${pr.title}\`
+    });
+    result = "Notification sent";
+} else {
+    result = "No action needed";
+}
+
+// 5. Return structured results
+return {
+    pr_number: pr.number,
+    pr_title: pr.title,
+    action_taken: result
+};
+\`\`\`
+
+Remember: Always discover and understand available tools before attempting to use them in code execution.
+`;
+var CodeModeConnector = class extends BaseConnector {
+  static {
+    __name(this, "CodeModeConnector");
+  }
+  mcpClient;
+  _tools;
+  constructor(client) {
+    super();
+    this.mcpClient = client;
+    this.connected = true;
+    this._tools = this._createToolsList();
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  get publicIdentifier() {
+    return { name: "code_mode", version: "1.0.0" };
+  }
+  _createToolsList() {
+    return [
+      {
+        name: "execute_code",
+        description: "Execute JavaScript/TypeScript code with access to MCP tools. This is the PRIMARY way to interact with MCP servers in code mode. Write code that discovers tools using search_tools(), calls tools as async functions (e.g., await github.get_pull_request(...)), processes data efficiently, and returns results. Use 'await' for async operations and 'return' to return values. Available in code: search_tools(), __tool_namespaces, and server.tool_name() functions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "JavaScript/TypeScript code to execute. Use 'await' for async operations. Use 'return' to return a value. Available: search_tools(), server.tool_name(), __tool_namespaces"
+            },
+            timeout: {
+              type: "number",
+              description: "Execution timeout in milliseconds",
+              default: 3e4
+            }
+          },
+          required: ["code"]
+        }
+      },
+      {
+        name: "search_tools",
+        description: "Search and discover available MCP tools across all servers. Use this to find out what tools are available before writing code. Returns tool information including names, descriptions, and schemas. Can filter by query and control detail level.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query to filter tools by name or description",
+              default: ""
+            },
+            detail_level: {
+              type: "string",
+              description: "Detail level: 'names', 'descriptions', or 'full'",
+              enum: ["names", "descriptions", "full"],
+              default: "full"
+            }
+          }
+        }
+      }
+    ];
+  }
+  // Override tools getter to return static list immediately
+  get tools() {
+    return this._tools;
+  }
+  async initialize() {
+    this.toolsCache = this._tools;
+    return { capabilities: {}, version: "1.0.0" };
+  }
+  async callTool(name, args) {
+    if (name === "execute_code") {
+      const code = args.code;
+      const timeout = args.timeout || 3e4;
+      const result = await this.mcpClient.executeCode(code, timeout);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    } else if (name === "search_tools") {
+      const query = args.query || "";
+      const detailLevel = args.detail_level;
+      const result = await this.mcpClient.searchTools(
+        query,
+        detailLevel && detailLevel in ["names", "descriptions", "full"] ? detailLevel : "full"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+  }
+};
+
+// src/config.ts
+var import_node_fs = require("fs");
+
+// src/connectors/http.ts
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_streamableHttp2 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+init_logging();
+
+// src/task_managers/sse.ts
+var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+init_logging();
+
+// src/task_managers/base.ts
+init_logging();
+var ConnectionManager = class {
+  static {
+    __name(this, "ConnectionManager");
+  }
+  _readyPromise;
+  _readyResolver;
+  _donePromise;
+  _doneResolver;
+  _exception = null;
+  _connection = null;
+  _task = null;
+  _abortController = null;
+  constructor() {
+    this.reset();
+  }
+  /**
+   * Start the connection manager and establish a connection.
+   *
+   * @returns The established connection.
+   * @throws If the connection cannot be established.
+   */
+  async start() {
+    this.reset();
+    logger.debug(`Starting ${this.constructor.name}`);
+    this._task = this.connectionTask();
+    await this._readyPromise;
+    if (this._exception) {
+      throw this._exception;
+    }
+    if (this._connection === null) {
+      throw new Error("Connection was not established");
+    }
+    return this._connection;
+  }
+  /**
+   * Stop the connection manager and close the connection.
+   */
+  async stop() {
+    if (this._task && this._abortController) {
+      logger.debug(`Cancelling ${this.constructor.name} task`);
+      this._abortController.abort();
+      try {
+        await this._task;
+      } catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
+          logger.debug(`${this.constructor.name} task aborted successfully`);
+        } else {
+          logger.warn(`Error stopping ${this.constructor.name} task: ${e}`);
+        }
+      }
+    }
+    await this._donePromise;
+    logger.debug(`${this.constructor.name} task completed`);
+  }
+  /**
+   * Reset all internal state.
+   */
+  reset() {
+    this._readyPromise = new Promise((res) => this._readyResolver = res);
+    this._donePromise = new Promise((res) => this._doneResolver = res);
+    this._exception = null;
+    this._connection = null;
+    this._task = null;
+    this._abortController = new AbortController();
+  }
+  /**
+   * The background task responsible for establishing and maintaining the
+   * connection until it is cancelled.
+   */
+  async connectionTask() {
+    logger.debug(`Running ${this.constructor.name} task`);
+    try {
+      this._connection = await this.establishConnection();
+      logger.debug(`${this.constructor.name} connected successfully`);
+      this._readyResolver();
+      await this.waitForAbort();
+    } catch (err) {
+      this._exception = err;
+      logger.error(`Error in ${this.constructor.name} task: ${err}`);
+      this._readyResolver();
+    } finally {
+      if (this._connection !== null) {
+        try {
+          await this.closeConnection(this._connection);
+        } catch (closeErr) {
+          logger.warn(
+            `Error closing connection in ${this.constructor.name}: ${closeErr}`
+          );
+        }
+        this._connection = null;
       }
-      throw err;
+      this._doneResolver();
     }
   }
   /**
-   * List resource templates from the server
-   *
-   * @param options - Request options
-   * @returns List of available resource templates
+   * Helper that returns a promise which resolves when the abort signal fires.
    */
-  async listResourceTemplates(options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug("Listing resource templates");
-    return await this.client.listResourceTemplates(void 0, options);
+  async waitForAbort() {
+    return new Promise((_resolve, _reject) => {
+      if (!this._abortController) {
+        return;
+      }
+      const signal = this._abortController.signal;
+      if (signal.aborted) {
+        _resolve();
+        return;
+      }
+      const onAbort = /* @__PURE__ */ __name(() => {
+        signal.removeEventListener("abort", onAbort);
+        _resolve();
+      }, "onAbort");
+      signal.addEventListener("abort", onAbort);
+    });
   }
-  /** Read a resource by URI. */
-  async readResource(uri, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Reading resource ${uri}`);
-    const res = await this.client.readResource({ uri }, options);
-    return res;
+};
+
+// src/task_managers/sse.ts
+var SseConnectionManager = class extends ConnectionManager {
+  static {
+    __name(this, "SseConnectionManager");
   }
+  url;
+  opts;
+  _transport = null;
   /**
-   * Subscribe to resource updates
+   * Create an SSE connection manager.
    *
-   * @param uri - URI of the resource to subscribe to
-   * @param options - Request options
+   * @param url  The SSE endpoint URL.
+   * @param opts Optional transport options (auth, headers, etc.).
    */
-  async subscribeToResource(uri, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Subscribing to resource: ${uri}`);
-    return await this.client.subscribeResource({ uri }, options);
+  constructor(url, opts) {
+    super();
+    this.url = typeof url === "string" ? new URL(url) : url;
+    this.opts = opts;
   }
   /**
-   * Unsubscribe from resource updates
-   *
-   * @param uri - URI of the resource to unsubscribe from
-   * @param options - Request options
+   * Spawn a new `SSEClientTransport` and start the connection.
    */
-  async unsubscribeFromResource(uri, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Unsubscribing from resource: ${uri}`);
-    return await this.client.unsubscribeResource({ uri }, options);
-  }
-  async listPrompts() {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    if (!this.capabilitiesCache?.prompts) {
-      logger.debug("Server does not advertise prompts capability, skipping");
-      return { prompts: [] };
-    }
-    try {
-      logger.debug("Listing prompts");
-      return await this.client.listPrompts();
-    } catch (err) {
-      if (err.code === -32601) {
-        logger.debug("Server advertised prompts but method not found");
-        return { prompts: [] };
-      }
-      throw err;
-    }
-  }
-  async getPrompt(name, args) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Getting prompt ${name}`);
-    return await this.client.getPrompt({ name, arguments: args });
-  }
-  /** Send a raw request through the client. */
-  async request(method, params = null, options) {
-    if (!this.client) {
-      throw new Error("MCP client is not connected");
-    }
-    logger.debug(`Sending raw request '${method}' with params`, params);
-    return await this.client.request(
-      { method, params: params ?? {} },
-      void 0,
-      options
-    );
+  async establishConnection() {
+    this._transport = new import_sse.SSEClientTransport(this.url, this.opts);
+    logger.debug(`${this.constructor.name} connected successfully`);
+    return this._transport;
   }
   /**
-   * Helper to tear down the client & connection manager safely.
+   * Close the underlying transport and clean up resources.
    */
-  async cleanupResources() {
-    const issues = [];
-    if (this.client) {
+  async closeConnection(_connection) {
+    if (this._transport) {
       try {
-        if (typeof this.client.close === "function") {
-          await this.client.close();
-        }
+        await this._transport.close();
       } catch (e) {
-        const msg = `Error closing client: ${e}`;
-        logger.warn(msg);
-        issues.push(msg);
+        logger.warn(`Error closing SSE transport: ${e}`);
       } finally {
-        this.client = null;
+        this._transport = null;
       }
     }
-    if (this.connectionManager) {
+  }
+};
+
+// src/task_managers/streamable_http.ts
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+init_logging();
+var StreamableHttpConnectionManager = class extends ConnectionManager {
+  static {
+    __name(this, "StreamableHttpConnectionManager");
+  }
+  url;
+  opts;
+  _transport = null;
+  /**
+   * Create a Streamable HTTP connection manager.
+   *
+   * @param url  The HTTP endpoint URL.
+   * @param opts Optional transport options (auth, headers, etc.).
+   */
+  constructor(url, opts) {
+    super();
+    this.url = typeof url === "string" ? new URL(url) : url;
+    this.opts = opts;
+  }
+  /**
+   * Spawn a new `StreamableHTTPClientTransport` and return it.
+   * The Client.connect() method will handle starting the transport.
+   */
+  async establishConnection() {
+    this._transport = new import_streamableHttp.StreamableHTTPClientTransport(this.url, this.opts);
+    logger.debug(`${this.constructor.name} created successfully`);
+    return this._transport;
+  }
+  /**
+   * Close the underlying transport and clean up resources.
+   */
+  async closeConnection(_connection) {
+    if (this._transport) {
       try {
-        await this.connectionManager.stop();
+        await this._transport.close();
       } catch (e) {
-        const msg = `Error stopping connection manager: ${e}`;
-        logger.warn(msg);
-        issues.push(msg);
+        logger.warn(`Error closing Streamable HTTP transport: ${e}`);
       } finally {
-        this.connectionManager = null;
+        this._transport = null;
       }
     }
-    this.toolsCache = null;
-    if (issues.length) {
-      logger.warn(`Resource cleanup finished with ${issues.length} issue(s)`);
-    }
+  }
+  /**
+   * Get the session ID from the transport if available.
+   */
+  get sessionId() {
+    return this._transport?.sessionId;
   }
 };
 
@@ -4600,11 +5745,17 @@ function createConnectorFromConfig(serverConfig) {
 __name(createConnectorFromConfig, "createConnectorFromConfig");
 
 // src/client.ts
+init_logging();
 var MCPClient = class _MCPClient extends BaseMCPClient {
   static {
     __name(this, "MCPClient");
   }
-  constructor(config2) {
+  codeMode = false;
+  _codeExecutor = null;
+  _customCodeExecutor = null;
+  _codeExecutorConfig = "vm";
+  _executorOptions;
+  constructor(config2, options) {
     if (config2) {
       if (typeof config2 === "string") {
         super(loadConfigFile(config2));
@@ -4614,12 +5765,30 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
     } 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;
+    if (this.codeMode) {
+      this._setupCodeModeConnector();
+    }
   }
-  static fromDict(cfg) {
-    return new _MCPClient(cfg);
+  static fromDict(cfg, options) {
+    return new _MCPClient(cfg, options);
   }
-  static fromConfigFile(path4) {
-    return new _MCPClient(loadConfigFile(path4));
+  static fromConfigFile(path4, options) {
+    return new _MCPClient(loadConfigFile(path4), options);
   }
   /**
    * Save configuration to a file (Node.js only)
@@ -4638,6 +5807,87 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
   createConnectorFromConfig(serverConfig) {
     return createConnectorFromConfig(serverConfig);
   }
+  _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 config2 = this._codeExecutorConfig;
+      if (config2 instanceof BaseCodeExecutor) {
+        this._codeExecutor = config2;
+      } else if (typeof config2 === "function") {
+        this._customCodeExecutor = config2;
+        throw new Error(
+          "Custom executor function should be handled in executeCode"
+        );
+      } else if (config2 === "e2b") {
+        const opts = this._executorOptions;
+        if (!opts?.apiKey) {
+          logger.warn("E2B executor requires apiKey. Falling back to VM.");
+          this._codeExecutor = new VMCodeExecutor(
+            this,
+            this._executorOptions
+          );
+        } else {
+          this._codeExecutor = new E2BCodeExecutor(this, opts);
+        }
+      } else {
+        this._codeExecutor = new VMCodeExecutor(
+          this,
+          this._executorOptions
+        );
+      }
+    }
+    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();
+  }
 };
 
 // index.ts
@@ -7486,3 +8736,8 @@ function WidgetDebugger({
   ));
 }
 __name(WidgetDebugger, "WidgetDebugger");
+
+// src/client/prompts.ts
+var PROMPTS = {
+  CODE_MODE: CODE_MODE_AGENT_PROMPT
+};