mcp-use 1.6.3-canary.0 → 1.7.0-canary.2

package/dist/index.cjs

@@ -335,13 +335,13 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       metadataProvider;
       tagsProvider;
       verbose;
-      constructor(config3, agentId2, metadata2, metadataProvider2, tagsProvider2) {
-        super(config3);
+      constructor(config2, agentId2, metadata2, metadataProvider2, tagsProvider2) {
+        super(config2);
         this.agentId = agentId2;
         this.metadata = metadata2;
         this.metadataProvider = metadataProvider2;
         this.tagsProvider = tagsProvider2;
-        this.verbose = config3?.verbose ?? false;
+        this.verbose = config2?.verbose ?? false;
       }
       // Override to add custom metadata to traces
       async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata2, name, kwargs) {
@@ -466,7 +466,7 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
     }
     const initialMetadata = metadata || (metadataProvider ? metadataProvider() : {});
     const initialTags = tagsProvider ? tagsProvider() : [];
-    const config2 = {
+    const config = {
       publicKey: process.env.LANGFUSE_PUBLIC_KEY,
       secretKey: process.env.LANGFUSE_SECRET_KEY,
       baseUrl: process.env.LANGFUSE_HOST || process.env.LANGFUSE_BASEURL || "https://cloud.langfuse.com",
@@ -491,17 +491,17 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       "Langfuse handler config:",
       JSON.stringify(
         {
-          traceName: config2.traceName,
-          sessionId: config2.sessionId,
-          userId: config2.userId,
-          tags: config2.tags
+          traceName: config.traceName,
+          sessionId: config.sessionId,
+          userId: config.userId,
+          tags: config.tags
         },
         null,
         2
       )
     );
     langfuseState.handler = new LoggingCallbackHandler(
-      config2,
+      config,
       agentId,
       metadata,
       metadataProvider,
@@ -528,13 +528,11 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
     logger.debug(`Langfuse initialization error: ${error}`);
   }
 }
-var import_dotenv, langfuseDisabled, langfuseState, langfuseHandler, langfuseClient, langfuseInitPromise;
+var langfuseDisabled, langfuseState, langfuseHandler, langfuseClient, langfuseInitPromise;
 var init_langfuse = __esm({
   "src/observability/langfuse.ts"() {
     "use strict";
-    import_dotenv = require("dotenv");
     init_logging();
-    (0, import_dotenv.config)();
     langfuseDisabled = process.env.MCP_USE_LANGFUSE?.toLowerCase() === "false";
     langfuseState = {
       handler: null,
@@ -573,8 +571,24 @@ __export(display_exports, {
   renderContent: () => renderContent,
   unwrapToolInput: () => unwrapToolInput
 });
+function highlightCode(content, language) {
+  if (!highlight) {
+    return content;
+  }
+  try {
+    return highlight(content, {
+      language: language ?? "javascript",
+      ignoreIllegals: true
+    });
+  } catch {
+    return content;
+  }
+}
 function stripAnsi(str) {
-  return (0, import_strip_ansi.default)(str);
+  if (stripVTControlCharacters) {
+    return stripVTControlCharacters(str);
+  }
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
 }
 function wrapAnsiLine(line, maxWidth) {
   const stripped = stripAnsi(line);
@@ -614,28 +628,28 @@ function printBox(content, title, language, bgColor = false) {
   let displayContent = content;
   if (language) {
     try {
-      displayContent = (0, import_cli_highlight.highlight)(content, { language, ignoreIllegals: true });
+      displayContent = highlightCode(content, language);
     } catch {
     }
   }
   const lines = displayContent.split("\n").flatMap((line) => wrapAnsiLine(line, width - 4));
-  console.log(import_chalk.default.gray("\u250C" + "\u2500".repeat(width - 2) + "\u2510"));
+  console.log(chalkHelper.gray("\u250C" + "\u2500".repeat(width - 2) + "\u2510"));
   if (title) {
     const stripped = stripAnsi(title);
     const lineText = `${title} `;
     const padding = Math.max(0, width - 4 - stripped.length - 2);
     console.log(
-      import_chalk.default.gray("\u2502 ") + import_chalk.default.bold.white(lineText) + " ".repeat(padding) + import_chalk.default.gray(" \u2502")
+      chalkHelper.gray("\u2502 ") + chalkHelper.bold.white(lineText) + " ".repeat(padding) + chalkHelper.gray(" \u2502")
     );
-    console.log(import_chalk.default.gray("\u251C" + "\u2500".repeat(width - 2) + "\u2524"));
+    console.log(chalkHelper.gray("\u251C" + "\u2500".repeat(width - 2) + "\u2524"));
   }
   lines.forEach((line) => {
     const stripped = stripAnsi(line);
     const padding = Math.max(0, width - 4 - stripped.length);
-    const finalLine = bgColor ? import_chalk.default.bgGray(line + " ".repeat(padding)) : line + " ".repeat(padding);
-    console.log(import_chalk.default.gray("\u2502 ") + finalLine + import_chalk.default.gray(" \u2502"));
+    const finalLine = bgColor ? chalkHelper.bgGray(line + " ".repeat(padding)) : line + " ".repeat(padding);
+    console.log(chalkHelper.gray("\u2502 ") + finalLine + chalkHelper.gray(" \u2502"));
   });
-  console.log(import_chalk.default.gray("\u2514" + "\u2500".repeat(width - 2) + "\u2518"));
+  console.log(chalkHelper.gray("\u2514" + "\u2500".repeat(width - 2) + "\u2518"));
 }
 function extractCodeFromToolInput(input) {
   if (typeof input === "object" && input !== null && "code" in input) {
@@ -774,7 +788,7 @@ ${noResultsMsg}`;
     const isLastServer = i === servers.length - 1;
     const serverPrefix = isLastServer ? "\u2514\u2500" : "\u251C\u2500";
     lines.push(
-      `${serverPrefix} ${import_chalk.default.cyan(server)} (${serverTools.length} tools)`
+      `${serverPrefix} ${chalkHelper.cyan(server)} (${serverTools.length} tools)`
     );
     for (let j = 0; j < serverTools.length; j++) {
       const tool = serverTools[j];
@@ -806,7 +820,7 @@ ${noResultsMsg}`;
           wrappedLines.push(currentLine.trimEnd());
         }
         for (const descLine of wrappedLines) {
-          lines.push(`${descriptionIndent}${import_chalk.default.dim(descLine)}`);
+          lines.push(`${descriptionIndent}${chalkHelper.dim(descLine)}`);
         }
       }
     }
@@ -833,7 +847,7 @@ function handleToolEnd(event) {
         const timeMs = execResult2.execution_time ? Math.round(execResult2.execution_time * 1e3) : 0;
         const timeStr = `${timeMs}ms`;
         const isError2 = execResult2.error !== null && execResult2.error !== void 0 && execResult2.error !== "";
-        const statusText = isError2 ? import_chalk.default.red("error") : import_chalk.default.green("success");
+        const statusText = isError2 ? chalkHelper.red("error") : chalkHelper.green("success");
         const title2 = `${toolName} - ${statusText} - ${timeStr}`;
         if (execResult2.result !== null && execResult2.result !== void 0) {
           const resultStr = renderContent(execResult2.result);
@@ -846,7 +860,12 @@ function handleToolEnd(event) {
           printBox(execResult2.logs.join("\n"), `Logs`, void 0, false);
         }
         if (execResult2.error) {
-          printBox(execResult2.error, import_chalk.default.red("Error"), void 0, false);
+          printBox(
+            execResult2.error,
+            chalkHelper.red("Error"),
+            void 0,
+            false
+          );
         }
         return;
       }
@@ -872,7 +891,7 @@ function handleToolEnd(event) {
         const contentWithMeta = actualContent;
         const meta = contentWithMeta.meta;
         const treeStr = formatSearchToolsAsTree(results, meta, query);
-        const statusText = status === "success" ? import_chalk.default.green("Success") : import_chalk.default.red("Error");
+        const statusText = status === "success" ? chalk.green("Success") : chalk.red("Error");
         const title2 = `${statusText}: ${toolName} - Result`;
         printBox(treeStr, title2, void 0, false);
         return;
@@ -883,7 +902,7 @@ function handleToolEnd(event) {
           void 0,
           query
         );
-        const statusText = status === "success" ? import_chalk.default.green("Success") : import_chalk.default.red("Error");
+        const statusText = status === "success" ? chalk.green("Success") : chalk.red("Error");
         const title2 = `${statusText}: ${toolName} - Result`;
         printBox(treeStr, title2, void 0, false);
         return;
@@ -902,7 +921,7 @@ function handleToolEnd(event) {
     }
     const contentStr = renderContent(displayContent);
     const language2 = typeof displayContent === "object" ? "json" : void 0;
-    const statusLabel = status === "success" ? import_chalk.default.green("Success") : isError ? import_chalk.default.red("Error") : "Result";
+    const statusLabel = status === "success" ? chalkHelper.green("Success") : isError ? chalkHelper.red("Error") : "Result";
     const title = `${statusLabel}: ${toolName} - Result`;
     printBox(contentStr, title, language2, false);
     return;
@@ -920,7 +939,7 @@ function handleToolEnd(event) {
       printBox(execResult.logs.join("\n"), `Logs`, void 0, false);
     }
     if (execResult.error) {
-      printBox(execResult.error, import_chalk.default.red("Error"), void 0, false);
+      printBox(execResult.error, chalkHelper.red("Error"), void 0, false);
     }
     return;
   }
@@ -960,14 +979,55 @@ async function* prettyStreamEvents(streamEventsGenerator) {
   }
   return finalResponse;
 }
-var import_chalk, import_cli_highlight, import_strip_ansi, TERMINAL_WIDTH;
+var chalk, highlight, stripVTControlCharacters, displayPackagesWarned, isNode, TERMINAL_WIDTH, chalkHelper;
 var init_display = __esm({
   "src/agents/display.ts"() {
     "use strict";
-    import_chalk = __toESM(require("chalk"), 1);
-    import_cli_highlight = require("cli-highlight");
-    import_strip_ansi = __toESM(require("strip-ansi"), 1);
+    chalk = null;
+    highlight = null;
+    stripVTControlCharacters = null;
+    displayPackagesWarned = false;
+    isNode = typeof process !== "undefined" && process.versions?.node;
+    (async () => {
+      if (isNode) {
+        try {
+          const utilModule = await import("util");
+          stripVTControlCharacters = utilModule.stripVTControlCharacters;
+        } catch {
+        }
+      }
+      try {
+        const chalkModule = await import("chalk");
+        chalk = chalkModule.default;
+      } catch {
+      }
+      try {
+        const cliHighlightModule = await import("cli-highlight");
+        highlight = cliHighlightModule.highlight;
+      } catch {
+      }
+      if (isNode && (!chalk || !highlight)) {
+        if (!displayPackagesWarned) {
+          displayPackagesWarned = true;
+          console.warn(
+            "\n\u2728 For enhanced console output with colors and syntax highlighting, install:\n\n  npm install chalk cli-highlight\n  # or\n  pnpm add chalk cli-highlight\n"
+          );
+        }
+      }
+    })();
     TERMINAL_WIDTH = process.stdout.columns || 120;
+    chalkHelper = {
+      gray: /* @__PURE__ */ __name((str) => chalk?.gray(str) ?? str, "gray"),
+      bold: {
+        white: /* @__PURE__ */ __name((str) => chalk?.bold?.white(str) ?? str, "white")
+      },
+      bgGray: /* @__PURE__ */ __name((str) => chalk?.bgGray(str) ?? str, "bgGray"),
+      cyan: /* @__PURE__ */ __name((str) => chalk?.cyan(str) ?? str, "cyan"),
+      dim: /* @__PURE__ */ __name((str) => chalk?.dim(str) ?? str, "dim"),
+      red: /* @__PURE__ */ __name((str) => chalk?.red(str) ?? str, "red"),
+      green: /* @__PURE__ */ __name((str) => chalk?.green(str) ?? str, "green")
+    };
+    __name(highlightCode, "highlightCode");
     __name(stripAnsi, "stripAnsi");
     __name(wrapAnsiLine, "wrapAnsiLine");
     __name(printBox, "printBox");
@@ -1037,12 +1097,699 @@ module.exports = __toCommonJS(index_exports);
 
 // src/agents/mcp_agent.ts
 var import_langchain2 = require("langchain");
-var import_zod_to_json_schema2 = require("zod-to-json-schema");
+var import_zod9 = require("zod");
+
+// src/utils/json-schema-to-zod/JSONSchemaToZod.ts
+var import_zod = require("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: import_zod.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: import_zod.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: import_zod.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 import_zod.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 import_zod.z.any();
+    }
+    switch (schema.type) {
+      case "string":
+        return this.parseString(schema);
+      case "number":
+      case "integer":
+        return this.parseNumberSchema(schema);
+      case "boolean":
+        return import_zod.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 = import_zod.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 = import_zod.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 import_zod.z.union(tupleSchemas);
+    }
+    const itemSchema = schema.items ? this.parseSchema(schema.items) : import_zod.z.any();
+    const arraySchema = import_zod.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, import_zod.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 = import_zod.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 import_zod.z.any();
+    }
+    if (schemas.length === 1) {
+      return this.parseSchema(schemas[0]);
+    }
+    const zodSchemas = [];
+    for (const subSchema of schemas) {
+      if (subSchema.type === "null") {
+        zodSchemas.push(import_zod.z.null());
+      } else {
+        zodSchemas.push(this.parseSchema(subSchema));
+      }
+    }
+    if (zodSchemas.length >= 2) {
+      return import_zod.z.union(zodSchemas);
+    } else if (zodSchemas.length === 1) {
+      return zodSchemas[0];
+    }
+    return import_zod.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 import_zod.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
-var import_json_schema_to_zod = require("@dmitryrechkin/json-schema-to-zod");
 var import_tools = require("@langchain/core/tools");
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 init_logging();
 
 // src/adapters/base.ts
@@ -1162,10 +1909,10 @@ var BaseAdapter = class {
 // src/adapters/langchain_adapter.ts
 function schemaToZod(schema) {
   try {
-    return import_json_schema_to_zod.JSONSchemaToZod.convert(schema);
+    return JSONSchemaToZod.convert(schema);
   } catch (err) {
     logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
-    return import_zod.z.any();
+    return import_zod2.z.any();
   }
 }
 __name(schemaToZod, "schemaToZod");
@@ -1183,7 +1930,7 @@ var LangChainAdapter = class extends BaseAdapter {
     if (this.disallowedTools.includes(mcpTool.name)) {
       return null;
     }
-    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : import_zod.z.object({}).optional();
+    const argsSchema = mcpTool.inputSchema ? schemaToZod(mcpTool.inputSchema) : import_zod2.z.object({}).optional();
     const tool = new import_tools.DynamicStructuredTool({
       name: mcpTool.name ?? "NO NAME",
       description: mcpTool.description ?? "",
@@ -1213,11 +1960,10 @@ var LangChainAdapter = class extends BaseAdapter {
 init_logging();
 
 // src/managers/server_manager.ts
-var import_lodash_es = require("lodash-es");
 init_logging();
 
 // src/managers/tools/acquire_active_mcp_server.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/managers/tools/base.ts
 var import_tools2 = require("@langchain/core/tools");
@@ -1242,7 +1988,7 @@ var MCPServerTool = class extends import_tools2.StructuredTool {
 };
 
 // src/managers/tools/acquire_active_mcp_server.ts
-var PresentActiveServerSchema = import_zod2.z.object({});
+var PresentActiveServerSchema = import_zod3.z.object({});
 var AcquireActiveMCPServerTool = class extends MCPServerTool {
   static {
     __name(this, "AcquireActiveMCPServerTool");
@@ -1263,7 +2009,7 @@ var AcquireActiveMCPServerTool = class extends MCPServerTool {
 
 // src/managers/tools/add_server_from_config.ts
 var import_tools3 = require("@langchain/core/tools");
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 init_logging();
 var AddMCPServerFromConfigTool = class extends import_tools3.StructuredTool {
   static {
@@ -1271,9 +2017,9 @@ var AddMCPServerFromConfigTool = class extends import_tools3.StructuredTool {
   }
   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 = import_zod3.z.object({
-    serverName: import_zod3.z.string().describe("The name for the new MCP server."),
-    serverConfig: import_zod3.z.any().describe(
+  schema = import_zod4.z.object({
+    serverName: import_zod4.z.string().describe("The name for the new MCP server."),
+    serverConfig: import_zod4.z.any().describe(
       'The configuration object for the server. This should not include the top-level "mcpServers" key.'
     )
   });
@@ -1315,10 +2061,10 @@ ${tools.map((t) => t.name).join("\n")}`;
 };
 
 // src/managers/tools/connect_mcp_server.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 init_logging();
-var ConnectMCPServerSchema = import_zod4.z.object({
-  serverName: import_zod4.z.string().describe("The name of the MCP server.")
+var ConnectMCPServerSchema = import_zod5.z.object({
+  serverName: import_zod5.z.string().describe("The name of the MCP server.")
 });
 var ConnectMCPServerTool = class extends MCPServerTool {
   static {
@@ -1366,9 +2112,9 @@ var ConnectMCPServerTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/list_mcp_servers.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 init_logging();
-var EnumerateServersSchema = import_zod5.z.object({});
+var EnumerateServersSchema = import_zod6.z.object({});
 var ListMCPServersTool = class extends MCPServerTool {
   static {
     __name(this, "ListMCPServersTool");
@@ -1405,8 +2151,8 @@ var ListMCPServersTool = class extends MCPServerTool {
 };
 
 // src/managers/tools/release_mcp_server_connection.ts
-var import_zod6 = require("zod");
-var ReleaseConnectionSchema = import_zod6.z.object({});
+var import_zod7 = require("zod");
+var ReleaseConnectionSchema = import_zod7.z.object({});
 var ReleaseMCPServerConnectionTool = class extends MCPServerTool {
   static {
     __name(this, "ReleaseMCPServerConnectionTool");
@@ -1428,6 +2174,28 @@ var ReleaseMCPServerConnectionTool = class extends MCPServerTool {
 };
 
 // src/managers/server_manager.ts
+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");
@@ -1504,7 +2272,7 @@ var ServerManager = class {
             continue;
           }
           const cachedTools = this.serverTools[serverName];
-          const toolsChanged = !cachedTools || !(0, import_lodash_es.isEqual)(cachedTools, tools);
+          const toolsChanged = !cachedTools || !isEqual(cachedTools, tools);
           if (toolsChanged) {
             this.serverTools[serverName] = tools;
             this.initializedServers[serverName] = true;
@@ -1566,14 +2334,14 @@ var ObservabilityManager = class {
   metadata;
   metadataProvider;
   tagsProvider;
-  constructor(config2 = {}) {
-    this.customCallbacks = config2.customCallbacks;
-    this.verbose = config2.verbose ?? false;
-    this.observe = config2.observe ?? true;
-    this.agentId = config2.agentId;
-    this.metadata = config2.metadata;
-    this.metadataProvider = config2.metadataProvider;
-    this.tagsProvider = config2.tagsProvider;
+  constructor(config = {}) {
+    this.customCallbacks = config.customCallbacks;
+    this.verbose = config.verbose ?? false;
+    this.observe = config.observe ?? true;
+    this.agentId = config.agentId;
+    this.metadata = config.metadata;
+    this.metadataProvider = config.metadataProvider;
+    this.tagsProvider = config.tagsProvider;
   }
   /**
    * Collect all available observability handlers from configured platforms.
@@ -1746,7 +2514,15 @@ var fs2 = __toESM(require("fs"), 1);
 var os = __toESM(require("os"), 1);
 var path2 = __toESM(require("path"), 1);
 var import_posthog_node = require("posthog-node");
-var import_uuid = require("uuid");
+
+// src/server/utils/runtime.ts
+var isDeno = typeof globalThis.Deno !== "undefined";
+function generateUUID() {
+  return globalThis.crypto.randomUUID();
+}
+__name(generateUUID, "generateUUID");
+
+// src/telemetry/telemetry.ts
 init_logging();
 
 // src/telemetry/events.ts
@@ -2010,7 +2786,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 = (0, import_uuid.v4)();
+        const newUserId = generateUUID();
         fs2.writeFileSync(this.USER_ID_PATH, newUserId);
         this._currUserId = newUserId;
         logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
@@ -2232,7 +3008,7 @@ Here are the tools *currently* available to you (this list includes server manag
 `;
 
 // src/agents/remote.ts
-var import_zod_to_json_schema = require("zod-to-json-schema");
+var import_zod8 = require("zod");
 init_logging();
 var API_CHATS_ENDPOINT = "/api/v1/chats";
 var API_CHAT_EXECUTE_ENDPOINT = "/api/v1/chats/{chat_id}/execute";
@@ -2256,7 +3032,7 @@ var RemoteAgent = class {
     this.apiKey = apiKey;
   }
   pydanticToJsonSchema(schema) {
-    return (0, import_zod_to_json_schema.zodToJsonSchema)(schema);
+    return (0, import_zod8.toJSONSchema)(schema);
   }
   parseStructuredResponse(responseData, outputSchema) {
     let resultData;
@@ -2858,24 +3634,24 @@ var MCPAgent = class {
         const serverConfigs = {};
         for (const serverName of serverNames) {
           try {
-            const config2 = this.client.getServerConfig(serverName);
-            if (config2) {
+            const config = this.client.getServerConfig(serverName);
+            if (config) {
               let serverType = "unknown";
-              if (config2.command) {
+              if (config.command) {
                 serverType = "command";
-              } else if (config2.url) {
+              } else if (config.url) {
                 serverType = "http";
-              } else if (config2.ws_url) {
+              } else if (config.ws_url) {
                 serverType = "websocket";
               }
               serverConfigs[serverName] = {
                 type: serverType,
                 // Include safe configuration details (avoid sensitive data)
-                has_args: !!config2.args,
-                has_env: !!config2.env,
-                has_headers: !!config2.headers,
-                url: config2.url || null,
-                command: config2.command || null
+                has_args: !!config.args,
+                has_env: !!config.env,
+                has_headers: !!config.headers,
+                url: config.url || null,
+                command: config.command || null
               };
             }
           } catch (error) {
@@ -3691,7 +4467,7 @@ var MCPAgent = class {
     let structuredLlm = null;
     let schemaDescription = "";
     logger.debug(
-      `\u{1F504} Structured output requested, schema: ${JSON.stringify((0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema), null, 2)}`
+      `\u{1F504} Structured output requested, schema: ${JSON.stringify((0, import_zod9.toJSONSchema)(outputSchema), null, 2)}`
     );
     if (llm && "withStructuredOutput" in llm && typeof llm.withStructuredOutput === "function") {
       structuredLlm = llm.withStructuredOutput(outputSchema);
@@ -3700,7 +4476,7 @@ var MCPAgent = class {
     } else {
       throw new Error("LLM is required for structured output");
     }
-    const jsonSchema = (0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema);
+    const jsonSchema = (0, import_zod9.toJSONSchema)(outputSchema);
     const { $schema, additionalProperties, ...cleanSchema } = jsonSchema;
     schemaDescription = JSON.stringify(cleanSchema, null, 2);
     logger.info(`\u{1F504} Schema description: ${schemaDescription}`);
@@ -3845,7 +4621,7 @@ ${formatPrompt}`
    */
   _enhanceQueryWithSchema(query, outputSchema) {
     try {
-      const jsonSchema = (0, import_zod_to_json_schema2.zodToJsonSchema)(outputSchema);
+      const jsonSchema = (0, import_zod9.toJSONSchema)(outputSchema);
       const { $schema, additionalProperties, ...cleanSchema } = jsonSchema;
       const schemaDescription = JSON.stringify(cleanSchema, null, 2);
       const enhancedQuery = `
@@ -3954,9 +4730,9 @@ var BaseMCPClient = class {
   config = {};
   sessions = {};
   activeSessions = [];
-  constructor(config2) {
-    if (config2) {
-      this.config = config2;
+  constructor(config) {
+    if (config) {
+      this.config = config;
     }
   }
   static fromDict(_cfg) {
@@ -5645,6 +6421,7 @@ var HttpConnector = class extends BaseConnector {
         stop: /* @__PURE__ */ __name(async () => {
           if (this.streamableTransport) {
             try {
+              await this.streamableTransport.terminateSession();
               await this.streamableTransport.close();
             } catch (e) {
               logger.warn(`Error closing Streamable HTTP transport: ${e}`);
@@ -5669,6 +6446,8 @@ var HttpConnector = class extends BaseConnector {
   async connectWithSse(baseUrl) {
     try {
       this.connectionManager = new SseConnectionManager(baseUrl, {
+        authProvider: this.opts.authProvider,
+        // ← Pass OAuth provider to SDK (same as streamable HTTP)
         requestInit: {
           headers: this.headers
         }
@@ -5870,7 +6649,6 @@ var StdioConnector = class extends BaseConnector {
 };
 
 // src/connectors/websocket.ts
-var import_uuid2 = require("uuid");
 init_logging();
 
 // src/task_managers/websocket.ts
@@ -5992,7 +6770,7 @@ var WebSocketConnector = class extends BaseConnector {
   }
   sendRequest(method, params = null) {
     if (!this.ws) throw new Error("WebSocket is not connected");
-    const id = (0, import_uuid2.v4)();
+    const id = generateUUID();
     const payload = JSON.stringify({ id, method, params: params ?? {} });
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject });
@@ -6195,12 +6973,12 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
   _codeExecutorConfig = "vm";
   _executorOptions;
   _samplingCallback;
-  constructor(config2, options) {
-    if (config2) {
-      if (typeof config2 === "string") {
-        super(loadConfigFile(config2));
+  constructor(config, options) {
+    if (config) {
+      if (typeof config === "string") {
+        super(loadConfigFile(config));
       } else {
-        super(config2);
+        super(config);
       }
     } else {
       super();
@@ -6259,15 +7037,15 @@ var MCPClient = class _MCPClient extends BaseMCPClient {
   }
   _ensureCodeExecutor() {
     if (!this._codeExecutor) {
-      const config2 = this._codeExecutorConfig;
-      if (config2 instanceof BaseCodeExecutor) {
-        this._codeExecutor = config2;
-      } else if (typeof config2 === "function") {
-        this._customCodeExecutor = config2;
+      const config = this._codeExecutorConfig;
+      if (config instanceof BaseCodeExecutor) {
+        this._codeExecutor = config;
+      } else if (typeof config === "function") {
+        this._customCodeExecutor = config;
         throw new Error(
           "Custom executor function should be handled in executeCode"
         );
-      } else if (config2 === "e2b") {
+      } else if (config === "e2b") {
         const opts = this._executorOptions;
         if (!opts?.apiKey) {
           logger.warn("E2B executor requires apiKey. Falling back to VM.");
@@ -6424,8 +7202,8 @@ var OAuthHelper = class {
   discovery;
   state;
   clientRegistration;
-  constructor(config2) {
-    this.config = config2;
+  constructor(config) {
+    this.config = config;
     this.state = {
       isRequired: false,
       isAuthenticated: false,
@@ -6820,8 +7598,33 @@ function createOAuthMCPConfig(serverUrl, accessToken) {
 }
 __name(createOAuthMCPConfig, "createOAuthMCPConfig");
 
+// src/utils/url-sanitize.ts
+function sanitizeUrl(raw) {
+  const abort = /* @__PURE__ */ __name(() => {
+    throw new Error(`Invalid url to pass to open(): ${raw}`);
+  }, "abort");
+  let url;
+  try {
+    url = new URL(raw);
+  } catch (_) {
+    abort();
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") abort();
+  if (url.hostname !== encodeURIComponent(url.hostname)) abort();
+  if (url.username) url.username = encodeURIComponent(url.username);
+  if (url.password) url.password = encodeURIComponent(url.password);
+  url.pathname = url.pathname.slice(0, 1) + encodeURIComponent(url.pathname.slice(1)).replace(/%2f/gi, "/");
+  url.search = url.search.slice(0, 1) + Array.from(url.searchParams.entries()).map(sanitizeParam).join("&");
+  url.hash = url.hash.slice(0, 1) + encodeURIComponent(url.hash.slice(1));
+  return url.href;
+}
+__name(sanitizeUrl, "sanitizeUrl");
+function sanitizeParam([k, v]) {
+  return `${encodeURIComponent(k)}${v.length > 0 ? `=${encodeURIComponent(v)}` : ""}`;
+}
+__name(sanitizeParam, "sanitizeParam");
+
 // src/auth/browser-provider.ts
-var import_strict_url_sanitise = require("strict-url-sanitise");
 var BrowserOAuthClientProvider = class {
   static {
     __name(this, "BrowserOAuthClientProvider");
@@ -6833,6 +7636,7 @@ var BrowserOAuthClientProvider = class {
   clientUri;
   callbackUrl;
   preventAutoAuth;
+  useRedirectFlow;
   onPopupWindow;
   constructor(serverUrl, options = {}) {
     this.serverUrl = serverUrl;
@@ -6840,15 +7644,16 @@ var BrowserOAuthClientProvider = class {
     this.serverUrlHash = this.hashString(serverUrl);
     this.clientName = options.clientName || "mcp-use";
     this.clientUri = options.clientUri || (typeof window !== "undefined" ? window.location.origin : "");
-    this.callbackUrl = (0, import_strict_url_sanitise.sanitizeUrl)(
+    this.callbackUrl = sanitizeUrl(
       options.callbackUrl || (typeof window !== "undefined" ? new URL("/oauth/callback", window.location.origin).toString() : "/oauth/callback")
     );
     this.preventAutoAuth = options.preventAutoAuth;
+    this.useRedirectFlow = options.useRedirectFlow;
     this.onPopupWindow = options.onPopupWindow;
   }
   // --- SDK Interface Methods ---
   get redirectUrl() {
-    return (0, import_strict_url_sanitise.sanitizeUrl)(this.callbackUrl);
+    return sanitizeUrl(this.callbackUrl);
   }
   get clientMetadata() {
     return {
@@ -6935,12 +7740,16 @@ var BrowserOAuthClientProvider = class {
         clientName: this.clientName,
         clientUri: this.clientUri,
         callbackUrl: this.callbackUrl
-      }
+      },
+      // Store flow type so callback knows how to handle the response
+      flowType: this.useRedirectFlow ? "redirect" : "popup",
+      // Store current URL for redirect flow so we can return to it
+      returnUrl: this.useRedirectFlow && typeof window !== "undefined" ? window.location.href : void 0
     };
     localStorage.setItem(stateKey, JSON.stringify(stateData));
     authorizationUrl.searchParams.set("state", state);
     const authUrlString = authorizationUrl.toString();
-    const sanitizedAuthUrl = (0, import_strict_url_sanitise.sanitizeUrl)(authUrlString);
+    const sanitizedAuthUrl = sanitizeUrl(authUrlString);
     localStorage.setItem(this.getKey("last_auth_url"), sanitizedAuthUrl);
     return sanitizedAuthUrl;
   }
@@ -6950,8 +7759,20 @@ var BrowserOAuthClientProvider = class {
    * @param authorizationUrl The fully constructed authorization URL from the SDK.
    */
   async redirectToAuthorization(authorizationUrl) {
-    if (this.preventAutoAuth) return;
     const sanitizedAuthUrl = await this.prepareAuthorizationUrl(authorizationUrl);
+    if (this.preventAutoAuth) {
+      console.info(
+        `[${this.storageKeyPrefix}] Auto-auth prevented. Authorization URL stored for manual trigger.`
+      );
+      return;
+    }
+    if (this.useRedirectFlow) {
+      console.info(
+        `[${this.storageKeyPrefix}] Redirecting to authorization URL (full-page redirect).`
+      );
+      window.location.href = sanitizedAuthUrl;
+      return;
+    }
     const popupFeatures = "width=600,height=700,resizable=yes,scrollbars=yes,status=yes";
     try {
       const popup = window.open(
@@ -6985,7 +7806,7 @@ var BrowserOAuthClientProvider = class {
    */
   getLastAttemptedAuthUrl() {
     const storedUrl = localStorage.getItem(this.getKey("last_auth_url"));
-    return storedUrl ? (0, import_strict_url_sanitise.sanitizeUrl)(storedUrl) : null;
+    return storedUrl ? sanitizeUrl(storedUrl) : null;
   }
   clearStorage() {
     const prefixPattern = `${this.storageKeyPrefix}_${this.serverUrlHash}_`;
@@ -7101,24 +7922,31 @@ async function onMcpAuthorization() {
       authorizationCode: code
     });
     if (authResult === "AUTHORIZED") {
-      console.log(
-        `${logPrefix} Authorization successful via SDK auth(). Notifying opener...`
-      );
-      if (window.opener && !window.opener.closed) {
+      console.log(`${logPrefix} Authorization successful via SDK auth().`);
+      const isRedirectFlow = storedStateData.flowType === "redirect";
+      if (isRedirectFlow && storedStateData.returnUrl) {
+        console.log(
+          `${logPrefix} Redirect flow complete. Returning to: ${storedStateData.returnUrl}`
+        );
+        localStorage.removeItem(stateKey);
+        window.location.href = storedStateData.returnUrl;
+      } else if (window.opener && !window.opener.closed) {
+        console.log(`${logPrefix} Popup flow complete. Notifying opener...`);
         window.opener.postMessage(
           { type: "mcp_auth_callback", success: true },
           window.location.origin
         );
+        localStorage.removeItem(stateKey);
         window.close();
       } else {
         console.warn(
-          `${logPrefix} No opener window detected. Redirecting to root.`
+          `${logPrefix} No opener window or return URL detected. Redirecting to root.`
         );
+        localStorage.removeItem(stateKey);
         const pathParts = window.location.pathname.split("/").filter(Boolean);
         const basePath = pathParts.length > 0 && pathParts[pathParts.length - 1] === "callback" ? "/" + pathParts.slice(0, -2).join("/") : "/";
         window.location.href = basePath || "/";
       }
-      localStorage.removeItem(stateKey);
     } else {
       console.warn(
         `${logPrefix} SDK auth() returned unexpected status: ${authResult}`
@@ -7166,15 +7994,14 @@ __name(onMcpAuthorization, "onMcpAuthorization");
 
 // src/react/useMcp.ts
 var import_react = require("react");
-var import_strict_url_sanitise2 = require("strict-url-sanitise");
 
 // src/client/browser.ts
 var BrowserMCPClient = class _BrowserMCPClient extends BaseMCPClient {
   static {
     __name(this, "BrowserMCPClient");
   }
-  constructor(config2) {
-    super(config2);
+  constructor(config) {
+    super(config);
   }
   static fromDict(cfg) {
     return new _BrowserMCPClient(cfg);
@@ -7240,14 +8067,13 @@ __name(assert, "assert");
 // src/react/useMcp.ts
 var DEFAULT_RECONNECT_DELAY = 3e3;
 var DEFAULT_RETRY_DELAY = 5e3;
-var AUTH_TIMEOUT = 5 * 60 * 1e3;
 function useMcp(options) {
   const {
     url,
     enabled = true,
     clientName,
     clientUri,
-    callbackUrl = typeof window !== "undefined" ? (0, import_strict_url_sanitise2.sanitizeUrl)(
+    callbackUrl = typeof window !== "undefined" ? sanitizeUrl(
       new URL("/oauth/callback", window.location.origin).toString()
     ) : "/oauth/callback",
     storageKeyPrefix = "mcp:auth",
@@ -7258,6 +8084,9 @@ function useMcp(options) {
     autoReconnect = DEFAULT_RECONNECT_DELAY,
     transportType = "auto",
     preventAutoAuth = false,
+    // Default to false for backward compatibility (auto-trigger OAuth)
+    useRedirectFlow = false,
+    // Default to false for backward compatibility (use popup)
     onPopupWindow,
     timeout = 3e4,
     // 30 seconds default for connection timeout
@@ -7383,6 +8212,7 @@ function useMcp(options) {
         clientUri,
         callbackUrl,
         preventAutoAuth,
+        useRedirectFlow,
         onPopupWindow
       });
       addLog("debug", "BrowserOAuthClientProvider initialized in connect.");
@@ -7473,6 +8303,42 @@ function useMcp(options) {
       } catch (err) {
         const errorMessage = err?.message || String(err);
         if (err.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+          if (authProviderRef.current) {
+            addLog(
+              "info",
+              "Authentication required. OAuth provider available."
+            );
+            try {
+              const { auth: auth2 } = await import("@modelcontextprotocol/sdk/client/auth.js");
+              const baseUrl = new URL(url).origin;
+              auth2(authProviderRef.current, { serverUrl: baseUrl }).catch(
+                () => {
+                }
+              );
+              setTimeout(() => {
+                if (isMountedRef.current) {
+                  const manualUrl = authProviderRef.current?.getLastAttemptedAuthUrl();
+                  if (manualUrl) {
+                    setAuthUrl(manualUrl);
+                    addLog(
+                      "info",
+                      "Manual authentication URL available:",
+                      manualUrl
+                    );
+                  } else {
+                    addLog("warn", "Could not generate authentication URL");
+                  }
+                }
+              }, 100);
+            } catch (authGenError) {
+              addLog("warn", "Error generating auth URL:", authGenError);
+            }
+            if (isMountedRef.current) {
+              setState("pending_auth");
+            }
+            connectingRef.current = false;
+            return "auth_redirect";
+          }
           if (customHeaders && Object.keys(customHeaders).length > 0) {
             failConnection(
               "Authentication failed: Server returned 401 Unauthorized. Check your Authorization header value is correct."
@@ -7524,6 +8390,7 @@ function useMcp(options) {
     customHeaders,
     transportType,
     preventAutoAuth,
+    useRedirectFlow,
     onPopupWindow,
     enabled,
     timeout,
@@ -7576,32 +8443,54 @@ function useMcp(options) {
       retry();
     } else if (currentState === "pending_auth") {
       addLog("info", "Proceeding with authentication from pending state...");
-      setState("authenticating");
-      if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-      authTimeoutRef.current = setTimeout(() => {
-        if (isMountedRef.current) {
-          const currentStateValue = stateRef.current;
-          if (currentStateValue === "authenticating") {
-            failConnection("Authentication timed out. Please try again.");
-          }
-        }
-      }, AUTH_TIMEOUT);
       try {
         assert(
           authProviderRef.current,
           "Auth Provider not available for manual auth"
         );
         assert(url, "Server URL is required for authentication");
-        addLog(
-          "info",
-          "Redirecting for manual authentication. Waiting for callback..."
-        );
+        addLog("info", "Clearing all OAuth state and initiating fresh flow...");
+        const hashPrefix = `${storageKeyPrefix}:${authProviderRef.current.serverUrlHash}`;
+        Object.keys(localStorage).forEach((key) => {
+          if (key.startsWith(hashPrefix)) {
+            addLog("debug", `Removing stale OAuth key: ${key}`);
+            localStorage.removeItem(key);
+          }
+          if (key.startsWith(`${storageKeyPrefix}:state_`)) {
+            addLog("debug", `Removing orphaned state: ${key}`);
+            localStorage.removeItem(key);
+          }
+        });
+        setState("authenticating");
+        const freshAuthProvider = new BrowserOAuthClientProvider(url, {
+          storageKeyPrefix,
+          clientName,
+          clientUri,
+          callbackUrl,
+          preventAutoAuth: false,
+          // ← Allow OAuth to proceed
+          useRedirectFlow,
+          onPopupWindow
+        });
+        authProviderRef.current = freshAuthProvider;
+        addLog("info", "Triggering fresh OAuth authorization...");
+        const { auth: auth2 } = await import("@modelcontextprotocol/sdk/client/auth.js");
+        const baseUrl = new URL(url).origin;
+        auth2(freshAuthProvider, {
+          serverUrl: baseUrl
+        }).catch((err) => {
+          addLog(
+            "info",
+            "OAuth flow initiated:",
+            err?.message || "Redirecting..."
+          );
+        });
       } catch (authError) {
         if (!isMountedRef.current) return;
-        if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-        failConnection(
-          `Manual authentication failed: ${authError instanceof Error ? authError.message : String(authError)}`,
-          authError instanceof Error ? authError : void 0
+        setState("pending_auth");
+        addLog(
+          "error",
+          `Manual authentication failed: ${authError instanceof Error ? authError.message : String(authError)}`
         );
       }
     } else if (currentState === "authenticating") {
@@ -7620,7 +8509,18 @@ function useMcp(options) {
         `Client not in a state requiring manual authentication trigger (state: ${currentState}). If needed, try disconnecting and reconnecting.`
       );
     }
-  }, [addLog, retry, authUrl, url, failConnection, connect]);
+  }, [
+    addLog,
+    retry,
+    authUrl,
+    url,
+    useRedirectFlow,
+    onPopupWindow,
+    storageKeyPrefix,
+    clientName,
+    clientUri,
+    callbackUrl
+  ]);
   const clearStorage = (0, import_react.useCallback)(() => {
     if (authProviderRef.current) {
       const count = authProviderRef.current.clearStorage();
@@ -7791,6 +8691,7 @@ function useMcp(options) {
         clientUri,
         callbackUrl,
         preventAutoAuth,
+        useRedirectFlow,
         onPopupWindow
       });
       addLog(
@@ -7812,7 +8713,8 @@ function useMcp(options) {
     clientName,
     clientUri,
     clientConfig.name,
-    clientConfig.version
+    clientConfig.version,
+    useRedirectFlow
   ]);
   (0, import_react.useEffect)(() => {
     let retryTimeoutId = null;
@@ -8627,7 +9529,18 @@ __name(WidgetControls, "WidgetControls");
 
 // src/react/McpUseProvider.tsx
 var import_react7 = __toESM(require("react"), 1);
-var import_react_router_dom = require("react-router-dom");
+var BrowserRouter = null;
+var routerError = null;
+(async () => {
+  try {
+    const routerModule = await import("react-router-dom");
+    BrowserRouter = routerModule.BrowserRouter;
+  } catch (error) {
+    routerError = new Error(
+      "\u274C react-router-dom not installed!\n\nTo use MCP widgets with McpUseProvider, you need to install:\n\n  npm install react-router-dom\n  # or\n  pnpm add react-router-dom\n\nThis dependency is automatically included in projects created with 'create-mcp-use-app'."
+    );
+  }
+})();
 function getBasename() {
   if (typeof window === "undefined") return "/";
   const path4 = window.location.pathname;
@@ -8721,7 +9634,13 @@ function McpUseProvider({
   if (enableDebugger || viewControls) {
     content = /* @__PURE__ */ import_react7.default.createElement(WidgetControls, { debugger: enableDebugger, viewControls }, content);
   }
-  content = /* @__PURE__ */ import_react7.default.createElement(import_react_router_dom.BrowserRouter, { basename }, content);
+  if (routerError) {
+    throw routerError;
+  }
+  if (!BrowserRouter) {
+    throw new Error("react-router-dom is still loading, please try again.");
+  }
+  content = /* @__PURE__ */ import_react7.default.createElement(BrowserRouter, { basename }, content);
   content = /* @__PURE__ */ import_react7.default.createElement(ThemeProvider, null, content);
   if (autoSize) {
     const containerStyle = {