mcp-use 1.10.6 → 1.11.0-canary.11

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

@@ -1,870 +1,23 @@
+import {
+  MCPClient
+} from "./chunk-7PSUUT4A.js";
+import {
+  LangChainAdapter
+} from "./chunk-MFSO5PUW.js";
 import {
   Telemetry,
   extractModelInfo,
   getPackageVersion
-} from "./chunk-JH3ZOGLI.js";
+} from "./chunk-J3WTIYVV.js";
 import {
   logger
-} from "./chunk-34R6SIER.js";
+} from "./chunk-FRUZDWXH.js";
 import {
   __name
 } 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;
-  }
-  /**
-   * 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;
-  }
-};
-
 // 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";
@@ -889,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");
@@ -910,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.'
     )
   });
@@ -961,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 {
@@ -992,15 +145,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)}`
@@ -1011,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");
@@ -1049,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");
@@ -1161,21 +320,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 +412,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 +574,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 +690,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 +714,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 +791,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 +817,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 +832,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 +1073,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 +1138,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 +1177,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 +1219,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 +1273,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 +1350,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 +1374,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 +1849,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 +1899,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 +1923,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 +2064,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 +2096,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 +2126,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 +2137,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 +2165,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 +2195,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 +2211,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 +2247,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 +2321,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 +2382,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 +2413,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();
       }
@@ -3150,8 +2622,6 @@ ${formatPrompt}`
 };
 
 export {
-  BaseAdapter,
-  LangChainAdapter,
   AcquireActiveMCPServerTool,
   AddMCPServerFromConfigTool,
   ConnectMCPServerTool,
@@ -3160,5 +2630,9 @@ export {
   ServerManager,
   ObservabilityManager,
   RemoteAgent,
+  parseLLMString,
+  createLLMFromString,
+  isValidLLMString,
+  getSupportedProviders,
   MCPAgent
 };