mcp-use 1.10.6 → 1.11.0-canary.4

package/dist/{chunk-FDKY2O5P.js → chunk-BE23AOUV.js}

@@ -1,13 +1,27 @@
 import {
+  CodeModeConnector
+} from "./chunk-APOF62EA.js";
+import {
+  BaseMCPClient,
+  ConnectionManager,
+  HttpConnector,
+  MCPSession
+} from "./chunk-OIXS25J5.js";
+import {
+  BaseConnector
+} from "./chunk-XXCHNDUF.js";
+import {
+  Tel,
   Telemetry,
   extractModelInfo,
   getPackageVersion
-} from "./chunk-JH3ZOGLI.js";
+} from "./chunk-K6YNB2Z3.js";
 import {
   logger
-} from "./chunk-34R6SIER.js";
+} from "./chunk-FRUZDWXH.js";
 import {
-  __name
+  __name,
+  __require
 } from "./chunk-3GQAWCBQ.js";
 
 // src/adapters/base.ts
@@ -93,6 +107,98 @@ var BaseAdapter = class {
     logger.debug(`Available tools: ${tools.length}`);
     return tools;
   }
+  /**
+   * Dynamically load resources for a specific connector.
+   *
+   * @param connector The connector to load resources for.
+   * @returns         The list of resources that were loaded in the target framework's format.
+   */
+  async loadResourcesForConnector(connector) {
+    const connectorResources = [];
+    const success = await this.ensureConnectorInitialized(connector);
+    if (!success) {
+      return [];
+    }
+    try {
+      const resourcesResult = await connector.listAllResources();
+      const resources = resourcesResult?.resources || [];
+      if (this.convertResource) {
+        for (const resource of resources) {
+          const converted = this.convertResource(resource, connector);
+          if (converted) {
+            connectorResources.push(converted);
+          }
+        }
+      }
+      logger.debug(
+        `Loaded ${connectorResources.length} new resources for connector: ${connectorResources.map((r) => r?.name ?? String(r)).join(", ")}`
+      );
+    } catch (err) {
+      logger.warn(`Error loading resources for connector: ${err}`);
+    }
+    return connectorResources;
+  }
+  /**
+   * Dynamically load prompts for a specific connector.
+   *
+   * @param connector The connector to load prompts for.
+   * @returns         The list of prompts that were loaded in the target framework's format.
+   */
+  async loadPromptsForConnector(connector) {
+    const connectorPrompts = [];
+    const success = await this.ensureConnectorInitialized(connector);
+    if (!success) {
+      return [];
+    }
+    try {
+      const promptsResult = await connector.listPrompts();
+      const prompts = promptsResult?.prompts || [];
+      if (this.convertPrompt) {
+        for (const prompt of prompts) {
+          const converted = this.convertPrompt(prompt, connector);
+          if (converted) {
+            connectorPrompts.push(converted);
+          }
+        }
+      }
+      logger.debug(
+        `Loaded ${connectorPrompts.length} new prompts for connector: ${connectorPrompts.map((p) => p?.name ?? String(p)).join(", ")}`
+      );
+    } catch (err) {
+      logger.warn(`Error loading prompts for connector: ${err}`);
+    }
+    return connectorPrompts;
+  }
+  /**
+   * Create resources from MCP resources in all provided connectors.
+   *
+   * @param connectors List of MCP connectors to create resources from.
+   * @returns         A promise that resolves with all converted resources.
+   */
+  async createResourcesFromConnectors(connectors) {
+    const resources = [];
+    for (const connector of connectors) {
+      const connectorResources = await this.loadResourcesForConnector(connector);
+      resources.push(...connectorResources);
+    }
+    logger.debug(`Available resources: ${resources.length}`);
+    return resources;
+  }
+  /**
+   * Create prompts from MCP prompts in all provided connectors.
+   *
+   * @param connectors List of MCP connectors to create prompts from.
+   * @returns         A promise that resolves with all converted prompts.
+   */
+  async createPromptsFromConnectors(connectors) {
+    const prompts = [];
+    for (const connector of connectors) {
+      const connectorPrompts = await this.loadPromptsForConnector(connector);
+      prompts.push(...connectorPrompts);
+    }
+    logger.debug(`Available prompts: ${prompts.length}`);
+    return prompts;
+  }
   /**
    * Check if a connector is initialized and has tools.
    *
@@ -799,67 +905,1178 @@ var JSONSchemaToZod = class {
         ...baseSchema.properties,
         ...addSchema.properties
       };
-      merged.properties = mergedProperties;
-    }
-    if (baseSchema.required && addSchema.required) {
-      const mergedRequired = [
-        .../* @__PURE__ */ new Set([...baseSchema.required, ...addSchema.required])
-      ];
-      merged.required = mergedRequired;
+      merged.properties = mergedProperties;
+    }
+    if (baseSchema.required && addSchema.required) {
+      const mergedRequired = [
+        .../* @__PURE__ */ new Set([...baseSchema.required, ...addSchema.required])
+      ];
+      merged.required = mergedRequired;
+    }
+    return merged;
+  }
+};
+
+// src/adapters/langchain_adapter.ts
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z as z2 } from "zod";
+function schemaToZod(schema) {
+  try {
+    return JSONSchemaToZod.convert(schema);
+  } catch (err) {
+    logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
+    return z2.any();
+  }
+}
+__name(schemaToZod, "schemaToZod");
+var LangChainAdapter = class extends BaseAdapter {
+  static {
+    __name(this, "LangChainAdapter");
+  }
+  constructor(disallowedTools = []) {
+    super(disallowedTools);
+  }
+  /**
+   * Convert a single MCP tool specification into a LangChainJS structured tool.
+   */
+  convertTool(mcpTool, connector) {
+    if (this.disallowedTools.includes(mcpTool.name)) {
+      return null;
+    }
+    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : z2.object({}).optional();
+    const tool = new DynamicStructuredTool({
+      name: mcpTool.name ?? "NO NAME",
+      description: mcpTool.description ?? "",
+      // Blank is acceptable but discouraged.
+      schema: argsSchema,
+      func: /* @__PURE__ */ __name(async (input) => {
+        logger.debug(
+          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
+        );
+        try {
+          const result = await connector.callTool(
+            mcpTool.name,
+            input
+          );
+          return JSON.stringify(result);
+        } catch (err) {
+          logger.error(`Error executing MCP tool: ${err.message}`);
+          return `Error executing MCP tool: ${String(err)}`;
+        }
+      }, "func")
+    });
+    return tool;
+  }
+  /**
+   * Convert a single MCP resource into a LangChainJS structured tool.
+   * Each resource becomes an async tool that returns its content when called.
+   */
+  convertResource(mcpResource, connector) {
+    const sanitizeName = /* @__PURE__ */ __name((name) => {
+      return name.replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
+    }, "sanitizeName");
+    const resourceName = sanitizeName(
+      mcpResource.name || `resource_${mcpResource.uri}`
+    );
+    const resourceUri = mcpResource.uri;
+    const tool = new DynamicStructuredTool({
+      name: resourceName,
+      description: mcpResource.description || `Return the content of the resource located at URI ${resourceUri}.`,
+      schema: z2.object({}).optional(),
+      // Resources take no arguments
+      func: /* @__PURE__ */ __name(async () => {
+        logger.debug(`Resource tool: "${resourceName}" called`);
+        try {
+          const result = await connector.readResource(resourceUri);
+          if (result.contents && result.contents.length > 0) {
+            return result.contents.map((content) => {
+              if (typeof content === "string") {
+                return content;
+              }
+              if (content.text) {
+                return content.text;
+              }
+              if (content.uri) {
+                return content.uri;
+              }
+              return JSON.stringify(content);
+            }).join("\n");
+          }
+          return "Resource is empty or unavailable";
+        } catch (err) {
+          logger.error(`Error reading resource: ${err.message}`);
+          return `Error reading resource: ${String(err)}`;
+        }
+      }, "func")
+    });
+    return tool;
+  }
+  /**
+   * Convert a single MCP prompt into a LangChainJS structured tool.
+   * The resulting tool executes getPrompt on the connector with the prompt's name
+   * and the user-provided arguments (if any).
+   */
+  convertPrompt(mcpPrompt, connector) {
+    let argsSchema = z2.object({}).optional();
+    if (mcpPrompt.arguments && mcpPrompt.arguments.length > 0) {
+      const schemaFields = {};
+      for (const arg of mcpPrompt.arguments) {
+        const zodType = z2.string();
+        if (arg.required !== false) {
+          schemaFields[arg.name] = zodType;
+        } else {
+          schemaFields[arg.name] = zodType.optional();
+        }
+      }
+      argsSchema = Object.keys(schemaFields).length > 0 ? z2.object(schemaFields) : z2.object({}).optional();
+    }
+    const tool = new DynamicStructuredTool({
+      name: mcpPrompt.name,
+      description: mcpPrompt.description || "",
+      schema: argsSchema,
+      func: /* @__PURE__ */ __name(async (input) => {
+        logger.debug(
+          `Prompt tool: "${mcpPrompt.name}" called with args: ${JSON.stringify(input)}`
+        );
+        try {
+          const result = await connector.getPrompt(mcpPrompt.name, input);
+          if (result.messages && result.messages.length > 0) {
+            return result.messages.map((msg) => {
+              if (typeof msg === "string") {
+                return msg;
+              }
+              if (msg.content) {
+                return typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+              }
+              return JSON.stringify(msg);
+            }).join("\n");
+          }
+          return "Prompt returned no messages";
+        } catch (err) {
+          logger.error(`Error getting prompt: ${err.message}`);
+          return `Error getting prompt: ${String(err)}`;
+        }
+      }, "func")
+    });
+    return tool;
+  }
+};
+
+// src/client/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;
     }
-    return merged;
+  }
+  get publicIdentifier() {
+    return {
+      type: "stdio",
+      "command&args": `${this.command} ${this.args.join(" ")}`
+    };
   }
 };
 
-// src/adapters/langchain_adapter.ts
-import { DynamicStructuredTool } from "@langchain/core/tools";
-import { z as z2 } from "zod";
-function schemaToZod(schema) {
-  try {
-    return JSONSchemaToZod.convert(schema);
-  } catch (err) {
-    logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
-    return z2.any();
+// 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(schemaToZod, "schemaToZod");
-var LangChainAdapter = class extends BaseAdapter {
+__name(createConnectorFromConfig, "createConnectorFromConfig");
+
+// src/client.ts
+import fs from "fs";
+import path from "path";
+var MCPClient = class _MCPClient extends BaseMCPClient {
   static {
-    __name(this, "LangChainAdapter");
+    __name(this, "MCPClient");
   }
-  constructor(disallowedTools = []) {
-    super(disallowedTools);
+  /**
+   * Get the mcp-use package version.
+   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+   */
+  static getPackageVersion() {
+    return getPackageVersion();
+  }
+  codeMode = false;
+  _codeExecutor = null;
+  _customCodeExecutor = null;
+  _codeExecutorConfig = "vm";
+  _executorOptions;
+  _samplingCallback;
+  _elicitationCallback;
+  constructor(config, options) {
+    if (config) {
+      if (typeof config === "string") {
+        super(loadConfigFile(config));
+      } else {
+        super(config);
+      }
+    } else {
+      super();
+    }
+    let codeModeEnabled = false;
+    let executorConfig = "vm";
+    let executorOptions;
+    if (options?.codeMode) {
+      if (typeof options.codeMode === "boolean") {
+        codeModeEnabled = options.codeMode;
+      } else {
+        codeModeEnabled = options.codeMode.enabled;
+        executorConfig = options.codeMode.executor ?? "vm";
+        executorOptions = options.codeMode.executorOptions;
+      }
+    }
+    this.codeMode = codeModeEnabled;
+    this._codeExecutorConfig = executorConfig;
+    this._executorOptions = executorOptions;
+    this._samplingCallback = options?.samplingCallback;
+    this._elicitationCallback = options?.elicitationCallback;
+    if (this.codeMode) {
+      this._setupCodeModeConnector();
+    }
+    this._trackClientInit();
+  }
+  _trackClientInit() {
+    const servers = Object.keys(this.config.mcpServers ?? {});
+    const hasSamplingCallback = !!this._samplingCallback;
+    const hasElicitationCallback = !!this._elicitationCallback;
+    Tel.getInstance().trackMCPClientInit({
+      codeMode: this.codeMode,
+      sandbox: false,
+      // Sandbox not supported in TS yet
+      allCallbacks: hasSamplingCallback && hasElicitationCallback,
+      verify: false,
+      // No verify option in TS client
+      servers,
+      numServers: servers.length,
+      isBrowser: false
+      // Node.js MCPClient
+    }).catch((e) => logger.debug(`Failed to track MCPClient init: ${e}`));
+  }
+  static fromDict(cfg, options) {
+    return new _MCPClient(cfg, options);
+  }
+  static fromConfigFile(path2, options) {
+    return new _MCPClient(loadConfigFile(path2), options);
   }
   /**
-   * Convert a single MCP tool specification into a LangChainJS structured tool.
+   * Save configuration to a file (Node.js only)
    */
-  convertTool(mcpTool, connector) {
-    if (this.disallowedTools.includes(mcpTool.name)) {
-      return null;
+  saveConfig(filepath) {
+    const dir = path.dirname(filepath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
     }
-    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : z2.object({}).optional();
-    const tool = new DynamicStructuredTool({
-      name: mcpTool.name ?? "NO NAME",
-      description: mcpTool.description ?? "",
-      // Blank is acceptable but discouraged.
-      schema: argsSchema,
-      func: /* @__PURE__ */ __name(async (input) => {
-        logger.debug(
-          `MCP tool "${mcpTool.name}" received input: ${JSON.stringify(input)}`
+    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 {
-          const result = await connector.callTool(
-            mcpTool.name,
-            input
+          this._codeExecutor = new VMCodeExecutor(
+            this,
+            this._executorOptions
           );
-          return JSON.stringify(result);
-        } catch (err) {
-          logger.error(`Error executing MCP tool: ${err.message}`);
-          return `Error executing MCP tool: ${String(err)}`;
+        } catch (error) {
+          const e2bOpts = this._executorOptions;
+          const e2bApiKey = e2bOpts?.apiKey || process.env.E2B_API_KEY;
+          if (e2bApiKey) {
+            logger.info(
+              "VM executor not available in this environment. Falling back to E2B."
+            );
+            this._codeExecutor = new E2BCodeExecutor(this, {
+              ...e2bOpts,
+              apiKey: e2bApiKey
+            });
+          } else {
+            throw new Error(
+              "VM executor is not available in this environment. Please provide an E2B API key via executorOptions or E2B_API_KEY environment variable, or run in a Node.js environment."
+            );
+          }
         }
-      }, "func")
+      }
+    }
+    return this._codeExecutor;
+  }
+  /**
+   * Execute code in code mode
+   */
+  async executeCode(code, timeout) {
+    if (!this.codeMode) {
+      throw new Error("Code execution mode is not enabled");
+    }
+    if (this._customCodeExecutor) {
+      return this._customCodeExecutor(code, timeout);
+    }
+    return this._ensureCodeExecutor().execute(code, timeout);
+  }
+  /**
+   * Search available tools (used by code mode)
+   */
+  async searchTools(query = "", detailLevel = "full") {
+    if (!this.codeMode) {
+      throw new Error("Code execution mode is not enabled");
+    }
+    return this._ensureCodeExecutor().createSearchToolsFunction()(
+      query,
+      detailLevel
+    );
+  }
+  /**
+   * Override getServerNames to exclude internal code_mode server
+   */
+  getServerNames() {
+    const isCodeModeEnabled = this.codeMode;
+    return super.getServerNames().filter((name) => {
+      return !isCodeModeEnabled || name !== "code_mode";
     });
-    return tool;
+  }
+  /**
+   * Close the client and clean up resources including code executors.
+   * This ensures E2B sandboxes and other resources are properly released.
+   */
+  async close() {
+    if (this._codeExecutor) {
+      await this._codeExecutor.cleanup();
+      this._codeExecutor = null;
+    }
+    await this.closeAllSessions();
   }
 };
 
@@ -992,15 +2209,21 @@ var ConnectMCPServerTool = class extends MCPServerTool {
         session = await this.manager.client.createSession(serverName);
       }
       this.manager.activeServer = serverName;
-      if (this.manager.serverTools[serverName]) {
+      if (!this.manager.serverTools[serverName]) {
         const connector = session.connector;
         const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
-        this.manager.serverTools[serverName] = tools;
+        const resources = await this.manager.adapter.createResourcesFromConnectors([connector]);
+        const prompts = await this.manager.adapter.createPromptsFromConnectors([connector]);
+        const allItems = [...tools, ...resources, ...prompts];
+        this.manager.serverTools[serverName] = allItems;
         this.manager.initializedServers[serverName] = true;
+        logger.debug(
+          `Loaded ${allItems.length} items for server '${serverName}': ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`
+        );
       }
       const serverTools = this.manager.serverTools[serverName] || [];
       const numTools = serverTools.length;
-      return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
+      return `Connected to MCP server '${serverName}'. ${numTools} tools, resources, and prompts are now available.`;
     } catch (error) {
       logger.error(
         `Error connecting to server '${serverName}': ${String(error)}`
@@ -1161,21 +2384,30 @@ var ServerManager = class {
         if (session) {
           const connector = session.connector;
           let tools = [];
+          let resources = [];
+          let prompts = [];
           try {
             tools = await this.adapter.createToolsFromConnectors([connector]);
+            resources = await this.adapter.createResourcesFromConnectors([
+              connector
+            ]);
+            prompts = await this.adapter.createPromptsFromConnectors([
+              connector
+            ]);
           } catch (toolFetchError) {
             logger.error(
-              `Failed to create tools from connector for server '${serverName}': ${toolFetchError}`
+              `Failed to create tools/resources/prompts from connector for server '${serverName}': ${toolFetchError}`
             );
             continue;
           }
+          const allItems = [...tools, ...resources, ...prompts];
           const cachedTools = this.serverTools[serverName];
-          const toolsChanged = !cachedTools || !isEqual(cachedTools, tools);
+          const toolsChanged = !cachedTools || !isEqual(cachedTools, allItems);
           if (toolsChanged) {
-            this.serverTools[serverName] = tools;
+            this.serverTools[serverName] = allItems;
             this.initializedServers[serverName] = true;
             logger.debug(
-              `Prefetched ${tools.length} tools for server '${serverName}'.`
+              `Prefetched ${allItems.length} items for server '${serverName}': ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts.`
             );
           } else {
             logger.debug(
@@ -1244,9 +2476,9 @@ var ObservabilityManager = class {
       return;
     }
     try {
-      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-N5Y5BSXK.js");
+      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-74RGPTAH.js");
       if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
-        const { initializeLangfuse } = await import("./langfuse-N5Y5BSXK.js");
+        const { initializeLangfuse } = await import("./langfuse-74RGPTAH.js");
         await initializeLangfuse(
           this.agentId,
           this.metadata,
@@ -1406,6 +2638,26 @@ var ObservabilityManager = class {
 import { toJSONSchema } from "zod";
 var API_CHATS_ENDPOINT = "/api/v1/chats";
 var API_CHAT_EXECUTE_ENDPOINT = "/api/v1/chats/{chat_id}/execute";
+function normalizeRemoteRunOptions(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+  if (typeof queryOrOptions === "object" && queryOrOptions !== null) {
+    const options = queryOrOptions;
+    return {
+      query: options.prompt,
+      maxSteps: options.maxSteps,
+      manageConnector: options.manageConnector,
+      externalHistory: options.externalHistory,
+      outputSchema: options.schema
+    };
+  }
+  return {
+    query: queryOrOptions,
+    maxSteps,
+    manageConnector,
+    externalHistory,
+    outputSchema
+  };
+}
+__name(normalizeRemoteRunOptions, "normalizeRemoteRunOptions");
 var RemoteAgent = class {
   static {
     __name(this, "RemoteAgent");
@@ -1502,8 +2754,20 @@ var RemoteAgent = class {
       throw new Error(`Failed to create chat session: ${String(e)}`);
     }
   }
-  async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-    if (externalHistory !== void 0) {
+  async run(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+    const {
+      query,
+      maxSteps: steps,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalizeRemoteRunOptions(
+      queryOrOptions,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
+    if (history !== void 0) {
       logger.warn("External history is not yet supported for remote execution");
     }
     try {
@@ -1514,10 +2778,10 @@ var RemoteAgent = class {
       const chatId = this.chatId;
       const executionPayload = {
         query,
-        max_steps: maxSteps ?? 10
+        max_steps: steps ?? 10
       };
-      if (outputSchema) {
-        executionPayload.output_schema = this.pydanticToJsonSchema(outputSchema);
+      if (schema) {
+        executionPayload.output_schema = this.pydanticToJsonSchema(schema);
         logger.info(`\u{1F527} Using structured output with schema`);
       }
       const headers = {
@@ -1591,8 +2855,8 @@ Raw error: ${result}`
           );
         }
       }
-      if (outputSchema) {
-        return this.parseStructuredResponse(result, outputSchema);
+      if (schema) {
+        return this.parseStructuredResponse(result, schema);
       }
       if (typeof result === "object" && result !== null && "result" in result) {
         return result.result;
@@ -1617,9 +2881,9 @@ Raw error: ${result}`
     }
   }
   // eslint-disable-next-line require-yield
-  async *stream(query, maxSteps, manageConnector, externalHistory, outputSchema) {
+  async *stream(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
     const result = await this.run(
-      query,
+      queryOrOptions,
       maxSteps,
       manageConnector,
       externalHistory,
@@ -1632,6 +2896,144 @@ Raw error: ${result}`
   }
 };
 
+// src/agents/utils/llm_provider.ts
+var PROVIDER_CONFIG = {
+  openai: {
+    package: "@langchain/openai",
+    className: "ChatOpenAI",
+    envVars: ["OPENAI_API_KEY"],
+    defaultModel: "gpt-4o"
+  },
+  anthropic: {
+    package: "@langchain/anthropic",
+    className: "ChatAnthropic",
+    envVars: ["ANTHROPIC_API_KEY"],
+    defaultModel: "claude-3-5-sonnet-20241022"
+  },
+  google: {
+    package: "@langchain/google-genai",
+    className: "ChatGoogleGenerativeAI",
+    envVars: ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+    defaultModel: "gemini-pro"
+  },
+  groq: {
+    package: "@langchain/groq",
+    className: "ChatGroq",
+    envVars: ["GROQ_API_KEY"],
+    defaultModel: "llama-3.1-70b-versatile"
+  }
+};
+function parseLLMString(llmString) {
+  const parts = llmString.split("/");
+  if (parts.length !== 2) {
+    throw new Error(
+      `Invalid LLM string format. Expected 'provider/model', got '${llmString}'. Examples: 'openai/gpt-4', 'anthropic/claude-3-5-sonnet-20241022', 'google/gemini-pro', 'groq/llama-3.1-70b-versatile'`
+    );
+  }
+  const [provider, model] = parts;
+  if (!provider || !model) {
+    throw new Error(
+      `Invalid LLM string format. Both provider and model must be non-empty. Got '${llmString}'`
+    );
+  }
+  const normalizedProvider = provider.toLowerCase();
+  if (!(normalizedProvider in PROVIDER_CONFIG)) {
+    const supportedProviders = Object.keys(PROVIDER_CONFIG).join(", ");
+    throw new Error(
+      `Unsupported LLM provider '${provider}'. Supported providers: ${supportedProviders}`
+    );
+  }
+  return { provider: normalizedProvider, model };
+}
+__name(parseLLMString, "parseLLMString");
+function getAPIKey(provider, config) {
+  if (config?.apiKey) {
+    return config.apiKey;
+  }
+  const providerConfig = PROVIDER_CONFIG[provider];
+  for (const envVar of providerConfig.envVars) {
+    const apiKey = process.env[envVar];
+    if (apiKey) {
+      logger.debug(
+        `Using API key from environment variable ${envVar} for provider ${provider}`
+      );
+      return apiKey;
+    }
+  }
+  const envVarsStr = providerConfig.envVars.join(" or ");
+  throw new Error(
+    `API key not found for provider '${provider}'. Set ${envVarsStr} environment variable or pass apiKey in llmConfig. Example: new MCPAgent({ llm: '${provider}/model', llmConfig: { apiKey: 'your-key' } })`
+  );
+}
+__name(getAPIKey, "getAPIKey");
+async function createLLMFromString(llmString, config) {
+  logger.info(`Creating LLM from string: ${llmString}`);
+  const { provider, model } = parseLLMString(llmString);
+  const providerConfig = PROVIDER_CONFIG[provider];
+  const apiKey = getAPIKey(provider, config);
+  let providerModule;
+  try {
+    logger.debug(`Importing package ${providerConfig.package}...`);
+    providerModule = await import(providerConfig.package);
+  } catch (error) {
+    if (error?.code === "MODULE_NOT_FOUND" || error?.message?.includes("Cannot find module") || error?.message?.includes("Cannot find package")) {
+      throw new Error(
+        `Package '${providerConfig.package}' is not installed. Install it with: npm install ${providerConfig.package} or yarn add ${providerConfig.package}`
+      );
+    }
+    throw new Error(
+      `Failed to import ${providerConfig.package}: ${error?.message || error}`
+    );
+  }
+  const LLMClass = providerModule[providerConfig.className];
+  if (!LLMClass) {
+    throw new Error(
+      `Could not find ${providerConfig.className} in package ${providerConfig.package}. This might be a version compatibility issue.`
+    );
+  }
+  const llmConfig = {
+    model,
+    apiKey,
+    ...config
+  };
+  if (config?.apiKey) {
+    delete llmConfig.apiKey;
+    llmConfig.apiKey = apiKey;
+  }
+  if (provider === "anthropic") {
+    llmConfig.model = model;
+  } else if (provider === "google") {
+    llmConfig.model = model;
+  } else if (provider === "openai") {
+    llmConfig.model = model;
+  } else if (provider === "groq") {
+    llmConfig.model = model;
+  }
+  try {
+    const llmInstance = new LLMClass(llmConfig);
+    logger.info(`Successfully created ${provider} LLM with model ${model}`);
+    return llmInstance;
+  } catch (error) {
+    throw new Error(
+      `Failed to instantiate ${providerConfig.className} with model '${model}': ${error?.message || error}`
+    );
+  }
+}
+__name(createLLMFromString, "createLLMFromString");
+function isValidLLMString(llmString) {
+  try {
+    parseLLMString(llmString);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isValidLLMString, "isValidLLMString");
+function getSupportedProviders() {
+  return Object.keys(PROVIDER_CONFIG);
+}
+__name(getSupportedProviders, "getSupportedProviders");
+
 // src/agents/mcp_agent.ts
 import {
   AIMessage,
@@ -1735,6 +3137,26 @@ Here are the tools *currently* available to you (this list includes server manag
 `;
 
 // src/agents/mcp_agent.ts
+function normalizeRunOptions(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+  if (typeof queryOrOptions === "object" && queryOrOptions !== null) {
+    const options = queryOrOptions;
+    return {
+      query: options.prompt,
+      maxSteps: options.maxSteps,
+      manageConnector: options.manageConnector,
+      externalHistory: options.externalHistory,
+      outputSchema: options.schema
+    };
+  }
+  return {
+    query: queryOrOptions,
+    maxSteps,
+    manageConnector,
+    externalHistory,
+    outputSchema
+  };
+}
+__name(normalizeRunOptions, "normalizeRunOptions");
 var MCPAgent = class {
   static {
     __name(this, "MCPAgent");
@@ -1780,6 +3202,12 @@ var MCPAgent = class {
   // Remote agent support
   isRemote = false;
   remoteAgent = null;
+  // Simplified mode support
+  isSimplifiedMode = false;
+  llmString;
+  llmConfig;
+  mcpServersConfig;
+  clientOwnedByAgent = false;
   constructor(options) {
     if (options.agentId) {
       this.isRemote = true;
@@ -1813,9 +3241,36 @@ var MCPAgent = class {
         "llm is required for local execution. For remote execution, provide agentId instead."
       );
     }
-    this.llm = options.llm;
-    this.client = options.client;
-    this.connectors = options.connectors ?? [];
+    const isSimplifiedMode = typeof options.llm === "string";
+    if (isSimplifiedMode) {
+      this.isSimplifiedMode = true;
+      this.llmString = options.llm;
+      this.llmConfig = options.llmConfig;
+      this.mcpServersConfig = options.mcpServers;
+      if (!this.mcpServersConfig || Object.keys(this.mcpServersConfig).length === 0) {
+        throw new Error(
+          "Simplified mode requires 'mcpServers' configuration. Provide an object with server configurations, e.g., { filesystem: { command: 'npx', args: [...] } }"
+        );
+      }
+      this.llm = void 0;
+      this.client = void 0;
+      this.clientOwnedByAgent = true;
+      this.connectors = [];
+      logger.info(
+        `\u{1F3AF} Simplified mode enabled: LLM will be created from '${this.llmString}'`
+      );
+    } else {
+      this.isSimplifiedMode = false;
+      this.llm = options.llm;
+      this.client = options.client;
+      this.connectors = options.connectors ?? [];
+      this.clientOwnedByAgent = false;
+      if (!this.client && this.connectors.length === 0) {
+        throw new Error(
+          "Explicit mode requires either 'client' or at least one 'connector'. Alternatively, use simplified mode with 'llm' as a string and 'mcpServers' config."
+        );
+      }
+    }
     this.maxSteps = options.maxSteps ?? 5;
     this.autoInitialize = options.autoInitialize ?? false;
     this.memoryEnabled = options.memoryEnabled ?? true;
@@ -1828,28 +3283,30 @@ var MCPAgent = class {
     this.useServerManager = options.useServerManager ?? false;
     this.verbose = options.verbose ?? false;
     this.observe = options.observe ?? true;
-    if (!this.client && this.connectors.length === 0) {
-      throw new Error(
-        "Either 'client' or at least one 'connector' must be provided."
-      );
-    }
-    if (this.useServerManager) {
-      if (!this.client) {
-        throw new Error(
-          "'client' must be provided when 'useServerManager' is true."
-        );
+    if (!this.isSimplifiedMode) {
+      if (this.useServerManager) {
+        if (!this.client) {
+          throw new Error(
+            "'client' must be provided when 'useServerManager' is true."
+          );
+        }
+        this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
+        this.serverManager = options.serverManagerFactory?.(this.client) ?? new ServerManager(this.client, this.adapter);
+      } else {
+        this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
+      }
+      this.telemetry = Telemetry.getInstance();
+      if (this.llm) {
+        const [provider, name] = extractModelInfo(this.llm);
+        this.modelProvider = provider;
+        this.modelName = name;
+      } else {
+        this.modelProvider = "unknown";
+        this.modelName = "unknown";
       }
-      this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
-      this.serverManager = options.serverManagerFactory?.(this.client) ?? new ServerManager(this.client, this.adapter);
     } else {
       this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
-    }
-    this.telemetry = Telemetry.getInstance();
-    if (this.llm) {
-      const [provider, name] = extractModelInfo(this.llm);
-      this.modelProvider = provider;
-      this.modelName = name;
-    } else {
+      this.telemetry = Telemetry.getInstance();
       this.modelProvider = "unknown";
       this.modelName = "unknown";
     }
@@ -1880,6 +3337,40 @@ var MCPAgent = class {
       return;
     }
     logger.info("\u{1F680} Initializing MCP agent and connecting to services...");
+    if (this.isSimplifiedMode) {
+      logger.info(
+        "\u{1F3AF} Simplified mode: Creating client and LLM from configuration..."
+      );
+      if (this.mcpServersConfig) {
+        logger.info(
+          `Creating MCPClient with ${Object.keys(this.mcpServersConfig).length} server(s)...`
+        );
+        this.client = new MCPClient({ mcpServers: this.mcpServersConfig });
+        logger.info("\u2705 MCPClient created successfully");
+      }
+      if (this.llmString) {
+        logger.info(`Creating LLM from string: ${this.llmString}...`);
+        try {
+          this.llm = await createLLMFromString(this.llmString, this.llmConfig);
+          logger.info("\u2705 LLM created successfully");
+          const [provider, name] = extractModelInfo(this.llm);
+          this.modelProvider = provider;
+          this.modelName = name;
+        } catch (error) {
+          throw new Error(
+            `Failed to create LLM from string '${this.llmString}': ${error?.message || error}`
+          );
+        }
+      }
+      if (this.useServerManager) {
+        if (!this.client) {
+          throw new Error(
+            "'client' must be available when 'useServerManager' is true."
+          );
+        }
+        this.serverManager = new ServerManager(this.client, this.adapter);
+      }
+    }
     this.callbacks = await this.observabilityManager.getCallbacks();
     const handlerNames = await this.observabilityManager.getHandlerNames();
     if (handlerNames.length > 0) {
@@ -1923,9 +3414,18 @@ var MCPAgent = class {
             );
           }
         } else {
-          this._tools = await LangChainAdapter.createTools(this.client);
+          const tools = await this.adapter.createToolsFromConnectors(
+            Object.values(this.sessions).map((session) => session.connector)
+          );
+          const resources = await this.adapter.createResourcesFromConnectors(
+            Object.values(this.sessions).map((session) => session.connector)
+          );
+          const prompts = await this.adapter.createPromptsFromConnectors(
+            Object.values(this.sessions).map((session) => session.connector)
+          );
+          this._tools = [...tools, ...resources, ...prompts];
           logger.info(
-            `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
+            `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain items from client: ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`
           );
         }
         this._tools.push(...this.additionalTools);
@@ -1938,12 +3438,19 @@ var MCPAgent = class {
             await connector.connect();
           }
         }
-        this._tools = await this.adapter.createToolsFromConnectors(
+        const tools = await this.adapter.createToolsFromConnectors(
+          this.connectors
+        );
+        const resources = await this.adapter.createResourcesFromConnectors(
+          this.connectors
+        );
+        const prompts = await this.adapter.createPromptsFromConnectors(
           this.connectors
         );
+        this._tools = [...tools, ...resources, ...prompts];
         this._tools.push(...this.additionalTools);
         logger.info(
-          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from connectors`
+          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain items from connectors: ${tools.length} tools, ${resources.length} resources, ${prompts.length} prompts`
         );
       }
       logger.info(`\u{1F9F0} Found ${this._tools.length} tools across all connectors`);
@@ -2406,33 +3913,47 @@ var MCPAgent = class {
       }
     }
   }
-  async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-    if (this.isRemote && this.remoteAgent) {
-      return this.remoteAgent.run(
-        query,
-        maxSteps,
-        manageConnector,
-        externalHistory,
-        outputSchema
-      );
-    }
-    const generator = this.stream(
+  async run(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema) {
+    const {
       query,
+      maxSteps: steps,
+      manageConnector: manage,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalizeRunOptions(
+      queryOrOptions,
       maxSteps,
       manageConnector,
       externalHistory,
       outputSchema
     );
+    if (this.isRemote && this.remoteAgent) {
+      return this.remoteAgent.run(query, steps, manage, history, schema);
+    }
+    const generator = this.stream(query, steps, manage, history, schema);
     return this._consumeAndReturn(generator);
   }
-  async *stream(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+  async *stream(queryOrOptions, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+    const {
+      query,
+      maxSteps: steps,
+      manageConnector: manage,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalizeRunOptions(
+      queryOrOptions,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
     if (this.isRemote && this.remoteAgent) {
       const result = await this.remoteAgent.run(
         query,
-        maxSteps,
-        manageConnector,
-        externalHistory,
-        outputSchema
+        steps,
+        manage,
+        history,
+        schema
       );
       return result;
     }
@@ -2442,7 +3963,7 @@ var MCPAgent = class {
     let finalOutput = null;
     let stepsTaken = 0;
     try {
-      if (manageConnector && !this._initialized) {
+      if (manage && !this._initialized) {
         await this.initialize();
         initializedHere = true;
       } else if (!this._initialized && this.autoInitialize) {
@@ -2466,7 +3987,7 @@ var MCPAgent = class {
           this._agentExecutor = this.createAgent();
         }
       }
-      const historyToUse = externalHistory ?? this.conversationHistory;
+      const historyToUse = history ?? this.conversationHistory;
       const langchainHistory = [];
       for (const msg of historyToUse) {
         if (this._isHumanMessageLike(msg) || this._isAIMessageLike(msg) || this._isToolMessageLike(msg)) {
@@ -2607,13 +4128,13 @@ var MCPAgent = class {
           this.addToHistory(msg);
         }
       }
-      if (outputSchema && finalOutput) {
+      if (schema && finalOutput) {
         try {
           logger.info("\u{1F527} Attempting structured output...");
           const structuredResult = await this._attemptStructuredOutput(
             finalOutput,
             this.llm,
-            outputSchema
+            schema
           );
           if (this.memoryEnabled) {
             this.addToHistory(
@@ -2639,7 +4160,7 @@ var MCPAgent = class {
       return finalOutput || "No output generated";
     } catch (e) {
       logger.error(`\u274C Error running query: ${e}`);
-      if (initializedHere && manageConnector) {
+      if (initializedHere && manage) {
         logger.info("\u{1F9F9} Cleaning up resources after error");
         await this.close();
       }
@@ -2669,9 +4190,9 @@ var MCPAgent = class {
         maxStepsConfigured: this.maxSteps,
         memoryEnabled: this.memoryEnabled,
         useServerManager: this.useServerManager,
-        maxStepsUsed: maxSteps ?? null,
-        manageConnector,
-        externalHistoryUsed: externalHistory !== void 0,
+        maxStepsUsed: steps ?? null,
+        manageConnector: manage ?? true,
+        externalHistoryUsed: history !== void 0,
         stepsTaken,
         toolsUsedCount: this.toolsUsedNames.length,
         toolsUsedNames: this.toolsUsedNames,
@@ -2680,7 +4201,7 @@ var MCPAgent = class {
         errorType: success ? null : "execution_error",
         conversationHistoryLength
       });
-      if (manageConnector && !this.client && initializedHere) {
+      if (manage && !this.client && initializedHere) {
         logger.info("\u{1F9F9} Closing agent after stream completion");
         await this.close();
       }
@@ -2708,15 +4229,28 @@ var MCPAgent = class {
       this._agentExecutor = null;
       this._tools = [];
       if (this.client) {
-        logger.info("\u{1F504} Closing client and cleaning up resources");
-        await this.client.close();
-        this.sessions = {};
+        if (this.clientOwnedByAgent) {
+          logger.info(
+            "\u{1F504} Closing internally-created client (simplified mode) and cleaning up resources"
+          );
+          await this.client.close();
+          this.sessions = {};
+          this.client = void 0;
+        } else {
+          logger.info("\u{1F504} Closing client and cleaning up resources");
+          await this.client.close();
+          this.sessions = {};
+        }
       } else {
         for (const connector of this.connectors) {
           logger.info("\u{1F504} Disconnecting connector");
           await connector.disconnect();
         }
       }
+      if (this.isSimplifiedMode && this.llm) {
+        logger.debug("\u{1F504} Clearing LLM reference (simplified mode)");
+        this.llm = void 0;
+      }
       if ("connectorToolMap" in this.adapter) {
         this.adapter = new LangChainAdapter();
       }
@@ -2725,16 +4259,12 @@ var MCPAgent = class {
       logger.info("\u{1F44B} Agent closed successfully");
     }
   }
-  /**
-   * Yields with pretty-printed output for code mode.
-   * This method formats and displays tool executions in a user-friendly way with syntax highlighting.
-   */
-  async *prettyStreamEvents(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+  async *prettyStreamEvents(queryOrOptions, maxSteps, manageConnector = true, externalHistory, outputSchema) {
     const { prettyStreamEvents: prettyStream } = await import("./display-A5IEINAP.js");
     const finalResponse = "";
     for await (const _ of prettyStream(
       this.streamEvents(
-        query,
+        queryOrOptions,
         maxSteps,
         manageConnector,
         externalHistory,
@@ -2745,22 +4275,32 @@ var MCPAgent = class {
     }
     return finalResponse;
   }
-  /**
-   * Yields LangChain StreamEvent objects from the underlying streamEvents() method.
-   * This provides token-level streaming and fine-grained event updates.
-   */
-  async *streamEvents(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+  async *streamEvents(queryOrOptions, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+    const normalized = normalizeRunOptions(
+      queryOrOptions,
+      maxSteps,
+      manageConnector,
+      externalHistory,
+      outputSchema
+    );
+    let { query } = normalized;
+    const {
+      maxSteps: steps,
+      manageConnector: manage,
+      externalHistory: history,
+      outputSchema: schema
+    } = normalized;
     let initializedHere = false;
     const startTime = Date.now();
     let success = false;
     let eventCount = 0;
     let totalResponseLength = 0;
     let finalResponse = "";
-    if (outputSchema) {
-      query = this._enhanceQueryWithSchema(query, outputSchema);
+    if (schema) {
+      query = this._enhanceQueryWithSchema(query, schema);
     }
     try {
-      if (manageConnector && !this._initialized) {
+      if (manage && !this._initialized) {
         await this.initialize();
         initializedHere = true;
       } else if (!this._initialized && this.autoInitialize) {
@@ -2771,14 +4311,14 @@ var MCPAgent = class {
       if (!agentExecutor) {
         throw new Error("MCP agent failed to initialize");
       }
-      this.maxSteps = maxSteps ?? this.maxSteps;
+      this.maxSteps = steps ?? this.maxSteps;
       const display_query = typeof query === "string" && query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : typeof query === "string" ? query.replace(/\n/g, " ") : String(query);
       logger.info(`\u{1F4AC} Received query for streamEvents: '${display_query}'`);
       if (this.memoryEnabled) {
         logger.info(`\u{1F504} Adding user message to history: ${display_query}`);
         this.addToHistory(new HumanMessage({ content: query }));
       }
-      const historyToUse = externalHistory ?? this.conversationHistory;
+      const historyToUse = history ?? this.conversationHistory;
       const langchainHistory = [];
       for (const msg of historyToUse) {
         if (this._isHumanMessageLike(msg) || this._isAIMessageLike(msg) || this._isToolMessageLike(msg)) {
@@ -2845,17 +4385,13 @@ var MCPAgent = class {
           }
         }
       }
-      if (outputSchema && finalResponse) {
+      if (schema && finalResponse) {
         logger.info("\u{1F527} Attempting structured output conversion...");
         try {
           let conversionCompleted = false;
           let conversionResult = null;
           let conversionError = null;
-          this._attemptStructuredOutput(
-            finalResponse,
-            this.llm,
-            outputSchema
-          ).then((result) => {
+          this._attemptStructuredOutput(finalResponse, this.llm, schema).then((result) => {
             conversionCompleted = true;
             conversionResult = result;
             return result;
@@ -2910,7 +4446,7 @@ var MCPAgent = class {
       success = true;
     } catch (e) {
       logger.error(`\u274C Error during streamEvents: ${e}`);
-      if (initializedHere && manageConnector) {
+      if (initializedHere && manage) {
         logger.info(
           "\u{1F9F9} Cleaning up resources after initialization error in streamEvents"
         );
@@ -2941,15 +4477,15 @@ var MCPAgent = class {
         maxStepsConfigured: this.maxSteps,
         memoryEnabled: this.memoryEnabled,
         useServerManager: this.useServerManager,
-        maxStepsUsed: maxSteps ?? null,
-        manageConnector,
-        externalHistoryUsed: externalHistory !== void 0,
+        maxStepsUsed: steps ?? null,
+        manageConnector: manage ?? true,
+        externalHistoryUsed: history !== void 0,
         response: `[STREAMED RESPONSE - ${totalResponseLength} chars]`,
         executionTimeMs,
         errorType: success ? null : "streaming_error",
         conversationHistoryLength
       });
-      if (manageConnector && !this.client && initializedHere) {
+      if (manage && !this.client && initializedHere) {
         logger.info("\u{1F9F9} Closing agent after streamEvents completion");
         await this.close();
       }
@@ -3152,6 +4688,13 @@ ${formatPrompt}`
 export {
   BaseAdapter,
   LangChainAdapter,
+  BaseCodeExecutor,
+  E2BCodeExecutor,
+  isVMAvailable,
+  VMCodeExecutor,
+  StdioConnector,
+  loadConfigFile,
+  MCPClient,
   AcquireActiveMCPServerTool,
   AddMCPServerFromConfigTool,
   ConnectMCPServerTool,
@@ -3160,5 +4703,9 @@ export {
   ServerManager,
   ObservabilityManager,
   RemoteAgent,
+  parseLLMString,
+  createLLMFromString,
+  isValidLLMString,
+  getSupportedProviders,
   MCPAgent
 };