mcp-use 1.3.4-canary.1 → 1.4.0-canary.3

package/dist/src/client/executors/e2b.d.ts

@@ -0,0 +1,46 @@
+import type { E2BExecutorOptions, MCPClient } from "../../client.js";
+import { BaseCodeExecutor, type ExecutionResult } from "./base.js";
+/**
+ * E2B-based code executor using remote sandboxes.
+ * Executes code in an E2B sandbox with tool calls proxied back to the host.
+ */
+export declare class E2BCodeExecutor extends BaseCodeExecutor {
+    private e2bApiKey;
+    private codeExecSandbox;
+    private SandboxClass;
+    private timeoutMs;
+    constructor(client: MCPClient, options: E2BExecutorOptions);
+    /**
+     * Lazy load E2B Sandbox class.
+     * This allows the library to work without E2B installed.
+     */
+    private ensureSandboxClass;
+    /**
+     * Get or create a dedicated sandbox for code execution.
+     */
+    private getOrCreateCodeExecSandbox;
+    /**
+     * Generate the shim code that exposes tools to the sandbox environment.
+     * Creates a bridge that intercepts tool calls and sends them back to host.
+     */
+    private generateShim;
+    /**
+     * Build the tool catalog for the shim.
+     * Returns a map of server names to their available tools.
+     */
+    private buildToolCatalog;
+    /**
+     * 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)
+     */
+    execute(code: string, timeout?: number): Promise<ExecutionResult>;
+    /**
+     * Clean up the E2B sandbox.
+     * Should be called when the executor is no longer needed.
+     */
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=e2b.d.ts.map

package/dist/src/client/executors/e2b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2b.d.ts","sourceRoot":"","sources":["../../../../src/client/executors/e2b.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAErE,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AAKnE;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACnD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB;IAM1D;;;OAGG;YACW,kBAAkB;IAgBhC;;OAEG;YACW,0BAA0B;IAcxC;;;OAGG;IACH,OAAO,CAAC,YAAY;IA6FpB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;;;OAMG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,SAAQ,GAAG,OAAO,CAAC,eAAe,CAAC;IAwKtE;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAW/B"}

package/dist/src/client/executors/vm.d.ts

@@ -0,0 +1,30 @@
+import type { MCPClient, VMExecutorOptions } from "../../client.js";
+import { BaseCodeExecutor, type ExecutionResult } from "./base.js";
+/**
+ * VM-based code executor using Node.js vm module.
+ * Executes code in an isolated V8 context with access to MCP tools.
+ */
+export declare class VMCodeExecutor extends BaseCodeExecutor {
+    private defaultTimeout;
+    private memoryLimitMb?;
+    constructor(client: MCPClient, options?: VMExecutorOptions);
+    /**
+     * 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)
+     */
+    execute(code: string, timeout?: number): Promise<ExecutionResult>;
+    /**
+     * Build the VM execution context with MCP tools and standard globals.
+     *
+     * @param logs - Array to capture console output
+     */
+    private _buildContext;
+    /**
+     * Clean up resources.
+     * VM executor doesn't need cleanup, but method kept for interface consistency.
+     */
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=vm.d.ts.map

package/dist/src/client/executors/vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vm.d.ts","sourceRoot":"","sources":["../../../../src/client/executors/vm.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AAEnE;;;GAGG;AACH,qBAAa,cAAe,SAAQ,gBAAgB;IAClD,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAC,CAAS;gBAEnB,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,iBAAiB;IAM1D;;;;;OAKG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAkEvE;;;;OAIG;YACW,aAAa;IA6F3B;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/src/client/prompts.cjs

@@ -0,0 +1,401 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/prompts.ts
+var prompts_exports = {};
+__export(prompts_exports, {
+  PROMPTS: () => PROMPTS
+});
+module.exports = __toCommonJS(prompts_exports);
+
+// src/logging.ts
+async function getNodeModules() {
+  if (typeof process !== "undefined" && process.platform) {
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      return { fs: fs.default, path: path.default };
+    } catch {
+      return { fs: null, path: null };
+    }
+  }
+  return { fs: null, path: null };
+}
+__name(getNodeModules, "getNodeModules");
+var winston = null;
+function loadWinstonSync() {
+  if (typeof require !== "undefined") {
+    try {
+      winston = require("winston");
+    } catch {
+    }
+  }
+}
+__name(loadWinstonSync, "loadWinstonSync");
+async function getWinston() {
+  if (!winston) {
+    winston = await import("winston");
+  }
+  return winston;
+}
+__name(getWinston, "getWinston");
+var DEFAULT_LOGGER_NAME = "mcp-use";
+function isNodeJSEnvironment() {
+  try {
+    if (typeof navigator !== "undefined" && navigator.userAgent?.includes("Cloudflare-Workers")) {
+      return false;
+    }
+    if (typeof globalThis.EdgeRuntime !== "undefined" || typeof globalThis.Deno !== "undefined") {
+      return false;
+    }
+    const hasNodeGlobals = typeof process !== "undefined" && typeof process.platform !== "undefined" && typeof __dirname !== "undefined";
+    return hasNodeGlobals;
+  } catch {
+    return false;
+  }
+}
+__name(isNodeJSEnvironment, "isNodeJSEnvironment");
+var SimpleConsoleLogger = class {
+  static {
+    __name(this, "SimpleConsoleLogger");
+  }
+  _level;
+  name;
+  constructor(name = DEFAULT_LOGGER_NAME, level = "info") {
+    this.name = name;
+    this._level = level;
+  }
+  shouldLog(level) {
+    const levels = [
+      "error",
+      "warn",
+      "info",
+      "http",
+      "verbose",
+      "debug",
+      "silly"
+    ];
+    const currentIndex = levels.indexOf(this._level);
+    const messageIndex = levels.indexOf(level);
+    return messageIndex <= currentIndex;
+  }
+  formatMessage(level, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    return `${timestamp} [${this.name}] ${level}: ${message}`;
+  }
+  error(message) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message));
+    }
+  }
+  warn(message) {
+    if (this.shouldLog("warn")) {
+      console.warn(this.formatMessage("warn", message));
+    }
+  }
+  info(message) {
+    if (this.shouldLog("info")) {
+      console.info(this.formatMessage("info", message));
+    }
+  }
+  debug(message) {
+    if (this.shouldLog("debug")) {
+      console.debug(this.formatMessage("debug", message));
+    }
+  }
+  http(message) {
+    if (this.shouldLog("http")) {
+      console.log(this.formatMessage("http", message));
+    }
+  }
+  verbose(message) {
+    if (this.shouldLog("verbose")) {
+      console.log(this.formatMessage("verbose", message));
+    }
+  }
+  silly(message) {
+    if (this.shouldLog("silly")) {
+      console.log(this.formatMessage("silly", message));
+    }
+  }
+  // Make it compatible with Winston interface
+  get level() {
+    return this._level;
+  }
+  set level(newLevel) {
+    this._level = newLevel;
+  }
+};
+function resolveLevel(env) {
+  const envValue = typeof process !== "undefined" && process.env ? env : void 0;
+  switch (envValue?.trim()) {
+    case "2":
+      return "debug";
+    case "1":
+      return "info";
+    default:
+      return "info";
+  }
+}
+__name(resolveLevel, "resolveLevel");
+var Logger = class {
+  static {
+    __name(this, "Logger");
+  }
+  static instances = {};
+  static simpleInstances = {};
+  static currentFormat = "minimal";
+  static get(name = DEFAULT_LOGGER_NAME) {
+    if (!isNodeJSEnvironment()) {
+      if (!this.simpleInstances[name]) {
+        const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+        this.simpleInstances[name] = new SimpleConsoleLogger(
+          name,
+          resolveLevel(debugEnv)
+        );
+      }
+      return this.simpleInstances[name];
+    }
+    if (!this.instances[name]) {
+      if (!winston) {
+        throw new Error("Winston not loaded - call Logger.configure() first");
+      }
+      const { createLogger, format } = winston;
+      const { combine, timestamp, label, colorize, splat } = format;
+      this.instances[name] = createLogger({
+        level: resolveLevel(process.env.DEBUG),
+        format: combine(
+          colorize(),
+          splat(),
+          label({ label: name }),
+          timestamp({ format: "HH:mm:ss" }),
+          this.getFormatter()
+        ),
+        transports: []
+      });
+    }
+    return this.instances[name];
+  }
+  static getFormatter() {
+    if (!winston) {
+      throw new Error("Winston not loaded");
+    }
+    const { format } = winston;
+    const { printf } = format;
+    const minimalFormatter = printf(({ level, message, label, timestamp }) => {
+      return `${timestamp} [${label}] ${level}: ${message}`;
+    });
+    const detailedFormatter = printf(({ level, message, label, timestamp }) => {
+      return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
+    });
+    const emojiFormatter = printf(({ level, message, label, timestamp }) => {
+      return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
+    });
+    switch (this.currentFormat) {
+      case "minimal":
+        return minimalFormatter;
+      case "detailed":
+        return detailedFormatter;
+      case "emoji":
+        return emojiFormatter;
+      default:
+        return minimalFormatter;
+    }
+  }
+  static async configure(options = {}) {
+    const { level, console: console2 = true, file, format = "minimal" } = options;
+    const debugEnv = typeof process !== "undefined" && process.env?.DEBUG || void 0;
+    const resolvedLevel = level ?? resolveLevel(debugEnv);
+    this.currentFormat = format;
+    if (!isNodeJSEnvironment()) {
+      Object.values(this.simpleInstances).forEach((logger2) => {
+        logger2.level = resolvedLevel;
+      });
+      return;
+    }
+    await getWinston();
+    if (!winston) {
+      throw new Error("Failed to load winston");
+    }
+    const root = this.get();
+    root.level = resolvedLevel;
+    const winstonRoot = root;
+    winstonRoot.clear();
+    if (console2) {
+      winstonRoot.add(new winston.transports.Console());
+    }
+    if (file) {
+      const { fs: nodeFs, path: nodePath } = await getNodeModules();
+      if (nodeFs && nodePath) {
+        const dir = nodePath.dirname(nodePath.resolve(file));
+        if (!nodeFs.existsSync(dir)) {
+          nodeFs.mkdirSync(dir, { recursive: true });
+        }
+        winstonRoot.add(new winston.transports.File({ filename: file }));
+      }
+    }
+    const { format: winstonFormat } = winston;
+    const { combine, timestamp, label, colorize, splat } = winstonFormat;
+    Object.values(this.instances).forEach((logger2) => {
+      if (logger2 && "format" in logger2) {
+        logger2.level = resolvedLevel;
+        logger2.format = combine(
+          colorize(),
+          splat(),
+          label({ label: DEFAULT_LOGGER_NAME }),
+          timestamp({ format: "HH:mm:ss" }),
+          this.getFormatter()
+        );
+      }
+    });
+  }
+  static setDebug(enabled) {
+    let level;
+    if (enabled === 2 || enabled === true) level = "debug";
+    else if (enabled === 1) level = "info";
+    else level = "info";
+    Object.values(this.simpleInstances).forEach((logger2) => {
+      logger2.level = level;
+    });
+    Object.values(this.instances).forEach((logger2) => {
+      if (logger2) {
+        logger2.level = level;
+      }
+    });
+    if (typeof process !== "undefined" && process.env) {
+      process.env.DEBUG = enabled ? enabled === true ? "2" : String(enabled) : "0";
+    }
+  }
+  static setFormat(format) {
+    this.currentFormat = format;
+    this.configure({ format });
+  }
+};
+if (isNodeJSEnvironment()) {
+  loadWinstonSync();
+  if (winston) {
+    Logger.configure();
+  }
+}
+var logger = Logger.get();
+
+// 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.
+`;
+
+// src/client/prompts.ts
+var PROMPTS = {
+  CODE_MODE: CODE_MODE_AGENT_PROMPT
+};

package/dist/src/client/prompts.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Prompt templates for MCP code execution mode.
+ *
+ * This module provides prompt templates to guide agents on how to use
+ * MCP tools via code execution.
+ */
+/**
+ * Collection of prompt templates for MCP agents.
+ */
+export declare const PROMPTS: {
+    readonly CODE_MODE: "\n## MCP Code Mode Tool Usage Guide\n\nYou have access to an MCP Code Mode Client that allows you to execute JavaScript/TypeScript code with access to registered tools. Follow this workflow:\n\n### 1. Tool Discovery Phase\n**Always start by discovering available tools:**\n- Tools are organized by server namespace (e.g., `server_name.tool_name`)\n- Use the `search_tools(query, detail_level)` function to find available tools\n- You can access `__tool_namespaces` to see all available server namespaces\n\n```javascript\n// Find all GitHub-related tools\nconst tools = await search_tools(\"github\");\nfor (const tool of tools) {\n    console.log(`${tool.server}.${tool.name}: ${tool.description}`);\n}\n\n// Get only tool names for quick overview\nconst tools = await search_tools(\"\", \"names\");\n```\n\n### 2. Interface Introspection\n**Understand tool contracts before using them:**\n- Use `search_tools` to get tool descriptions and input schemas\n- Look for \"Access as: server.tool(args)\" patterns in descriptions\n\n### 3. Code Execution Guidelines\n**When writing code:**\n- Use `await server.tool({ param: value })` syntax for all tool calls\n- Tools are async functions that return promises\n- You have access to standard JavaScript globals: `console`, `JSON`, `Math`, `Date`, etc.\n- All console output (`console.log`, `console.error`, etc.) is automatically captured and returned\n- Build properly structured input objects based on interface definitions\n- Handle errors appropriately with try/catch blocks\n- Chain tool calls by using results from previous calls\n\n### 4. Best Practices\n- **Discover first, code second**: Always explore available tools before writing execution code\n- **Respect namespaces**: Use full `server.tool` names to avoid conflicts\n- **Minimize Context**: Process large data in code, return only essential results\n- **Error handling**: Wrap tool calls in try/catch for robustness\n- **Data flow**: Chain tools by passing outputs as inputs to subsequent tools\n\n### 5. Available Runtime Context\n- `search_tools(query, detail_level)`: Function to discover tools\n- `__tool_namespaces`: Array of available server namespaces\n- All registered tools as `server.tool` functions\n- Standard JavaScript built-ins for data processing\n\n### Example Workflow\n\n```javascript\n// 1. Discover available tools\nconst github_tools = await search_tools(\"github pull request\");\nconsole.log(`Available GitHub PR tools: ${github_tools.map(t => t.name)}`);\n\n// 2. Call tools with proper parameters\nconst pr = await github.get_pull_request({\n    owner: \"facebook\",\n    repo: \"react\",\n    number: 12345\n});\n\n// 3. Process results\nlet result;\nif (pr.state === 'open' && pr.labels.some(l => l.name === 'bug')) {\n    // 4. Chain with other tools\n    await slack.post_message({\n        channel: \"#bugs\",\n        text: `🐛 Bug PR needs review: ${pr.title}`\n    });\n    result = \"Notification sent\";\n} else {\n    result = \"No action needed\";\n}\n\n// 5. Return structured results\nreturn {\n    pr_number: pr.number,\n    pr_title: pr.title,\n    action_taken: result\n};\n```\n\nRemember: Always discover and understand available tools before attempting to use them in code execution.\n";
+};
+//# sourceMappingURL=prompts.d.ts.map

package/dist/src/client/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/client/prompts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,eAAO,MAAM,OAAO;;CAEV,CAAC"}

package/dist/src/client/prompts.js

@@ -0,0 +1,9 @@
+import {
+  PROMPTS
+} from "../../chunk-WERYJ6PF.js";
+import "../../chunk-DSBKVAWD.js";
+import "../../chunk-34R6SIER.js";
+import "../../chunk-3GQAWCBQ.js";
+export {
+  PROMPTS
+};

package/dist/src/client.d.ts

@@ -1,5 +1,27 @@
-import type { BaseConnector } from "./connectors/base.js";
 import { BaseMCPClient } from "./client/base.js";
+import type { ExecutionResult } from "./client/codeExecutor.js";
+import { BaseCodeExecutor, E2BCodeExecutor, VMCodeExecutor } from "./client/codeExecutor.js";
+import type { BaseConnector } from "./connectors/base.js";
+export type CodeExecutorFunction = (code: string, timeout?: number) => Promise<ExecutionResult>;
+export type CodeExecutorType = "vm" | "e2b";
+export interface VMExecutorOptions {
+    timeoutMs?: number;
+    memoryLimitMb?: number;
+}
+export interface E2BExecutorOptions {
+    apiKey: string;
+    timeoutMs?: number;
+}
+export type ExecutorOptions = VMExecutorOptions | E2BExecutorOptions;
+export interface CodeModeConfig {
+    enabled: boolean;
+    executor?: CodeExecutorType | CodeExecutorFunction | BaseCodeExecutor;
+    executorOptions?: ExecutorOptions;
+}
+export interface MCPClientOptions {
+    codeMode?: boolean | CodeModeConfig;
+}
+export { BaseCodeExecutor, E2BCodeExecutor, VMCodeExecutor };
 /**
  * Node.js-specific MCPClient implementation
  *
@@ -7,11 +29,17 @@ import { BaseMCPClient } from "./client/base.js";
  * - File system operations (saveConfig)
  * - Config file loading (fromConfigFile)
  * - All connector types including StdioConnector
+ * - Code execution mode
  */
 export declare class MCPClient extends BaseMCPClient {
-    constructor(config?: string | Record<string, any>);
-    static fromDict(cfg: Record<string, any>): MCPClient;
-    static fromConfigFile(path: string): MCPClient;
+    codeMode: boolean;
+    private _codeExecutor;
+    private _customCodeExecutor;
+    private _codeExecutorConfig;
+    private _executorOptions?;
+    constructor(config?: string | Record<string, any>, options?: MCPClientOptions);
+    static fromDict(cfg: Record<string, any>, options?: MCPClientOptions): MCPClient;
+    static fromConfigFile(path: string, options?: MCPClientOptions): MCPClient;
     /**
      * Save configuration to a file (Node.js only)
      */
@@ -21,5 +49,24 @@ export declare class MCPClient extends BaseMCPClient {
      * Supports all connector types including StdioConnector
      */
     protected createConnectorFromConfig(serverConfig: Record<string, any>): BaseConnector;
+    private _setupCodeModeConnector;
+    private _ensureCodeExecutor;
+    /**
+     * Execute code in code mode
+     */
+    executeCode(code: string, timeout?: number): Promise<ExecutionResult>;
+    /**
+     * Search available tools (used by code mode)
+     */
+    searchTools(query?: string, detailLevel?: "names" | "descriptions" | "full"): Promise<import("./client/codeExecutor.js").ToolSearchResult[]>;
+    /**
+     * Override getServerNames to exclude internal code_mode server
+     */
+    getServerNames(): string[];
+    /**
+     * Close the client and clean up resources including code executors.
+     * This ensures E2B sandboxes and other resources are properly released.
+     */
+    close(): Promise<void>;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/src/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,aAAa;gBAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;WAYnC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS;WAI7C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAIrD;;OAEG;IACI,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQzC;;;OAGG;IACH,SAAS,CAAC,yBAAyB,CACjC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,aAAa;CAGjB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,cAAc,EACf,MAAM,0BAA0B,CAAC;AAGlC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,MAAM,MAAM,oBAAoB,GAAG,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,KACb,OAAO,CAAC,eAAe,CAAC,CAAC;AAC9B,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,KAAK,CAAC;AAG5C,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG,kBAAkB,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,gBAAgB,GAAG,oBAAoB,GAAG,gBAAgB,CAAC;IACtE,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,OAAO,GAAG,cAAc,CAAC;CACrC;AAGD,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC;AAE7D;;;;;;;;GAQG;AACH,qBAAa,SAAU,SAAQ,aAAa;IACnC,QAAQ,EAAE,OAAO,CAAS;IACjC,OAAO,CAAC,aAAa,CAAiC;IACtD,OAAO,CAAC,mBAAmB,CAAqC;IAChE,OAAO,CAAC,mBAAmB,CAGC;IAC5B,OAAO,CAAC,gBAAgB,CAAC,CAAkB;gBAGzC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,OAAO,CAAC,EAAE,gBAAgB;WAuCd,QAAQ,CACpB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACxB,OAAO,CAAC,EAAE,gBAAgB,GACzB,SAAS;WAIE,cAAc,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,gBAAgB,GACzB,SAAS;IAIZ;;OAEG;IACI,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQzC;;;OAGG;IACH,SAAS,CAAC,yBAAyB,CACjC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,aAAa;IAIhB,OAAO,CAAC,uBAAuB;IAU/B,OAAO,CAAC,mBAAmB;IAmC3B;;OAEG;IACU,WAAW,CACtB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,eAAe,CAAC;IAc3B;;OAEG;IACU,WAAW,CACtB,KAAK,GAAE,MAAW,EAClB,WAAW,GAAE,OAAO,GAAG,cAAc,GAAG,MAAe,GACtD,OAAO,CAAC,OAAO,0BAA0B,EAAE,gBAAgB,EAAE,CAAC;IAUjE;;OAEG;IACI,cAAc,IAAI,MAAM,EAAE;IAOjC;;;OAGG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAUpC"}

package/dist/src/react/index.js

@@ -6,10 +6,11 @@ import {
   useWidgetProps,
   useWidgetState,
   useWidgetTheme
-} from "../../chunk-QKPVHYJU.js";
+} from "../../chunk-RE7EYFDV.js";
 import {
   onMcpAuthorization
-} from "../../chunk-TIUSJAAE.js";
+} from "../../chunk-GRLCLVAK.js";
+import "../../chunk-DSBKVAWD.js";
 import "../../chunk-34R6SIER.js";
 import "../../chunk-3GQAWCBQ.js";
 export {

package/dist/tsup.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsup.config.d.ts","sourceRoot":"","sources":["../tsup.config.ts"],"names":[],"mappings":";AAEA,wBAkCG"}
+{"version":3,"file":"tsup.config.d.ts","sourceRoot":"","sources":["../tsup.config.ts"],"names":[],"mappings":";AAEA,wBAsCG"}