mcp-use 1.11.0-canary.7 → 1.11.0-canary.9

package/dist/{chunk-5LBXMCKC.js → chunk-N3DO4P2L.js}

@@ -1,2087 +1,23 @@
 import {
-  BaseMCPClient,
-  ConnectionManager,
-  HttpConnector,
-  MCPSession
-} from "./chunk-QP7MQ2UJ.js";
+  MCPClient
+} from "./chunk-WW3A2EKQ.js";
 import {
-  CodeModeConnector
-} from "./chunk-REX2YTWF.js";
+  LangChainAdapter
+} from "./chunk-MFSO5PUW.js";
 import {
-  BaseConnector
-} from "./chunk-CHHWJQVC.js";
-import {
-  Tel,
-  Telemetry,
-  extractModelInfo,
-  getPackageVersion
-} from "./chunk-3QVRNWW7.js";
-import {
-  logger
-} from "./chunk-FRUZDWXH.js";
-import {
-  __name,
-  __require
-} from "./chunk-3GQAWCBQ.js";
-
-// src/adapters/base.ts
-var BaseAdapter = class {
-  static {
-    __name(this, "BaseAdapter");
-  }
-  /**
-   * List of tool names that should not be available.
-   */
-  disallowedTools;
-  /**
-   * Internal cache that maps a connector instance to the list of tools
-   * generated for it.
-   */
-  connectorToolMap = /* @__PURE__ */ new Map();
-  constructor(disallowedTools) {
-    this.disallowedTools = disallowedTools ?? [];
-  }
-  /**
-   * Create tools from an MCPClient instance.
-   *
-   * This is the recommended way to create tools from an MCPClient, as it handles
-   * session creation and connector extraction automatically.
-   *
-   * @param client          The MCPClient to extract tools from.
-   * @param disallowedTools Optional list of tool names to exclude.
-   * @returns               A promise that resolves with a list of converted tools.
-   */
-  static async createTools(client, disallowedTools) {
-    const adapter = new this(disallowedTools);
-    if (!client.activeSessions || Object.keys(client.activeSessions).length === 0) {
-      logger.info("No active sessions found, creating new ones...");
-      await client.createAllSessions();
-    }
-    const sessions = client.getAllActiveSessions();
-    const connectors = Object.values(sessions).map(
-      (session) => session.connector
-    );
-    return adapter.createToolsFromConnectors(connectors);
-  }
-  /**
-   * Dynamically load tools for a specific connector.
-   *
-   * @param connector The connector to load tools for.
-   * @returns         The list of tools that were loaded in the target framework's format.
-   */
-  async loadToolsForConnector(connector) {
-    if (this.connectorToolMap.has(connector)) {
-      const cached = this.connectorToolMap.get(connector);
-      logger.debug(`Returning ${cached.length} existing tools for connector`);
-      return cached;
-    }
-    const connectorTools = [];
-    const success = await this.ensureConnectorInitialized(connector);
-    if (!success) {
-      return [];
-    }
-    for (const tool of connector.tools) {
-      const converted = this.convertTool(tool, connector);
-      if (converted) {
-        connectorTools.push(converted);
-      }
-    }
-    this.connectorToolMap.set(connector, connectorTools);
-    logger.debug(
-      `Loaded ${connectorTools.length} new tools for connector: ${connectorTools.map((t) => t?.name ?? String(t)).join(", ")}`
-    );
-    return connectorTools;
-  }
-  /**
-   * Create tools from MCP tools in all provided connectors.
-   *
-   * @param connectors List of MCP connectors to create tools from.
-   * @returns         A promise that resolves with all converted tools.
-   */
-  async createToolsFromConnectors(connectors) {
-    const tools = [];
-    for (const connector of connectors) {
-      const connectorTools = await this.loadToolsForConnector(connector);
-      tools.push(...connectorTools);
-    }
-    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.
-   *
-   * @param connector The connector to check.
-   * @returns         True if the connector is initialized and has tools, false otherwise.
-   */
-  checkConnectorInitialized(connector) {
-    return Boolean(connector.tools && connector.tools.length);
-  }
-  /**
-   * Ensure a connector is initialized.
-   *
-   * @param connector The connector to initialize.
-   * @returns         True if initialization succeeded, false otherwise.
-   */
-  async ensureConnectorInitialized(connector) {
-    if (!this.checkConnectorInitialized(connector)) {
-      logger.debug("Connector doesn't have tools, initializing it");
-      try {
-        await connector.initialize();
-        return true;
-      } catch (err) {
-        logger.error(`Error initializing connector: ${err}`);
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-// src/utils/json-schema-to-zod/JSONSchemaToZod.ts
-import { z } from "zod";
-var JSONSchemaToZod = class {
-  static {
-    __name(this, "JSONSchemaToZod");
-  }
-  /**
-   * Converts a JSON schema to a Zod schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {ZodSchema} - The Zod schema.
-   */
-  static convert(schema) {
-    return this.parseSchema(schema);
-  }
-  /**
-   * Checks if data matches a condition schema.
-   *
-   * @param {JSONValue} data - The data to check.
-   * @param {JSONSchema} condition - The condition schema.
-   * @returns {boolean} - Whether the data matches the condition.
-   */
-  static matchesCondition(data, condition) {
-    if (!condition.properties) {
-      return true;
-    }
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      return false;
-    }
-    const objectData = data;
-    for (const [key, propCondition] of Object.entries(condition.properties)) {
-      if (!(key in objectData)) {
-        if ("const" in propCondition) {
-          return false;
-        }
-        continue;
-      }
-      const value = objectData[key];
-      if ("const" in propCondition && value !== propCondition["const"]) {
-        return false;
-      }
-      if ("minimum" in propCondition && typeof value === "number" && value < propCondition["minimum"]) {
-        return false;
-      }
-      if ("maximum" in propCondition && typeof value === "number" && value > propCondition["maximum"]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Validates data against a conditional schema and adds issues to context if validation fails.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The conditional schema.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
-   */
-  static validateConditionalSchema(data, schema, ctx) {
-    this.validateRequiredProperties(data, schema, ctx);
-    this.validatePropertyPatterns(data, schema, ctx);
-    this.validateNestedConditions(data, schema, ctx);
-  }
-  /**
-   * Validates that all required properties are present in the data.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The schema containing required properties.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
-   */
-  static validateRequiredProperties(data, schema, ctx) {
-    if (!schema.required) {
-      return;
-    }
-    if (typeof data !== "object" || data === null) {
-      for (const requiredProp of schema.required) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Required property '${requiredProp}' is missing`,
-          path: [requiredProp]
-        });
-      }
-      return;
-    }
-    for (const requiredProp of schema.required) {
-      if (!(requiredProp in data)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `Required property '${requiredProp}' is missing`,
-          path: [requiredProp]
-        });
-      }
-    }
-  }
-  /**
-   * Validates property patterns for string properties.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The schema containing property patterns.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
-   */
-  static validatePropertyPatterns(data, schema, ctx) {
-    if (!schema.properties) {
-      return;
-    }
-    if (typeof data !== "object" || data === null) {
-      return;
-    }
-    if (Array.isArray(data)) {
-      return;
-    }
-    const objectData = data;
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      if (!(key in objectData)) {
-        continue;
-      }
-      const value = objectData[key];
-      if (propSchema["pattern"] && typeof value === "string") {
-        const regex = new RegExp(propSchema["pattern"]);
-        if (!regex.test(value)) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `String '${value}' does not match pattern '${propSchema["pattern"]}'`,
-            path: [key]
-          });
-        }
-      }
-    }
-  }
-  /**
-   * Validates nested if-then-else conditions.
-   *
-   * @param {JSONValue} data - The data to validate.
-   * @param {JSONSchema} schema - The schema containing if-then-else conditions.
-   * @param {z.RefinementCtx} ctx - The Zod refinement context.
-   */
-  static validateNestedConditions(data, schema, ctx) {
-    if (!schema["if"] || !schema["then"]) {
-      return;
-    }
-    const matchesIf = this.matchesCondition(data, schema["if"]);
-    if (matchesIf) {
-      this.validateConditionalSchema(data, schema["then"], ctx);
-    } else if (schema["else"]) {
-      this.validateConditionalSchema(data, schema["else"], ctx);
-    }
-  }
-  /**
-   * Parses a JSON schema and returns the corresponding Zod schema.
-   * This is the main entry point for schema conversion.
-   *
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseSchema(schema) {
-    if (Array.isArray(schema.type)) {
-      return this.handleTypeArray(schema);
-    }
-    if (schema.oneOf || schema.anyOf || schema.allOf) {
-      return this.parseCombinator(schema);
-    }
-    if (schema["if"] && schema["then"]) {
-      return this.parseObject(schema);
-    }
-    if (schema.properties && (!schema.type || schema.type === "object")) {
-      return this.parseObject(schema);
-    }
-    return this.handleSingleType(schema);
-  }
-  /**
-   * Handles schemas with an array of types.
-   *
-   * @param {JSONSchema} schema - The JSON schema with type array.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static handleTypeArray(schema) {
-    if (!Array.isArray(schema.type)) {
-      throw new Error("Expected schema.type to be an array");
-    }
-    if (schema.type.includes("null")) {
-      return this.handleNullableType(schema);
-    }
-    return this.createUnionFromTypes(schema.type, schema);
-  }
-  /**
-   * Handles nullable types by creating a nullable schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema with nullable type.
-   * @returns {ZodTypeAny} - The nullable Zod schema.
-   */
-  static handleNullableType(schema) {
-    if (!Array.isArray(schema.type)) {
-      throw new Error("Expected schema.type to be an array");
-    }
-    const nonNullSchema = { ...schema };
-    nonNullSchema.type = schema.type.filter((t) => t !== "null");
-    if (nonNullSchema.type.length === 1) {
-      const singleTypeSchema = this.handleSingleType({
-        ...schema,
-        type: nonNullSchema.type[0]
-      });
-      return singleTypeSchema.nullable();
-    }
-    const unionSchema = this.parseSchema(nonNullSchema);
-    return unionSchema.nullable();
-  }
-  /**
-   * Creates a union type from an array of types.
-   *
-   * @param {string[]} types - Array of type strings.
-   * @param {JSONSchema} baseSchema - The base schema to apply to each type.
-   * @returns {ZodTypeAny} - The union Zod schema.
-   */
-  static createUnionFromTypes(types, baseSchema) {
-    const schemas = types.map((type) => {
-      const singleTypeSchema = { ...baseSchema, type };
-      return this.parseSchema(singleTypeSchema);
-    });
-    return z.union(schemas);
-  }
-  /**
-   * Handles schemas with a single type.
-   *
-   * @param {JSONSchema} schema - The JSON schema with single type.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static handleSingleType(schema) {
-    if (schema.type === void 0) {
-      if (schema.oneOf || schema.anyOf || schema.allOf) {
-        return this.parseCombinator(schema);
-      }
-      if (schema.properties) {
-        return this.parseObject(schema);
-      }
-      return z.any();
-    }
-    switch (schema.type) {
-      case "string":
-        return this.parseString(schema);
-      case "number":
-      case "integer":
-        return this.parseNumberSchema(schema);
-      case "boolean":
-        return z.boolean();
-      case "array":
-        return this.parseArray(schema);
-      case "object":
-        return this.parseObject(schema);
-      default:
-        throw new Error("Unsupported schema type");
-    }
-  }
-  /**
-   * Parses a number schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema for a number.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseNumberSchema(schema) {
-    const numberSchema = z.number();
-    let result = numberSchema;
-    result = this.applyNumberBounds(numberSchema, schema);
-    result = this.applyNumberMultipleOf(numberSchema, schema);
-    result = this.applyNumberEnum(numberSchema, schema);
-    result = this.applyIntegerConstraint(numberSchema, schema);
-    return result;
-  }
-  /**
-   * Applies bounds validation to a number schema.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema with bounds.
-   * @returns {z.ZodNumber} - The updated schema with bounds validation.
-   */
-  static applyNumberBounds(numberSchema, schema) {
-    let result = numberSchema;
-    if (schema["minimum"] !== void 0) {
-      result = schema["exclusiveMinimum"] ? result.gt(schema["minimum"]) : result.gte(schema["minimum"]);
-    }
-    if (schema["maximum"] !== void 0) {
-      result = schema["exclusiveMaximum"] ? result.lt(schema["maximum"]) : result.lte(schema["maximum"]);
-    }
-    return result;
-  }
-  /**
-   * Applies multipleOf validation to a number schema.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema with multipleOf.
-   * @returns {z.ZodNumber} - The updated schema with multipleOf validation.
-   */
-  static applyNumberMultipleOf(numberSchema, schema) {
-    if (schema["multipleOf"] === void 0) {
-      return numberSchema;
-    }
-    return numberSchema.refine((val) => val % schema["multipleOf"] === 0, {
-      message: `Number must be a multiple of ${schema["multipleOf"]}`
-    });
-  }
-  /**
-   * Applies enum validation to a number schema.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema with enum.
-   * @returns {z.ZodNumber} - The updated schema with enum validation.
-   */
-  static applyNumberEnum(numberSchema, schema) {
-    if (!schema.enum) {
-      return numberSchema;
-    }
-    const numberEnums = schema.enum.filter(
-      (val) => typeof val === "number"
-    );
-    if (numberEnums.length === 0) {
-      return numberSchema;
-    }
-    return numberSchema.refine((val) => numberEnums.includes(val), {
-      message: `Number must be one of: ${numberEnums.join(", ")}`
-    });
-  }
-  /**
-   * Applies integer constraint to a number schema if needed.
-   *
-   * @param {z.ZodNumber} numberSchema - The base number schema.
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {z.ZodNumber} - The updated schema with integer validation if needed.
-   */
-  static applyIntegerConstraint(numberSchema, schema) {
-    if (schema.type !== "integer") {
-      return numberSchema;
-    }
-    return numberSchema.refine((val) => Number.isInteger(val), {
-      message: "Number must be an integer"
-    });
-  }
-  /**
-   * Parses a string schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema for a string.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseString(schema) {
-    const stringSchema = z.string();
-    let result = stringSchema;
-    if (schema.format) {
-      return this.applyStringFormat(stringSchema, schema);
-    } else {
-      result = this.applyStringPattern(stringSchema, schema);
-      result = this.applyStringLength(stringSchema, schema);
-      result = this.applyStringEnum(stringSchema, schema);
-    }
-    return result;
-  }
-  /**
-   * Applies format validation to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with format.
-   * @returns {ZodTypeAny} - The updated schema with format validation.
-   */
-  static applyStringFormat(stringSchema, schema) {
-    if (!schema.format) {
-      return stringSchema;
-    }
-    switch (schema.format) {
-      case "email":
-        return stringSchema.email();
-      case "date-time":
-        return stringSchema.datetime();
-      case "uri":
-        return stringSchema.url();
-      case "uuid":
-        return stringSchema.uuid();
-      case "date":
-        return stringSchema.date();
-      default:
-        return stringSchema;
-    }
-  }
-  /**
-   * Applies pattern validation to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with pattern.
-   * @returns {z.ZodString} - The updated schema with pattern validation.
-   */
-  static applyStringPattern(stringSchema, schema) {
-    if (!schema["pattern"]) {
-      return stringSchema;
-    }
-    const regex = new RegExp(schema["pattern"]);
-    return stringSchema.regex(regex, {
-      message: `String must match pattern: ${schema["pattern"]}`
-    });
-  }
-  /**
-   * Applies length constraints to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with length constraints.
-   * @returns {z.ZodString} - The updated schema with length validation.
-   */
-  static applyStringLength(stringSchema, schema) {
-    const result = stringSchema;
-    if (schema["minLength"] !== void 0) {
-      stringSchema = stringSchema.min(schema["minLength"]);
-    }
-    if (schema["maxLength"] !== void 0) {
-      stringSchema = stringSchema.max(schema["maxLength"]);
-    }
-    return result;
-  }
-  /**
-   * Applies enum validation to a string schema.
-   *
-   * @param {z.ZodString} stringSchema - The base string schema.
-   * @param {JSONSchema} schema - The JSON schema with enum.
-   * @returns {ZodTypeAny} - The updated schema with enum validation.
-   */
-  static applyStringEnum(stringSchema, schema) {
-    if (!schema.enum) {
-      return stringSchema;
-    }
-    return stringSchema.refine((val) => schema.enum?.includes(val), {
-      message: `Value must be one of: ${schema.enum?.join(", ")}`
-    });
-  }
-  /**
-   * Parses a JSON schema of type array and returns the corresponding Zod schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseArray(schema) {
-    if (Array.isArray(schema.items)) {
-      const tupleSchemas = schema.items.map((item) => this.parseSchema(item));
-      return z.union(tupleSchemas);
-    }
-    const itemSchema = schema.items ? this.parseSchema(schema.items) : z.any();
-    const arraySchema = z.array(itemSchema);
-    let result = arraySchema;
-    result = this.applyArrayConstraints(arraySchema, schema);
-    return result;
-  }
-  /**
-   * Applies constraints to an array schema.
-   *
-   * @param {z.ZodArray<any>} arraySchema - The base array schema.
-   * @param {JSONSchema} schema - The JSON schema with array constraints.
-   * @returns {z.ZodTypeAny} - The updated array schema with constraints.
-   */
-  static applyArrayConstraints(arraySchema, schema) {
-    if (schema["minItems"] !== void 0) {
-      arraySchema = arraySchema.min(schema["minItems"]);
-    }
-    if (schema["maxItems"] !== void 0) {
-      arraySchema = arraySchema.max(schema["maxItems"]);
-    }
-    if (schema["uniqueItems"]) {
-      return arraySchema.refine(
-        (items) => new Set(items).size === items.length,
-        { message: "Array items must be unique" }
-      );
-    }
-    return arraySchema;
-  }
-  /**
-   * Parses an object schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema for an object.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseObject(schema) {
-    if (schema["if"] && schema["then"]) {
-      return this.parseConditional(schema);
-    }
-    const shape = {};
-    this.processObjectProperties(schema, shape);
-    return this.processAdditionalProperties(schema, z.object(shape));
-  }
-  /**
-   * Processes object properties and builds the shape object.
-   *
-   * @param {JSONSchema} schema - The JSON schema for an object.
-   * @param {Record<string, ZodTypeAny>} shape - The shape object to populate.
-   */
-  static processObjectProperties(schema, shape) {
-    const required = new Set(schema.required || []);
-    if (!schema.properties) {
-      return;
-    }
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      const zodSchema = this.parseSchema(propSchema);
-      shape[key] = required.has(key) ? zodSchema : zodSchema.optional();
-    }
-  }
-  /**
-   * Processes additionalProperties configuration.
-   *
-   * @param {JSONSchema} schema - The JSON schema for an object.
-   * @param {z.ZodObject<any, any>} objectSchema - The Zod object schema.
-   * @returns {z.ZodObject<any, any>} - The updated Zod object schema.
-   */
-  static processAdditionalProperties(schema, objectSchema) {
-    if (schema.additionalProperties === true) {
-      return objectSchema.passthrough();
-    } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-      const additionalPropSchema = this.parseSchema(
-        schema.additionalProperties
-      );
-      return objectSchema.catchall(additionalPropSchema);
-    } else {
-      return objectSchema.strict();
-    }
-  }
-  /**
-   * Parses a conditional schema with if-then-else.
-   *
-   * @param {JSONSchema} schema - The JSON schema with conditional validation.
-   * @returns {ZodTypeAny} - The conditional Zod schema.
-   */
-  static parseConditional(schema) {
-    const zodObject = this.createBaseObjectSchema(schema);
-    const ifCondition = schema["if"];
-    const thenSchema = schema["then"];
-    const elseSchema = schema["else"];
-    return zodObject.superRefine((data, ctx) => {
-      const dataWithDefaults = this.applyDefaultValues(
-        data,
-        schema
-      );
-      if (this.matchesCondition(dataWithDefaults, ifCondition)) {
-        this.validateConditionalSchema(dataWithDefaults, thenSchema, ctx);
-      } else if (elseSchema) {
-        this.validateConditionalSchema(dataWithDefaults, elseSchema, ctx);
-      }
-    });
-  }
-  /**
-   * Creates a base object schema from the given JSON schema.
-   *
-   * @param {JSONSchema} schema - The JSON schema.
-   * @returns {z.ZodObject<any, any>} - The base Zod object schema.
-   */
-  static createBaseObjectSchema(schema) {
-    const shape = {};
-    const required = new Set(schema.required || []);
-    for (const [key, value] of Object.entries(schema.properties || {})) {
-      const zodSchema = this.parseSchema(value);
-      shape[key] = required.has(key) ? zodSchema : zodSchema.optional();
-    }
-    const zodObject = z.object(shape);
-    return this.processAdditionalProperties(schema, zodObject);
-  }
-  /**
-   * Applies default values from schema properties to data object.
-   *
-   * @param {JSONValue} data - The original data object.
-   * @param {JSONSchema} schema - The schema with default values.
-   * @returns {JSONValue} - The data object with defaults applied.
-   */
-  static applyDefaultValues(data, schema) {
-    if (typeof data !== "object" || data === null) {
-      return data;
-    }
-    if (Array.isArray(data)) {
-      return data;
-    }
-    const objectData = data;
-    const dataWithDefaults = { ...objectData };
-    if (!schema.properties) {
-      return dataWithDefaults;
-    }
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      if (!(key in dataWithDefaults) && "default" in propSchema) {
-        dataWithDefaults[key] = propSchema["default"];
-      }
-    }
-    return dataWithDefaults;
-  }
-  /**
-   * Parses a schema with combinators (oneOf, anyOf, allOf).
-   * Delegates to the appropriate combinator parser based on which combinator is present.
-   *
-   * @param {JSONSchema} schema - The JSON schema with combinators.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseCombinator(schema) {
-    if (schema.oneOf) {
-      return this.parseOneOf(schema.oneOf);
-    }
-    if (schema.anyOf) {
-      return this.parseAnyOf(schema.anyOf);
-    }
-    if (schema.allOf) {
-      return this.parseAllOf(schema.allOf);
-    }
-    throw new Error("Unsupported schema type");
-  }
-  /**
-   * Parses a oneOf combinator schema.
-   *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas in the oneOf.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseOneOf(schemas) {
-    return this.createUnionFromSchemas(schemas);
-  }
-  /**
-   * Parses an anyOf combinator schema.
-   *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas in the anyOf.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseAnyOf(schemas) {
-    return this.createUnionFromSchemas(schemas);
-  }
-  /**
-   * Creates a union from an array of schemas, handling special cases.
-   *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas to create a union from.
-   * @returns {ZodTypeAny} - The union Zod schema.
-   */
-  static createUnionFromSchemas(schemas) {
-    if (schemas.length === 0) {
-      return z.any();
-    }
-    if (schemas.length === 1) {
-      return this.parseSchema(schemas[0]);
-    }
-    const zodSchemas = [];
-    for (const subSchema of schemas) {
-      if (subSchema.type === "null") {
-        zodSchemas.push(z.null());
-      } else {
-        zodSchemas.push(this.parseSchema(subSchema));
-      }
-    }
-    if (zodSchemas.length >= 2) {
-      return z.union(zodSchemas);
-    } else if (zodSchemas.length === 1) {
-      return zodSchemas[0];
-    }
-    return z.any();
-  }
-  /**
-   * Parses an allOf combinator schema by merging all schemas.
-   *
-   * @param {JSONSchema[]} schemas - Array of JSON schemas in the allOf.
-   * @returns {ZodTypeAny} - The ZodTypeAny schema.
-   */
-  static parseAllOf(schemas) {
-    if (schemas.length === 0) {
-      return z.any();
-    }
-    if (schemas.length === 1) {
-      return this.parseSchema(schemas[0]);
-    }
-    const mergedSchema = schemas.reduce(
-      (acc, currentSchema) => this.mergeSchemas(acc, currentSchema)
-    );
-    return this.parseSchema(mergedSchema);
-  }
-  /**
-   * Merges two JSON schemas together.
-   *
-   * @param {JSONSchema} baseSchema - The base JSON schema.
-   * @param {JSONSchema} addSchema - The JSON schema to add.
-   * @returns {JSONSchema} - The merged JSON schema
-   */
-  static mergeSchemas(baseSchema, addSchema) {
-    const merged = { ...baseSchema, ...addSchema };
-    if (baseSchema.properties && addSchema.properties) {
-      const mergedProperties = {
-        ...baseSchema.properties,
-        ...addSchema.properties
-      };
-      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;
-    }
-  }
-  get publicIdentifier() {
-    return {
-      type: "stdio",
-      "command&args": `${this.command} ${this.args.join(" ")}`
-    };
-  }
-};
-
-// src/config.ts
-import { readFileSync } from "fs";
-function loadConfigFile(filepath) {
-  const raw = readFileSync(filepath, "utf-8");
-  return JSON.parse(raw);
-}
-__name(loadConfigFile, "loadConfigFile");
-function createConnectorFromConfig(serverConfig, connectorOptions) {
-  if ("command" in serverConfig && "args" in serverConfig) {
-    return new StdioConnector({
-      command: serverConfig.command,
-      args: serverConfig.args,
-      env: serverConfig.env,
-      ...connectorOptions
-    });
-  }
-  if ("url" in serverConfig) {
-    const transport = serverConfig.transport || "http";
-    return new HttpConnector(serverConfig.url, {
-      headers: serverConfig.headers,
-      authToken: serverConfig.auth_token || serverConfig.authToken,
-      // Only force SSE if explicitly requested
-      preferSse: serverConfig.preferSse || transport === "sse",
-      ...connectorOptions
-    });
-  }
-  throw new Error("Cannot determine connector type from config");
-}
-__name(createConnectorFromConfig, "createConnectorFromConfig");
-
-// src/client.ts
-import fs from "fs";
-import path from "path";
-var MCPClient = class _MCPClient extends BaseMCPClient {
-  static {
-    __name(this, "MCPClient");
-  }
-  /**
-   * Get the mcp-use package version.
-   * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
-   */
-  static getPackageVersion() {
-    return getPackageVersion();
-  }
-  codeMode = false;
-  _codeExecutor = null;
-  _customCodeExecutor = null;
-  _codeExecutorConfig = "vm";
-  _executorOptions;
-  _samplingCallback;
-  _elicitationCallback;
-  constructor(config, options) {
-    if (config) {
-      if (typeof config === "string") {
-        super(loadConfigFile(config));
-      } else {
-        super(config);
-      }
-    } else {
-      super();
-    }
-    let codeModeEnabled = false;
-    let executorConfig = "vm";
-    let executorOptions;
-    if (options?.codeMode) {
-      if (typeof options.codeMode === "boolean") {
-        codeModeEnabled = options.codeMode;
-      } else {
-        codeModeEnabled = options.codeMode.enabled;
-        executorConfig = options.codeMode.executor ?? "vm";
-        executorOptions = options.codeMode.executorOptions;
-      }
-    }
-    this.codeMode = codeModeEnabled;
-    this._codeExecutorConfig = executorConfig;
-    this._executorOptions = executorOptions;
-    this._samplingCallback = options?.samplingCallback;
-    this._elicitationCallback = options?.elicitationCallback;
-    if (this.codeMode) {
-      this._setupCodeModeConnector();
-    }
-    this._trackClientInit();
-  }
-  _trackClientInit() {
-    const servers = Object.keys(this.config.mcpServers ?? {});
-    const hasSamplingCallback = !!this._samplingCallback;
-    const hasElicitationCallback = !!this._elicitationCallback;
-    Tel.getInstance().trackMCPClientInit({
-      codeMode: this.codeMode,
-      sandbox: false,
-      // Sandbox not supported in TS yet
-      allCallbacks: hasSamplingCallback && hasElicitationCallback,
-      verify: false,
-      // No verify option in TS client
-      servers,
-      numServers: servers.length,
-      isBrowser: false
-      // Node.js MCPClient
-    }).catch((e) => logger.debug(`Failed to track MCPClient init: ${e}`));
-  }
-  static fromDict(cfg, options) {
-    return new _MCPClient(cfg, options);
-  }
-  static fromConfigFile(path2, options) {
-    return new _MCPClient(loadConfigFile(path2), options);
-  }
-  /**
-   * Save configuration to a file (Node.js only)
-   */
-  saveConfig(filepath) {
-    const dir = path.dirname(filepath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(filepath, JSON.stringify(this.config, null, 2), "utf-8");
-  }
-  /**
-   * Create a connector from server configuration (Node.js version)
-   * Supports all connector types including StdioConnector
-   */
-  createConnectorFromConfig(serverConfig) {
-    return createConnectorFromConfig(serverConfig, {
-      samplingCallback: this._samplingCallback,
-      elicitationCallback: this._elicitationCallback
-    });
-  }
-  _setupCodeModeConnector() {
-    logger.debug("Code mode connector initialized as internal meta server");
-    const connector = new CodeModeConnector(this);
-    const session = new MCPSession(connector);
-    this.sessions["code_mode"] = session;
-    this.activeSessions.push("code_mode");
-  }
-  _ensureCodeExecutor() {
-    if (!this._codeExecutor) {
-      const config = this._codeExecutorConfig;
-      if (config instanceof BaseCodeExecutor) {
-        this._codeExecutor = config;
-      } else if (typeof config === "function") {
-        this._customCodeExecutor = config;
-        throw new Error(
-          "Custom executor function should be handled in executeCode"
-        );
-      } else if (config === "e2b") {
-        const opts = this._executorOptions;
-        if (!opts?.apiKey) {
-          logger.warn("E2B executor requires apiKey. Falling back to VM.");
-          try {
-            this._codeExecutor = new VMCodeExecutor(
-              this,
-              this._executorOptions
-            );
-          } catch (error) {
-            throw new Error(
-              "VM executor is not available in this environment and E2B API key is not provided. Please provide an E2B API key or run in a Node.js environment."
-            );
-          }
-        } else {
-          this._codeExecutor = new E2BCodeExecutor(this, opts);
-        }
-      } else {
-        try {
-          this._codeExecutor = new VMCodeExecutor(
-            this,
-            this._executorOptions
-          );
-        } catch (error) {
-          const e2bOpts = this._executorOptions;
-          const e2bApiKey = e2bOpts?.apiKey || process.env.E2B_API_KEY;
-          if (e2bApiKey) {
-            logger.info(
-              "VM executor not available in this environment. Falling back to E2B."
-            );
-            this._codeExecutor = new E2BCodeExecutor(this, {
-              ...e2bOpts,
-              apiKey: e2bApiKey
-            });
-          } else {
-            throw new Error(
-              "VM executor is not available in this environment. Please provide an E2B API key via executorOptions or E2B_API_KEY environment variable, or run in a Node.js environment."
-            );
-          }
-        }
-      }
-    }
-    return this._codeExecutor;
-  }
-  /**
-   * Execute code in code mode
-   */
-  async executeCode(code, timeout) {
-    if (!this.codeMode) {
-      throw new Error("Code execution mode is not enabled");
-    }
-    if (this._customCodeExecutor) {
-      return this._customCodeExecutor(code, timeout);
-    }
-    return this._ensureCodeExecutor().execute(code, timeout);
-  }
-  /**
-   * Search available tools (used by code mode)
-   */
-  async searchTools(query = "", detailLevel = "full") {
-    if (!this.codeMode) {
-      throw new Error("Code execution mode is not enabled");
-    }
-    return this._ensureCodeExecutor().createSearchToolsFunction()(
-      query,
-      detailLevel
-    );
-  }
-  /**
-   * Override getServerNames to exclude internal code_mode server
-   */
-  getServerNames() {
-    const isCodeModeEnabled = this.codeMode;
-    return super.getServerNames().filter((name) => {
-      return !isCodeModeEnabled || name !== "code_mode";
-    });
-  }
-  /**
-   * Close the client and clean up resources including code executors.
-   * This ensures E2B sandboxes and other resources are properly released.
-   */
-  async close() {
-    if (this._codeExecutor) {
-      await this._codeExecutor.cleanup();
-      this._codeExecutor = null;
-    }
-    await this.closeAllSessions();
-  }
-};
+  Telemetry,
+  extractModelInfo,
+  getPackageVersion
+} from "./chunk-Q5LZL6BH.js";
+import {
+  logger
+} from "./chunk-FRUZDWXH.js";
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
 
 // src/managers/tools/acquire_active_mcp_server.ts
-import { z as z3 } from "zod";
+import { z } from "zod";
 
 // src/managers/tools/base.ts
 import { StructuredTool } from "@langchain/core/tools";
@@ -2106,7 +42,7 @@ var MCPServerTool = class extends StructuredTool {
 };
 
 // src/managers/tools/acquire_active_mcp_server.ts
-var PresentActiveServerSchema = z3.object({});
+var PresentActiveServerSchema = z.object({});
 var AcquireActiveMCPServerTool = class extends MCPServerTool {
   static {
     __name(this, "AcquireActiveMCPServerTool");
@@ -2127,16 +63,16 @@ var AcquireActiveMCPServerTool = class extends MCPServerTool {
 
 // src/managers/tools/add_server_from_config.ts
 import { StructuredTool as StructuredTool2 } from "@langchain/core/tools";
-import { z as z4 } from "zod";
+import { z as z2 } from "zod";
 var AddMCPServerFromConfigTool = class extends StructuredTool2 {
   static {
     __name(this, "AddMCPServerFromConfigTool");
   }
   name = "add_mcp_server_from_config";
   description = "Adds a new MCP server to the client from a configuration object and connects to it, making its tools available.";
-  schema = z4.object({
-    serverName: z4.string().describe("The name for the new MCP server."),
-    serverConfig: z4.any().describe(
+  schema = z2.object({
+    serverName: z2.string().describe("The name for the new MCP server."),
+    serverConfig: z2.any().describe(
       'The configuration object for the server. This should not include the top-level "mcpServers" key.'
     )
   });
@@ -2178,9 +114,9 @@ ${tools.map((t) => t.name).join("\n")}`;
 };
 
 // src/managers/tools/connect_mcp_server.ts
-import { z as z5 } from "zod";
-var ConnectMCPServerSchema = z5.object({
-  serverName: z5.string().describe("The name of the MCP server.")
+import { z as z3 } from "zod";
+var ConnectMCPServerSchema = z3.object({
+  serverName: z3.string().describe("The name of the MCP server.")
 });
 var ConnectMCPServerTool = class extends MCPServerTool {
   static {
@@ -2234,8 +170,8 @@ var ConnectMCPServerTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/list_mcp_servers.ts
-import { z as z6 } from "zod";
-var EnumerateServersSchema = z6.object({});
+import { z as z4 } from "zod";
+var EnumerateServersSchema = z4.object({});
 var ListMCPServersTool = class extends MCPServerTool {
   static {
     __name(this, "ListMCPServersTool");
@@ -2272,8 +208,8 @@ var ListMCPServersTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/release_mcp_server_connection.ts
-import { z as z7 } from "zod";
-var ReleaseConnectionSchema = z7.object({});
+import { z as z5 } from "zod";
+var ReleaseConnectionSchema = z5.object({});
 var ReleaseMCPServerConnectionTool = class extends MCPServerTool {
   static {
     __name(this, "ReleaseMCPServerConnectionTool");
@@ -4686,15 +2622,6 @@ ${formatPrompt}`
 };
 
 export {
-  BaseAdapter,
-  LangChainAdapter,
-  BaseCodeExecutor,
-  E2BCodeExecutor,
-  isVMAvailable,
-  VMCodeExecutor,
-  StdioConnector,
-  loadConfigFile,
-  MCPClient,
   AcquireActiveMCPServerTool,
   AddMCPServerFromConfigTool,
   ConnectMCPServerTool,