mcp-use 1.11.0-canary.8 → 1.11.0

package/dist/{chunk-5RTMAOZ6.js → chunk-A4QJRN7Z.js}

@@ -1,1050 +1,21 @@
+import {
+  MCPClient
+} from "./chunk-QPIDKGV4.js";
 import {
   LangChainAdapter
 } from "./chunk-MFSO5PUW.js";
 import {
-  CodeModeConnector
-} from "./chunk-JZNXOM7C.js";
-import {
-  BaseMCPClient,
-  ConnectionManager,
-  HttpConnector,
-  MCPSession
-} from "./chunk-TAEHPLGV.js";
-import {
-  BaseConnector
-} from "./chunk-XKTBHYNM.js";
-import {
-  Tel,
   Telemetry,
   extractModelInfo,
   getPackageVersion
-} from "./chunk-JPKFN73V.js";
+} from "./chunk-ZLZOOXMJ.js";
 import {
   logger
 } from "./chunk-FRUZDWXH.js";
 import {
-  __name,
-  __require
+  __name
 } from "./chunk-3GQAWCBQ.js";
 
-// src/client/executors/base.ts
-var BaseCodeExecutor = class {
-  static {
-    __name(this, "BaseCodeExecutor");
-  }
-  client;
-  _connecting = false;
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Ensure all configured MCP servers are connected before execution.
-   * Prevents race conditions with a connection lock.
-   */
-  async ensureServersConnected() {
-    const configuredServers = this.client.getServerNames();
-    const activeSessions = Object.keys(this.client.getAllActiveSessions());
-    const missingServers = configuredServers.filter(
-      (s) => !activeSessions.includes(s)
-    );
-    if (missingServers.length > 0 && !this._connecting) {
-      this._connecting = true;
-      try {
-        logger.debug(
-          `Connecting to configured servers for code execution: ${missingServers.join(", ")}`
-        );
-        await this.client.createAllSessions();
-      } finally {
-        this._connecting = false;
-      }
-    } else if (missingServers.length > 0 && this._connecting) {
-      logger.debug("Waiting for ongoing server connection...");
-      const startWait = Date.now();
-      while (this._connecting && Date.now() - startWait < 5e3) {
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-    }
-  }
-  /**
-   * Get tool namespace information from all active MCP sessions.
-   * Filters out the internal code_mode server.
-   */
-  getToolNamespaces() {
-    const namespaces = [];
-    const activeSessions = this.client.getAllActiveSessions();
-    for (const [serverName, session] of Object.entries(activeSessions)) {
-      if (serverName === "code_mode") continue;
-      try {
-        const connector = session.connector;
-        let tools;
-        try {
-          tools = connector.tools;
-        } catch (e) {
-          logger.warn(`Tools not available for server ${serverName}: ${e}`);
-          continue;
-        }
-        if (!tools || tools.length === 0) continue;
-        namespaces.push({ serverName, tools, session });
-      } catch (e) {
-        logger.warn(`Failed to load tools for server ${serverName}: ${e}`);
-      }
-    }
-    return namespaces;
-  }
-  /**
-   * Create a search function for discovering available MCP tools.
-   * Used by code execution environments to find tools at runtime.
-   */
-  createSearchToolsFunction() {
-    return async (query = "", detailLevel = "full") => {
-      const allTools = [];
-      const allNamespaces = /* @__PURE__ */ new Set();
-      const queryLower = query.toLowerCase();
-      const activeSessions = this.client.getAllActiveSessions();
-      for (const [serverName, session] of Object.entries(activeSessions)) {
-        if (serverName === "code_mode") continue;
-        try {
-          const tools = session.connector.tools;
-          if (tools && tools.length > 0) {
-            allNamespaces.add(serverName);
-          }
-          for (const tool of tools) {
-            if (detailLevel === "names") {
-              allTools.push({ name: tool.name, server: serverName });
-            } else if (detailLevel === "descriptions") {
-              allTools.push({
-                name: tool.name,
-                server: serverName,
-                description: tool.description
-              });
-            } else {
-              allTools.push({
-                name: tool.name,
-                server: serverName,
-                description: tool.description,
-                input_schema: tool.inputSchema
-              });
-            }
-          }
-        } catch (e) {
-          logger.warn(`Failed to search tools in server ${serverName}: ${e}`);
-        }
-      }
-      let filteredTools = allTools;
-      if (query) {
-        filteredTools = allTools.filter((tool) => {
-          const nameMatch = tool.name.toLowerCase().includes(queryLower);
-          const descMatch = tool.description?.toLowerCase().includes(queryLower);
-          const serverMatch = tool.server.toLowerCase().includes(queryLower);
-          return nameMatch || descMatch || serverMatch;
-        });
-      }
-      return {
-        meta: {
-          total_tools: allTools.length,
-          namespaces: Array.from(allNamespaces).sort(),
-          result_count: filteredTools.length
-        },
-        results: filteredTools
-      };
-    };
-  }
-};
-
-// src/client/executors/e2b.ts
-var E2BCodeExecutor = class extends BaseCodeExecutor {
-  static {
-    __name(this, "E2BCodeExecutor");
-  }
-  e2bApiKey;
-  codeExecSandbox = null;
-  SandboxClass = null;
-  timeoutMs;
-  constructor(client, options) {
-    super(client);
-    this.e2bApiKey = options.apiKey;
-    this.timeoutMs = options.timeoutMs ?? 3e5;
-  }
-  /**
-   * Lazy load E2B Sandbox class.
-   * This allows the library to work without E2B installed.
-   */
-  async ensureSandboxClass() {
-    if (this.SandboxClass) return;
-    try {
-      const e2b = await import("@e2b/code-interpreter");
-      this.SandboxClass = e2b.Sandbox;
-    } catch (error) {
-      throw new Error(
-        "@e2b/code-interpreter is not installed. The E2B code executor requires this optional dependency. Install it with: yarn add @e2b/code-interpreter"
-      );
-    }
-  }
-  /**
-   * Get or create a dedicated sandbox for code execution.
-   */
-  async getOrCreateCodeExecSandbox() {
-    if (this.codeExecSandbox) return this.codeExecSandbox;
-    await this.ensureSandboxClass();
-    logger.debug("Starting E2B sandbox for code execution...");
-    this.codeExecSandbox = await this.SandboxClass.create("base", {
-      apiKey: this.e2bApiKey,
-      timeoutMs: this.timeoutMs
-    });
-    return this.codeExecSandbox;
-  }
-  /**
-   * Generate the shim code that exposes tools to the sandbox environment.
-   * Creates a bridge that intercepts tool calls and sends them back to host.
-   */
-  generateShim(tools) {
-    let shim = `
-// MCP Bridge Shim
-global.__callMcpTool = async (server, tool, args) => {
-    const id = Math.random().toString(36).substring(7);
-    console.log(JSON.stringify({
-        type: '__MCP_TOOL_CALL__',
-        id,
-        server,
-        tool,
-        args
-    }));
-    
-    const resultPath = \`/tmp/mcp_result_\${id}.json\`;
-    const fs = require('fs');
-    
-    // Poll for result file
-    let attempts = 0;
-    while (attempts < 300) { // 30 seconds timeout
-        if (fs.existsSync(resultPath)) {
-            const content = fs.readFileSync(resultPath, 'utf8');
-            const result = JSON.parse(content);
-            fs.unlinkSync(resultPath); // Clean up
-            
-            if (result.error) {
-                throw new Error(result.error);
-            }
-            return result.data;
-        }
-        await new Promise(resolve => setTimeout(resolve, 100));
-        attempts++;
-    }
-    throw new Error('Tool execution timed out');
-};
-
-// Global search_tools helper
-global.search_tools = async (query, detailLevel = 'full') => {
-    const allTools = ${JSON.stringify(
-      Object.entries(tools).flatMap(
-        ([server, serverTools]) => serverTools.map((tool) => ({
-          name: tool.name,
-          description: tool.description,
-          server,
-          input_schema: tool.inputSchema
-        }))
-      )
-    )};
-    
-    const filtered = allTools.filter(tool => {
-        if (!query) return true;
-        const q = query.toLowerCase();
-        return tool.name.toLowerCase().includes(q) || 
-               (tool.description && tool.description.toLowerCase().includes(q));
-    });
-    
-    if (detailLevel === 'names') {
-        return filtered.map(t => ({ name: t.name, server: t.server }));
-    } else if (detailLevel === 'descriptions') {
-        return filtered.map(t => ({ name: t.name, server: t.server, description: t.description }));
-    }
-    return filtered;
-};
-`;
-    for (const [serverName, serverTools] of Object.entries(tools)) {
-      if (!serverTools || serverTools.length === 0) continue;
-      const safeServerName = serverName.replace(/[^a-zA-Z0-9_]/g, "_");
-      shim += `
-global['${serverName}'] = {`;
-      for (const tool of serverTools) {
-        shim += `
-    '${tool.name}': async (args) => await global.__callMcpTool('${serverName}', '${tool.name}', args),`;
-      }
-      shim += `
-};
-
-// Also expose as safe name if different
-if ('${safeServerName}' !== '${serverName}') {
-    global['${safeServerName}'] = global['${serverName}'];
-}
-`;
-    }
-    return shim;
-  }
-  /**
-   * Build the tool catalog for the shim.
-   * Returns a map of server names to their available tools.
-   */
-  buildToolCatalog() {
-    const catalog = {};
-    const namespaces = this.getToolNamespaces();
-    for (const { serverName, tools } of namespaces) {
-      catalog[serverName] = tools;
-    }
-    return catalog;
-  }
-  /**
-   * Execute JavaScript/TypeScript code in an E2B sandbox with MCP tool access.
-   * Tool calls are proxied back to the host via the bridge pattern.
-   *
-   * @param code - Code to execute
-   * @param timeout - Execution timeout in milliseconds (default: 30000)
-   */
-  async execute(code, timeout = 3e4) {
-    const startTime = Date.now();
-    let result = null;
-    let error = null;
-    let logs = [];
-    try {
-      await this.ensureServersConnected();
-      const sandbox = await this.getOrCreateCodeExecSandbox();
-      const toolCatalog = this.buildToolCatalog();
-      const shim = this.generateShim(toolCatalog);
-      const wrappedCode = `
-${shim}
-
-(async () => {
-    try {
-        const func = async () => {
-            ${code}
-        };
-        const result = await func();
-        console.log('__MCP_RESULT_START__');
-        console.log(JSON.stringify(result));
-        console.log('__MCP_RESULT_END__');
-    } catch (e) {
-        console.error(e);
-        process.exit(1);
-    }
-})();
-`;
-      const filename = `exec_${Date.now()}.js`;
-      await sandbox.files.write(filename, wrappedCode);
-      const execution = await sandbox.commands.run(`node ${filename}`, {
-        timeoutMs: timeout,
-        onStdout: /* @__PURE__ */ __name(async (data) => {
-          try {
-            const lines = data.split("\n");
-            for (const line of lines) {
-              if (line.trim().startsWith('{"type":"__MCP_TOOL_CALL__"')) {
-                const call = JSON.parse(line);
-                if (call.type === "__MCP_TOOL_CALL__") {
-                  try {
-                    logger.debug(
-                      `[E2B Bridge] Calling tool ${call.server}.${call.tool}`
-                    );
-                    const activeSessions = this.client.getAllActiveSessions();
-                    const session = activeSessions[call.server];
-                    if (!session) {
-                      throw new Error(`Server ${call.server} not found`);
-                    }
-                    const toolResult = await session.connector.callTool(
-                      call.tool,
-                      call.args
-                    );
-                    let extractedResult = toolResult;
-                    if (toolResult.content && toolResult.content.length > 0) {
-                      const item = toolResult.content[0];
-                      if (item.type === "text") {
-                        try {
-                          extractedResult = JSON.parse(item.text);
-                        } catch {
-                          extractedResult = item.text;
-                        }
-                      } else {
-                        extractedResult = item;
-                      }
-                    }
-                    const resultPath = `/tmp/mcp_result_${call.id}.json`;
-                    await sandbox.files.write(
-                      resultPath,
-                      JSON.stringify({ data: extractedResult })
-                    );
-                  } catch (err) {
-                    logger.error(
-                      `[E2B Bridge] Tool execution failed: ${err.message}`
-                    );
-                    const resultPath = `/tmp/mcp_result_${call.id}.json`;
-                    await sandbox.files.write(
-                      resultPath,
-                      JSON.stringify({
-                        error: err.message || String(err)
-                      })
-                    );
-                  }
-                }
-              }
-            }
-          } catch (e) {
-          }
-        }, "onStdout")
-      });
-      logs = [execution.stdout, execution.stderr].filter(Boolean);
-      if (execution.exitCode !== 0) {
-        error = execution.stderr || "Execution failed";
-      } else {
-        const stdout = execution.stdout;
-        const startMarker = "__MCP_RESULT_START__";
-        const endMarker = "__MCP_RESULT_END__";
-        const startIndex = stdout.indexOf(startMarker);
-        const endIndex = stdout.indexOf(endMarker);
-        if (startIndex !== -1 && endIndex !== -1) {
-          const jsonStr = stdout.substring(startIndex + startMarker.length, endIndex).trim();
-          try {
-            result = JSON.parse(jsonStr);
-          } catch (e) {
-            result = jsonStr;
-          }
-          logs = logs.map((log) => {
-            let cleaned = log.replace(
-              new RegExp(startMarker + "[\\s\\S]*?" + endMarker),
-              "[Result captured]"
-            );
-            cleaned = cleaned.split("\n").filter((l) => !l.includes("__MCP_TOOL_CALL__")).join("\n");
-            return cleaned;
-          });
-        }
-      }
-    } catch (e) {
-      error = e.message || String(e);
-      if (error && (error.includes("timeout") || error.includes("timed out"))) {
-        error = "Script execution timed out";
-      }
-    }
-    return {
-      result,
-      logs,
-      error,
-      execution_time: (Date.now() - startTime) / 1e3
-    };
-  }
-  /**
-   * Clean up the E2B sandbox.
-   * Should be called when the executor is no longer needed.
-   */
-  async cleanup() {
-    if (this.codeExecSandbox) {
-      try {
-        await this.codeExecSandbox.kill();
-        this.codeExecSandbox = null;
-        logger.debug("E2B code execution sandbox stopped");
-      } catch (error) {
-        logger.error("Failed to stop E2B code execution sandbox:", error);
-      }
-    }
-  }
-};
-
-// src/client/executors/vm.ts
-var vm = null;
-var vmCheckAttempted = false;
-function getVMModuleName() {
-  return ["node", "vm"].join(":");
-}
-__name(getVMModuleName, "getVMModuleName");
-function tryLoadVM() {
-  if (vmCheckAttempted) {
-    return vm !== null;
-  }
-  vmCheckAttempted = true;
-  try {
-    const nodeRequire = typeof __require !== "undefined" ? __require : null;
-    if (nodeRequire) {
-      vm = nodeRequire(getVMModuleName());
-      return true;
-    }
-  } catch (error) {
-    logger.debug("node:vm module not available via require");
-  }
-  return false;
-}
-__name(tryLoadVM, "tryLoadVM");
-async function tryLoadVMAsync() {
-  if (vm !== null) {
-    return true;
-  }
-  if (!vmCheckAttempted) {
-    if (tryLoadVM()) {
-      return true;
-    }
-  }
-  try {
-    vm = await import(
-      /* @vite-ignore */
-      getVMModuleName()
-    );
-    return true;
-  } catch (error) {
-    logger.debug(
-      "node:vm module not available in this environment (e.g., Deno)"
-    );
-    return false;
-  }
-}
-__name(tryLoadVMAsync, "tryLoadVMAsync");
-function isVMAvailable() {
-  tryLoadVM();
-  return vm !== null;
-}
-__name(isVMAvailable, "isVMAvailable");
-var VMCodeExecutor = class extends BaseCodeExecutor {
-  static {
-    __name(this, "VMCodeExecutor");
-  }
-  defaultTimeout;
-  memoryLimitMb;
-  constructor(client, options) {
-    super(client);
-    this.defaultTimeout = options?.timeoutMs ?? 3e4;
-    this.memoryLimitMb = options?.memoryLimitMb;
-    tryLoadVM();
-  }
-  /**
-   * Ensure VM module is loaded before execution
-   */
-  async ensureVMLoaded() {
-    if (vm !== null) {
-      return;
-    }
-    const loaded = await tryLoadVMAsync();
-    if (!loaded) {
-      throw new Error(
-        "node:vm module is not available in this environment. Please use E2B executor instead or run in a Node.js environment."
-      );
-    }
-  }
-  /**
-   * Execute JavaScript/TypeScript code with access to MCP tools.
-   *
-   * @param code - Code to execute
-   * @param timeout - Execution timeout in milliseconds (default: configured timeout or 30000)
-   */
-  async execute(code, timeout) {
-    const effectiveTimeout = timeout ?? this.defaultTimeout;
-    await this.ensureVMLoaded();
-    await this.ensureServersConnected();
-    const logs = [];
-    const startTime = Date.now();
-    let result = null;
-    let error = null;
-    try {
-      const context = await this._buildContext(logs);
-      const wrappedCode = `
-        (async () => {
-          try {
-            ${code}
-          } catch (e) {
-            throw e;
-          }
-        })()
-      `;
-      const script = new vm.Script(wrappedCode, {
-        filename: "agent_code.js"
-      });
-      const promise = script.runInNewContext(context, {
-        timeout: effectiveTimeout,
-        displayErrors: true
-      });
-      result = await promise;
-    } catch (e) {
-      error = e.message || String(e);
-      if (e.code === "ERR_SCRIPT_EXECUTION_TIMEOUT" || e.message === "Script execution timed out." || typeof error === "string" && (error.includes("timed out") || error.includes("timeout"))) {
-        error = "Script execution timed out";
-      }
-      if (e.stack) {
-        logger.debug(`Code execution error stack: ${e.stack}`);
-      }
-    }
-    const executionTime = (Date.now() - startTime) / 1e3;
-    return {
-      result,
-      logs,
-      error,
-      execution_time: executionTime
-    };
-  }
-  /**
-   * Build the VM execution context with MCP tools and standard globals.
-   *
-   * @param logs - Array to capture console output
-   */
-  async _buildContext(logs) {
-    const logHandler = /* @__PURE__ */ __name((...args) => {
-      logs.push(
-        args.map(
-          (arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)
-        ).join(" ")
-      );
-    }, "logHandler");
-    const sandbox = {
-      console: {
-        log: logHandler,
-        error: /* @__PURE__ */ __name((...args) => {
-          logHandler("[ERROR]", ...args);
-        }, "error"),
-        warn: /* @__PURE__ */ __name((...args) => {
-          logHandler("[WARN]", ...args);
-        }, "warn"),
-        info: logHandler,
-        debug: logHandler
-      },
-      // Standard globals
-      Object,
-      Array,
-      String,
-      Number,
-      Boolean,
-      Date,
-      Math,
-      JSON,
-      RegExp,
-      Map,
-      Set,
-      Promise,
-      parseInt,
-      parseFloat,
-      isNaN,
-      isFinite,
-      encodeURI,
-      decodeURI,
-      encodeURIComponent,
-      decodeURIComponent,
-      setTimeout,
-      clearTimeout,
-      // Helper for tools
-      search_tools: this.createSearchToolsFunction(),
-      __tool_namespaces: []
-    };
-    const toolNamespaces = {};
-    const namespaceInfos = this.getToolNamespaces();
-    for (const { serverName, tools, session } of namespaceInfos) {
-      const serverNamespace = {};
-      for (const tool of tools) {
-        const toolName = tool.name;
-        serverNamespace[toolName] = async (args) => {
-          const result = await session.connector.callTool(toolName, args || {});
-          if (result.content && result.content.length > 0) {
-            const item = result.content[0];
-            if (item.type === "text") {
-              try {
-                return JSON.parse(item.text);
-              } catch {
-                return item.text;
-              }
-            }
-            return item;
-          }
-          return result;
-        };
-      }
-      sandbox[serverName] = serverNamespace;
-      toolNamespaces[serverName] = true;
-    }
-    sandbox.__tool_namespaces = Object.keys(toolNamespaces);
-    return vm.createContext(sandbox);
-  }
-  /**
-   * Clean up resources.
-   * VM executor doesn't need cleanup, but method kept for interface consistency.
-   */
-  async cleanup() {
-  }
-};
-
-// src/connectors/stdio.ts
-import process2 from "process";
-import { Client } from "@mcp-use/modelcontextprotocol-sdk/client/index.js";
-
-// src/task_managers/stdio.ts
-import { StdioClientTransport } from "@mcp-use/modelcontextprotocol-sdk/client/stdio.js";
-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 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 = process2.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(process2.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 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
-import { readFileSync } from "fs";
-function loadConfigFile(filepath) {
-  const raw = 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
-import fs from "fs";
-import path from "path";
-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 = path.dirname(filepath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(filepath, JSON.stringify(this.config, null, 2), "utf-8");
-  }
-  /**
-   * Create a connector from server configuration (Node.js version)
-   * Supports all connector types including StdioConnector
-   */
-  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/managers/tools/acquire_active_mcp_server.ts
 import { z } from "zod";
 
@@ -3651,13 +2622,6 @@ ${formatPrompt}`
 };
 
 export {
-  BaseCodeExecutor,
-  E2BCodeExecutor,
-  isVMAvailable,
-  VMCodeExecutor,
-  StdioConnector,
-  loadConfigFile,
-  MCPClient,
   AcquireActiveMCPServerTool,
   AddMCPServerFromConfigTool,
   ConnectMCPServerTool,