mcp-use 1.7.0-canary.1 → 1.7.0-canary.2

package/dist/{chunk-GVVPUU5K.js → chunk-S6K5QZBJ.js}

@@ -1,3 +1,6 @@
+import {
+  generateUUID
+} from "./chunk-MTHLLDCX.js";
 import {
   logger
 } from "./chunk-34R6SIER.js";
@@ -118,16 +121,703 @@ var BaseAdapter = class {
   }
 };
 
+// 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 { JSONSchemaToZod } from "@dmitryrechkin/json-schema-to-zod";
 import { DynamicStructuredTool } from "@langchain/core/tools";
-import { z } from "zod";
+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 z.any();
+    return z2.any();
   }
 }
 __name(schemaToZod, "schemaToZod");
@@ -145,7 +835,7 @@ var LangChainAdapter = class extends BaseAdapter {
     if (this.disallowedTools.includes(mcpTool.name)) {
       return null;
     }
-    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : z.object({}).optional();
+    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : z2.object({}).optional();
     const tool = new DynamicStructuredTool({
       name: mcpTool.name ?? "NO NAME",
       description: mcpTool.description ?? "",
@@ -172,7 +862,7 @@ var LangChainAdapter = class extends BaseAdapter {
 };
 
 // src/managers/tools/acquire_active_mcp_server.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/managers/tools/base.ts
 import { StructuredTool } from "@langchain/core/tools";
@@ -197,7 +887,7 @@ var MCPServerTool = class extends StructuredTool {
 };
 
 // src/managers/tools/acquire_active_mcp_server.ts
-var PresentActiveServerSchema = z2.object({});
+var PresentActiveServerSchema = z3.object({});
 var AcquireActiveMCPServerTool = class extends MCPServerTool {
   static {
     __name(this, "AcquireActiveMCPServerTool");
@@ -218,16 +908,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 z3 } from "zod";
+import { z as z4 } 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 = z3.object({
-    serverName: z3.string().describe("The name for the new MCP server."),
-    serverConfig: z3.any().describe(
+  schema = z4.object({
+    serverName: z4.string().describe("The name for the new MCP server."),
+    serverConfig: z4.any().describe(
       'The configuration object for the server. This should not include the top-level "mcpServers" key.'
     )
   });
@@ -269,9 +959,9 @@ ${tools.map((t) => t.name).join("\n")}`;
 };
 
 // src/managers/tools/connect_mcp_server.ts
-import { z as z4 } from "zod";
-var ConnectMCPServerSchema = z4.object({
-  serverName: z4.string().describe("The name of the MCP server.")
+import { z as z5 } from "zod";
+var ConnectMCPServerSchema = z5.object({
+  serverName: z5.string().describe("The name of the MCP server.")
 });
 var ConnectMCPServerTool = class extends MCPServerTool {
   static {
@@ -319,8 +1009,8 @@ var ConnectMCPServerTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/list_mcp_servers.ts
-import { z as z5 } from "zod";
-var EnumerateServersSchema = z5.object({});
+import { z as z6 } from "zod";
+var EnumerateServersSchema = z6.object({});
 var ListMCPServersTool = class extends MCPServerTool {
   static {
     __name(this, "ListMCPServersTool");
@@ -357,8 +1047,8 @@ var ListMCPServersTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/release_mcp_server_connection.ts
-import { z as z6 } from "zod";
-var ReleaseConnectionSchema = z6.object({});
+import { z as z7 } from "zod";
+var ReleaseConnectionSchema = z7.object({});
 var ReleaseMCPServerConnectionTool = class extends MCPServerTool {
   static {
     __name(this, "ReleaseMCPServerConnectionTool");
@@ -380,7 +1070,28 @@ var ReleaseMCPServerConnectionTool = class extends MCPServerTool {
 };
 
 // src/managers/server_manager.ts
-import { isEqual } from "lodash-es";
+function isEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => isEqual(item, b[index]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => {
+      return Object.prototype.hasOwnProperty.call(b, key) && isEqual(a[key], b[key]);
+    });
+  }
+  return false;
+}
+__name(isEqual, "isEqual");
 var ServerManager = class {
   static {
     __name(this, "ServerManager");
@@ -531,9 +1242,9 @@ var ObservabilityManager = class {
       return;
     }
     try {
-      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-C4HKZ3NL.js");
+      const { langfuseHandler: langfuseHandler2, langfuseInitPromise: langfuseInitPromise2 } = await import("./langfuse-N5Y5BSXK.js");
       if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
-        const { initializeLangfuse } = await import("./langfuse-C4HKZ3NL.js");
+        const { initializeLangfuse } = await import("./langfuse-N5Y5BSXK.js");
         await initializeLangfuse(
           this.agentId,
           this.metadata,
@@ -694,7 +1405,6 @@ import * as fs2 from "fs";
 import * as os from "os";
 import * as path2 from "path";
 import { PostHog } from "posthog-node";
-import { v4 as uuidv4 } from "uuid";
 
 // src/telemetry/events.ts
 var BaseTelemetryEvent = class {
@@ -957,7 +1667,7 @@ var Telemetry = class _Telemetry {
       if (isFirstTime) {
         logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
         fs2.mkdirSync(path2.dirname(this.USER_ID_PATH), { recursive: true });
-        const newUserId = uuidv4();
+        const newUserId = generateUUID();
         fs2.writeFileSync(this.USER_ID_PATH, newUserId);
         this._currUserId = newUserId;
         logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
@@ -1088,7 +1798,7 @@ function setTelemetrySource(source) {
 __name(setTelemetrySource, "setTelemetrySource");
 
 // src/agents/remote.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { toJSONSchema } from "zod";
 var API_CHATS_ENDPOINT = "/api/v1/chats";
 var API_CHAT_EXECUTE_ENDPOINT = "/api/v1/chats/{chat_id}/execute";
 var RemoteAgent = class {
@@ -1111,7 +1821,7 @@ var RemoteAgent = class {
     this.apiKey = apiKey;
   }
   pydanticToJsonSchema(schema) {
-    return zodToJsonSchema(schema);
+    return toJSONSchema(schema);
   }
   parseStructuredResponse(responseData, outputSchema) {
     let resultData;
@@ -1326,7 +2036,7 @@ import {
   SystemMessage as SystemMessage2,
   ToolMessage
 } from "langchain";
-import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+import { toJSONSchema as toJSONSchema2 } from "zod";
 
 // src/agents/prompts/system_prompt_builder.ts
 import { SystemMessage } from "langchain";
@@ -2408,7 +3118,7 @@ var MCPAgent = class {
    * This method formats and displays tool executions in a user-friendly way with syntax highlighting.
    */
   async *prettyStreamEvents(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
-    const { prettyStreamEvents: prettyStream } = await import("./display-YIYC6WJE.js");
+    const { prettyStreamEvents: prettyStream } = await import("./display-A5IEINAP.js");
     const finalResponse = "";
     for await (const _ of prettyStream(
       this.streamEvents(
@@ -2648,7 +3358,7 @@ var MCPAgent = class {
     let structuredLlm = null;
     let schemaDescription = "";
     logger.debug(
-      `\u{1F504} Structured output requested, schema: ${JSON.stringify(zodToJsonSchema2(outputSchema), null, 2)}`
+      `\u{1F504} Structured output requested, schema: ${JSON.stringify(toJSONSchema2(outputSchema), null, 2)}`
     );
     if (llm && "withStructuredOutput" in llm && typeof llm.withStructuredOutput === "function") {
       structuredLlm = llm.withStructuredOutput(outputSchema);
@@ -2657,7 +3367,7 @@ var MCPAgent = class {
     } else {
       throw new Error("LLM is required for structured output");
     }
-    const jsonSchema = zodToJsonSchema2(outputSchema);
+    const jsonSchema = toJSONSchema2(outputSchema);
     const { $schema, additionalProperties, ...cleanSchema } = jsonSchema;
     schemaDescription = JSON.stringify(cleanSchema, null, 2);
     logger.info(`\u{1F504} Schema description: ${schemaDescription}`);
@@ -2802,7 +3512,7 @@ ${formatPrompt}`
    */
   _enhanceQueryWithSchema(query, outputSchema) {
     try {
-      const jsonSchema = zodToJsonSchema2(outputSchema);
+      const jsonSchema = toJSONSchema2(outputSchema);
       const { $schema, additionalProperties, ...cleanSchema } = jsonSchema;
       const schemaDescription = JSON.stringify(cleanSchema, null, 2);
       const enhancedQuery = `