@mcpjam/inspector 0.9.30 → 0.9.40

package/dist/server/index.js

@@ -1,5 +1,6 @@
 // index.ts
 import { serve } from "@hono/node-server";
+import dotenv from "dotenv";
 import fixPath from "fix-path";
 import { Hono as Hono13 } from "hono";
 import { cors } from "hono/cors";
@@ -185,7 +186,7 @@ var servers_default = servers;
 
 // routes/mcp/tools.ts
 import { Hono as Hono3 } from "hono";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { zodToJsonSchema } from "@alcyone-labs/zod-to-json-schema";
 var tools = new Hono3();
 var activeExecution = null;
 function nowIso() {
@@ -212,17 +213,17 @@ tools.post("/list", async (c) => {
     }
     const flattenedTools = await mcp2.getToolsetsForServer(serverId);
     const toolsWithJsonSchema = {};
-    for (const [name17, tool] of Object.entries(flattenedTools)) {
-      let inputSchema = tool.inputSchema;
+    for (const [name, tool2] of Object.entries(flattenedTools)) {
+      let inputSchema = tool2.inputSchema;
       try {
         inputSchema = zodToJsonSchema(inputSchema);
       } catch {
       }
-      toolsWithJsonSchema[name17] = {
-        name: name17,
-        description: tool.description,
+      toolsWithJsonSchema[name] = {
+        name,
+        description: tool2.description,
         inputSchema,
-        outputSchema: tool.outputSchema
+        outputSchema: tool2.outputSchema
       };
     }
     return c.json({ tools: toolsWithJsonSchema });
@@ -465,11 +466,11 @@ prompts.post("/list", async (c) => {
 });
 prompts.post("/get", async (c) => {
   try {
-    const { serverId, name: name17, args } = await c.req.json();
+    const { serverId, name, args } = await c.req.json();
     if (!serverId) {
       return c.json({ success: false, error: "serverId is required" }, 400);
     }
-    if (!name17) {
+    if (!name) {
       return c.json(
         {
           success: false,
@@ -480,7 +481,7 @@ prompts.post("/get", async (c) => {
     }
     const mcpJamClientManager2 = c.mcpJamClientManager;
     const content = await mcpJamClientManager2.getPrompt(
-      name17,
+      name,
       serverId,
       args || {}
     );
@@ -500,7 +501,7 @@ var prompts_default = prompts;
 
 // routes/mcp/chat.ts
 import { Hono as Hono6 } from "hono";
-import { Agent } from "@mastra/core/agent";
+import { streamText } from "ai";
 import { TextEncoder as TextEncoder2 } from "util";
 
 // ../client/src/lib/chat-utils.ts
@@ -520,2630 +521,319 @@ function getDefaultTemperatureByProvider(provider) {
   }
 }
 
-// node_modules/ai-v5/node_modules/@ai-sdk/provider/dist/index.mjs
-var marker = "vercel.ai.error";
-var symbol = Symbol.for(marker);
-var _a;
-var _AISDKError = class _AISDKError2 extends Error {
-  /**
-   * Creates an AI SDK Error.
-   *
-   * @param {Object} params - The parameters for creating the error.
-   * @param {string} params.name - The name of the error.
-   * @param {string} params.message - The error message.
-   * @param {unknown} [params.cause] - The underlying cause of the error.
-   */
-  constructor({
-    name: name143,
-    message,
-    cause
-  }) {
-    super(message);
-    this[_a] = true;
-    this.name = name143;
-    this.cause = cause;
-  }
-  /**
-   * Checks if the given error is an AI SDK Error.
-   * @param {unknown} error - The error to check.
-   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
-   */
-  static isInstance(error) {
-    return _AISDKError2.hasMarker(error, marker);
-  }
-  static hasMarker(error, marker153) {
-    const markerSymbol = Symbol.for(marker153);
-    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
-  }
-};
-_a = symbol;
-var AISDKError = _AISDKError;
-var name = "AI_APICallError";
-var marker2 = `vercel.ai.error.${name}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
-_a2 = symbol2;
-var name2 = "AI_EmptyResponseBodyError";
-var marker3 = `vercel.ai.error.${name2}`;
-var symbol3 = Symbol.for(marker3);
-var _a3;
-_a3 = symbol3;
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return JSON.stringify(error);
-}
-var name3 = "AI_InvalidArgumentError";
-var marker4 = `vercel.ai.error.${name3}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var InvalidArgumentError = class extends AISDKError {
-  constructor({
-    message,
-    cause,
-    argument
-  }) {
-    super({ name: name3, message, cause });
-    this[_a4] = true;
-    this.argument = argument;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-var name4 = "AI_InvalidPromptError";
-var marker5 = `vercel.ai.error.${name4}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-_a5 = symbol5;
-var name5 = "AI_InvalidResponseDataError";
-var marker6 = `vercel.ai.error.${name5}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-_a6 = symbol6;
-var name6 = "AI_JSONParseError";
-var marker7 = `vercel.ai.error.${name6}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var JSONParseError = class extends AISDKError {
-  constructor({ text: text2, cause }) {
-    super({
-      name: name6,
-      message: `JSON parsing failed: Text: ${text2}.
-Error message: ${getErrorMessage(cause)}`,
-      cause
-    });
-    this[_a7] = true;
-    this.text = text2;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-var name7 = "AI_LoadAPIKeyError";
-var marker8 = `vercel.ai.error.${name7}`;
-var symbol8 = Symbol.for(marker8);
-var _a8;
-_a8 = symbol8;
-var name8 = "AI_LoadSettingError";
-var marker9 = `vercel.ai.error.${name8}`;
-var symbol9 = Symbol.for(marker9);
-var _a9;
-_a9 = symbol9;
-var name9 = "AI_NoContentGeneratedError";
-var marker10 = `vercel.ai.error.${name9}`;
-var symbol10 = Symbol.for(marker10);
-var _a10;
-_a10 = symbol10;
-var name10 = "AI_NoSuchModelError";
-var marker11 = `vercel.ai.error.${name10}`;
-var symbol11 = Symbol.for(marker11);
-var _a11;
-_a11 = symbol11;
-var name11 = "AI_TooManyEmbeddingValuesForCallError";
-var marker12 = `vercel.ai.error.${name11}`;
-var symbol12 = Symbol.for(marker12);
-var _a12;
-_a12 = symbol12;
-var name12 = "AI_TypeValidationError";
-var marker13 = `vercel.ai.error.${name12}`;
-var symbol13 = Symbol.for(marker13);
-var _a13;
-var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
-  constructor({ value, cause }) {
-    super({
-      name: name12,
-      message: `Type validation failed: Value: ${JSON.stringify(value)}.
-Error message: ${getErrorMessage(cause)}`,
-      cause
-    });
-    this[_a13] = true;
-    this.value = value;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker13);
-  }
-  /**
-   * Wraps an error into a TypeValidationError.
-   * If the cause is already a TypeValidationError with the same value, it returns the cause.
-   * Otherwise, it creates a new TypeValidationError.
-   *
-   * @param {Object} params - The parameters for wrapping the error.
-   * @param {unknown} params.value - The value that failed validation.
-   * @param {unknown} params.cause - The original error or cause of the validation failure.
-   * @returns {TypeValidationError} A TypeValidationError instance.
-   */
-  static wrap({
-    value,
-    cause
-  }) {
-    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+// utils/chat-helpers.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createDeepSeek } from "@ai-sdk/deepseek";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOllama } from "ollama-ai-provider-v2";
+var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
+  if (!modelDefinition?.id || !modelDefinition?.provider) {
+    throw new Error(
+      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
+    );
   }
-};
-_a13 = symbol13;
-var TypeValidationError = _TypeValidationError;
-var name13 = "AI_UnsupportedFunctionalityError";
-var marker14 = `vercel.ai.error.${name13}`;
-var symbol14 = Symbol.for(marker14);
-var _a14;
-_a14 = symbol14;
-
-// node_modules/ai-v5/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-import * as z4 from "zod/v4";
-import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
-import { ZodFirstPartyTypeKind } from "zod/v3";
-import {
-  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
-} from "zod/v3";
-var createIdGenerator = ({
-  prefix,
-  size = 16,
-  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  separator = "-"
-} = {}) => {
-  const generator = () => {
-    const alphabetLength = alphabet.length;
-    const chars = new Array(size);
-    for (let i = 0; i < size; i++) {
-      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+  switch (modelDefinition.provider) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(modelDefinition.id);
+    case "openai":
+      return createOpenAI({ apiKey })(modelDefinition.id);
+    case "deepseek":
+      return createDeepSeek({ apiKey })(modelDefinition.id);
+    case "google":
+      return createGoogleGenerativeAI({ apiKey })(modelDefinition.id);
+    case "ollama": {
+      const raw = ollamaBaseUrl || "http://localhost:11434/api";
+      const normalized = /\/api\/?$/.test(raw) ? raw : `${raw.replace(/\/+$/, "")}/api`;
+      return createOllama({ baseURL: normalized })(modelDefinition.id);
     }
-    return chars.join("");
-  };
-  if (prefix == null) {
-    return generator;
-  }
-  if (alphabet.includes(separator)) {
-    throw new InvalidArgumentError({
-      argument: "separator",
-      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
-    });
+    default:
+      throw new Error(
+        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
+      );
   }
-  return () => `${prefix}${separator}${generator()}`;
 };
-var generateId = createIdGenerator();
-var suspectProtoRx = /"__proto__"\s*:/;
-var suspectConstructorRx = /"constructor"\s*:/;
-function _parse(text2) {
-  const obj = JSON.parse(text2);
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (suspectProtoRx.test(text2) === false && suspectConstructorRx.test(text2) === false) {
-    return obj;
-  }
-  return filter(obj);
-}
-function filter(obj) {
-  let next = [obj];
-  while (next.length) {
-    const nodes = next;
-    next = [];
-    for (const node of nodes) {
-      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
-        throw new SyntaxError("Object contains forbidden prototype property");
-      }
-      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
-        throw new SyntaxError("Object contains forbidden prototype property");
-      }
-      for (const key in node) {
-        const value = node[key];
-        if (value && typeof value === "object") {
-          next.push(value);
-        }
-      }
-    }
-  }
-  return obj;
-}
-function secureJsonParse(text2) {
-  const { stackTraceLimit } = Error;
-  Error.stackTraceLimit = 0;
-  try {
-    return _parse(text2);
-  } finally {
-    Error.stackTraceLimit = stackTraceLimit;
-  }
-}
-var validatorSymbol = Symbol.for("vercel.ai.validator");
-function validator(validate) {
-  return { [validatorSymbol]: true, validate };
-}
-function isValidator(value) {
-  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+
+// ../shared/tools.ts
+import { z } from "zod";
+import { zodToJsonSchema as zodToJsonSchema2 } from "@alcyone-labs/zod-to-json-schema";
+import { tool } from "ai";
+var fallbackInputSchema = z.object({}).passthrough();
+var UNREPRESENTABLE_JSON_SCHEMA_MESSAGES = [
+  "Custom types cannot be represented in JSON Schema",
+  "Function types cannot be represented in JSON Schema"
+];
+function isUnrepresentableSchemaError(error) {
+  return error instanceof Error && UNREPRESENTABLE_JSON_SCHEMA_MESSAGES.some(
+    (message) => error.message.includes(message)
+  );
 }
-function asValidator(value) {
-  return isValidator(value) ? value : standardSchemaValidator(value);
+function isZodSchema(value) {
+  return Boolean(
+    value && typeof value === "object" && "safeParse" in value
+  );
 }
-function standardSchemaValidator(standardSchema) {
-  return validator(async (value) => {
-    const result = await standardSchema["~standard"].validate(value);
-    return result.issues == null ? { success: true, value: result.value } : {
-      success: false,
-      error: new TypeValidationError({
-        value,
-        cause: result.issues
-      })
-    };
-  });
+function isDirectlyUnrepresentable(schema) {
+  const schemaType = schema?._def?.type;
+  return schemaType === "custom" || schemaType === "function";
 }
-async function safeValidateTypes({
-  value,
-  schema
-}) {
-  const validator2 = asValidator(schema);
-  try {
-    if (validator2.validate == null) {
-      return { success: true, value, rawValue: value };
-    }
-    const result = await validator2.validate(value);
-    if (result.success) {
-      return { success: true, value: result.value, rawValue: value };
+function canConvertToJSONSchema(schema) {
+  const toJSONSchema = z.toJSONSchema;
+  if (typeof toJSONSchema === "function") {
+    try {
+      toJSONSchema(schema);
+      return true;
+    } catch (error) {
+      if (isUnrepresentableSchemaError(error)) {
+        return false;
+      }
+      throw error;
     }
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error }),
-      rawValue: value
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: error }),
-      rawValue: value
-    };
   }
-}
-async function safeParseJSON({
-  text: text2,
-  schema
-}) {
   try {
-    const value = secureJsonParse(text2);
-    if (schema == null) {
-      return { success: true, value, rawValue: value };
-    }
-    return await safeValidateTypes({ value, schema });
+    zodToJsonSchema2(schema);
+    return true;
   } catch (error) {
-    return {
-      success: false,
-      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text: text2, cause: error }),
-      rawValue: void 0
-    };
-  }
-}
-var getRelativePath = (pathA, pathB) => {
-  let i = 0;
-  for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i])
-      break;
+    if (isUnrepresentableSchemaError(error)) {
+      return false;
+    }
+    throw error;
   }
-  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
-var ignoreOverride = Symbol(
-  "Let zodToJsonSchema decide on which parser to use"
-);
-var defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "format:date-time",
-  mapStrategy: "entries",
-  removeAdditionalStrategy: "passthrough",
-  allowedAdditionalProperties: true,
-  rejectedAdditionalProperties: false,
-  definitionPath: "definitions",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  patternStrategy: "escape",
-  applyRegexFlags: false,
-  emailStrategy: "format:email",
-  base64Strategy: "contentEncoding:base64",
-  nameStrategy: "ref"
-};
-var getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-function parseAnyDef() {
-  return {};
 }
-function parseArrayDef(def, refs) {
-  var _a17, _b, _c;
-  const res = {
-    type: "array"
-  };
-  if (((_a17 = def.type) == null ? void 0 : _a17._def) && ((_c = (_b = def.type) == null ? void 0 : _b._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef(def.type._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "items"]
-    });
-  }
-  if (def.minLength) {
-    res.minItems = def.minLength.value;
+function ensureInputSchema(schema) {
+  if (!isZodSchema(schema)) {
+    return fallbackInputSchema;
   }
-  if (def.maxLength) {
-    res.maxItems = def.maxLength.value;
+  if (isDirectlyUnrepresentable(schema)) {
+    return fallbackInputSchema;
   }
-  if (def.exactLength) {
-    res.minItems = def.exactLength.value;
-    res.maxItems = def.exactLength.value;
-  }
-  return res;
-}
-function parseBigintDef(def) {
-  const res = {
-    type: "integer",
-    format: "int64"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        if (check.inclusive) {
-          res.minimum = check.value;
-        } else {
-          res.exclusiveMinimum = check.value;
-        }
-        break;
-      case "max":
-        if (check.inclusive) {
-          res.maximum = check.value;
-        } else {
-          res.exclusiveMaximum = check.value;
-        }
-        break;
-      case "multipleOf":
-        res.multipleOf = check.value;
-        break;
-    }
+  if (!canConvertToJSONSchema(schema)) {
+    return fallbackInputSchema;
   }
-  return res;
-}
-function parseBooleanDef() {
-  return { type: "boolean" };
-}
-function parseBrandedDef(_def, refs) {
-  return parseDef(_def.type._def, refs);
+  return schema;
 }
-var parseCatchDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-function parseDateDef(def, refs, overrideDateStrategy) {
-  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
-  if (Array.isArray(strategy)) {
-    return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
-    };
-  }
-  switch (strategy) {
-    case "string":
-    case "format:date-time":
-      return {
-        type: "string",
-        format: "date-time"
-      };
-    case "format:date":
-      return {
-        type: "string",
-        format: "date"
-      };
-    case "integer":
-      return integerDateParser(def);
+function ensureOutputSchema(schema) {
+  if (!isZodSchema(schema)) {
+    return void 0;
   }
-}
-var integerDateParser = (def) => {
-  const res = {
-    type: "integer",
-    format: "unix-time"
-  };
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        res.minimum = check.value;
-        break;
-      case "max":
-        res.maximum = check.value;
-        break;
-    }
+  if (isDirectlyUnrepresentable(schema)) {
+    return void 0;
   }
-  return res;
-};
-function parseDefaultDef(_def, refs) {
-  return {
-    ...parseDef(_def.innerType._def, refs),
-    default: _def.defaultValue()
-  };
-}
-function parseEffectsDef(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
-}
-function parseEnumDef(def) {
-  return {
-    type: "string",
-    enum: Array.from(def.values)
-  };
-}
-var isJsonSchema7AllOfType = (type) => {
-  if ("type" in type && type.type === "string")
-    return false;
-  return "allOf" in type;
-};
-function parseIntersectionDef(def, refs) {
-  const allOf = [
-    parseDef(def.left._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "0"]
-    }),
-    parseDef(def.right._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "1"]
-    })
-  ].filter((x) => !!x);
-  const mergedAllOf = [];
-  allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
-      mergedAllOf.push(...schema.allOf);
-    } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
-        nestedSchema = rest;
-      }
-      mergedAllOf.push(nestedSchema);
-    }
-  });
-  return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
-}
-function parseLiteralDef(def) {
-  const parsedType = typeof def.value;
-  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
-    return {
-      type: Array.isArray(def.value) ? "array" : "object"
-    };
+  if (!canConvertToJSONSchema(schema)) {
+    return void 0;
   }
-  return {
-    type: parsedType === "bigint" ? "integer" : parsedType,
-    const: def.value
-  };
+  return schema;
 }
-var emojiRegex = void 0;
-var zodPatterns = {
-  /**
-   * `c` was changed to `[cC]` to replicate /i flag
-   */
-  cuid: /^[cC][^\s-]{8,}$/,
-  cuid2: /^[0-9a-z]+$/,
-  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
-  /**
-   * `a-z` was added to replicate /i flag
-   */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
-  /**
-   * Constructed a valid Unicode RegExp
-   *
-   * Lazily instantiate since this type of regex isn't supported
-   * in all envs (e.g. React Native).
-   *
-   * See:
-   * https://github.com/colinhacks/zod/issues/2433
-   * Fix in Zod:
-   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
-   */
-  emoji: () => {
-    if (emojiRegex === void 0) {
-      emojiRegex = RegExp(
-        "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
-        "u"
-      );
-    }
-    return emojiRegex;
-  },
-  /**
-   * Unused
-   */
-  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
-  /**
-   * Unused
-   */
-  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
-  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
-  /**
-   * Unused
-   */
-  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
-  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
-  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
-  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
-  nanoid: /^[a-zA-Z0-9_-]{21}$/,
-  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
-};
-function parseStringDef(def, refs) {
-  const res = {
-    type: "string"
+function extractPureToolName(toolKey) {
+  const separatorIndex = toolKey.indexOf("_");
+  if (separatorIndex === -1 || separatorIndex === toolKey.length - 1) {
+    return toolKey;
+  }
+  return toolKey.slice(separatorIndex + 1);
+}
+function convertMastraToolToVercelTool(toolName, mastraTool, options) {
+  const inputSchema = ensureInputSchema(mastraTool.inputSchema);
+  const outputSchema = ensureOutputSchema(mastraTool.outputSchema);
+  const displayName = options?.originalName ?? toolName;
+  const vercelToolConfig = {
+    type: "dynamic",
+    description: mastraTool.description,
+    inputSchema
   };
-  if (def.checks) {
-    for (const check of def.checks) {
-      switch (check.kind) {
-        case "min":
-          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
-          break;
-        case "max":
-          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
-          break;
-        case "email":
-          switch (refs.emailStrategy) {
-            case "format:email":
-              addFormat(res, "email", check.message, refs);
-              break;
-            case "format:idn-email":
-              addFormat(res, "idn-email", check.message, refs);
-              break;
-            case "pattern:zod":
-              addPattern(res, zodPatterns.email, check.message, refs);
-              break;
-          }
-          break;
-        case "url":
-          addFormat(res, "uri", check.message, refs);
-          break;
-        case "uuid":
-          addFormat(res, "uuid", check.message, refs);
-          break;
-        case "regex":
-          addPattern(res, check.regex, check.message, refs);
-          break;
-        case "cuid":
-          addPattern(res, zodPatterns.cuid, check.message, refs);
-          break;
-        case "cuid2":
-          addPattern(res, zodPatterns.cuid2, check.message, refs);
-          break;
-        case "startsWith":
-          addPattern(
-            res,
-            RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`),
-            check.message,
-            refs
-          );
-          break;
-        case "endsWith":
-          addPattern(
-            res,
-            RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`),
-            check.message,
-            refs
-          );
-          break;
-        case "datetime":
-          addFormat(res, "date-time", check.message, refs);
-          break;
-        case "date":
-          addFormat(res, "date", check.message, refs);
-          break;
-        case "time":
-          addFormat(res, "time", check.message, refs);
-          break;
-        case "duration":
-          addFormat(res, "duration", check.message, refs);
-          break;
-        case "length":
-          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
-          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
-          break;
-        case "includes": {
-          addPattern(
-            res,
-            RegExp(escapeLiteralCheckValue(check.value, refs)),
-            check.message,
-            refs
+  if (outputSchema) {
+    vercelToolConfig.outputSchema = outputSchema;
+  }
+  if (typeof mastraTool.execute === "function") {
+    vercelToolConfig.execute = async (input, options2) => {
+      const executionArgs = { context: input };
+      if (options2) {
+        executionArgs.runtimeContext = options2;
+      }
+      const result = await mastraTool.execute?.(executionArgs, options2);
+      if (outputSchema) {
+        const parsed = outputSchema.safeParse(result);
+        if (!parsed.success) {
+          throw new Error(
+            `Mastra tool '${displayName}' returned invalid output: ${parsed.error.message}`
           );
-          break;
-        }
-        case "ip": {
-          if (check.version !== "v6") {
-            addFormat(res, "ipv4", check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addFormat(res, "ipv6", check.message, refs);
-          }
-          break;
-        }
-        case "base64url":
-          addPattern(res, zodPatterns.base64url, check.message, refs);
-          break;
-        case "jwt":
-          addPattern(res, zodPatterns.jwt, check.message, refs);
-          break;
-        case "cidr": {
-          if (check.version !== "v6") {
-            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
-          }
-          break;
-        }
-        case "emoji":
-          addPattern(res, zodPatterns.emoji(), check.message, refs);
-          break;
-        case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
-          break;
-        }
-        case "base64": {
-          switch (refs.base64Strategy) {
-            case "format:binary": {
-              addFormat(res, "binary", check.message, refs);
-              break;
-            }
-            case "contentEncoding:base64": {
-              res.contentEncoding = "base64";
-              break;
-            }
-            case "pattern:zod": {
-              addPattern(res, zodPatterns.base64, check.message, refs);
-              break;
-            }
-          }
-          break;
         }
-        case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check.message, refs);
-        }
-        case "toLowerCase":
-        case "toUpperCase":
-        case "trim":
-          break;
-        default:
-          /* @__PURE__ */ ((_) => {
-          })(check);
+        return parsed.data;
       }
-    }
-  }
-  return res;
-}
-function escapeLiteralCheckValue(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
-}
-var ALPHA_NUMERIC = new Set(
-  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
-);
-function escapeNonAlphaNumeric(source) {
-  let result = "";
-  for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC.has(source[i])) {
-      result += "\\";
-    }
-    result += source[i];
-  }
-  return result;
-}
-function addFormat(schema, value, message, refs) {
-  var _a17;
-  if (schema.format || ((_a17 = schema.anyOf) == null ? void 0 : _a17.some((x) => x.format))) {
-    if (!schema.anyOf) {
-      schema.anyOf = [];
-    }
-    if (schema.format) {
-      schema.anyOf.push({
-        format: schema.format
-      });
-      delete schema.format;
-    }
-    schema.anyOf.push({
-      format: value,
-      ...message && refs.errorMessages && { errorMessage: { format: message } }
-    });
-  } else {
-    schema.format = value;
-  }
-}
-function addPattern(schema, regex, message, refs) {
-  var _a17;
-  if (schema.pattern || ((_a17 = schema.allOf) == null ? void 0 : _a17.some((x) => x.pattern))) {
-    if (!schema.allOf) {
-      schema.allOf = [];
-    }
-    if (schema.pattern) {
-      schema.allOf.push({
-        pattern: schema.pattern
-      });
-      delete schema.pattern;
-    }
-    schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
-      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
-    });
-  } else {
-    schema.pattern = stringifyRegExpWithFlags(regex, refs);
-  }
-}
-function stringifyRegExpWithFlags(regex, refs) {
-  var _a17;
-  if (!refs.applyRegexFlags || !regex.flags) {
-    return regex.source;
+      return result;
+    };
   }
-  const flags = {
-    i: regex.flags.includes("i"),
-    // Case-insensitive
-    m: regex.flags.includes("m"),
-    // `^` and `$` matches adjacent to newline characters
-    s: regex.flags.includes("s")
-    // `.` matches newlines
-  };
-  const source = flags.i ? regex.source.toLowerCase() : regex.source;
-  let pattern = "";
-  let isEscaped = false;
-  let inCharGroup = false;
-  let inCharRange = false;
-  for (let i = 0; i < source.length; i++) {
-    if (isEscaped) {
-      pattern += source[i];
-      isEscaped = false;
-      continue;
+  try {
+    return tool(vercelToolConfig);
+  } catch (error) {
+    if (!isUnrepresentableSchemaError(error)) {
+      throw error;
     }
-    if (flags.i) {
-      if (inCharGroup) {
-        if (source[i].match(/[a-z]/)) {
-          if (inCharRange) {
-            pattern += source[i];
-            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
-            inCharRange = false;
-          } else if (source[i + 1] === "-" && ((_a17 = source[i + 2]) == null ? void 0 : _a17.match(/[a-z]/))) {
-            pattern += source[i];
-            inCharRange = true;
-          } else {
-            pattern += `${source[i]}${source[i].toUpperCase()}`;
-          }
-          continue;
+    if (vercelToolConfig.outputSchema) {
+      const {
+        outputSchema: _unusedOutputSchema,
+        ...configWithoutOutputSchema
+      } = vercelToolConfig;
+      try {
+        return tool(configWithoutOutputSchema);
+      } catch (errorWithoutOutputSchema) {
+        if (!isUnrepresentableSchemaError(errorWithoutOutputSchema)) {
+          throw errorWithoutOutputSchema;
         }
-      } else if (source[i].match(/[a-z]/)) {
-        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
-        continue;
-      }
-    }
-    if (flags.m) {
-      if (source[i] === "^") {
-        pattern += `(^|(?<=[\r
-]))`;
-        continue;
-      } else if (source[i] === "$") {
-        pattern += `($|(?=[\r
-]))`;
-        continue;
-      }
-    }
-    if (flags.s && source[i] === ".") {
-      pattern += inCharGroup ? `${source[i]}\r
-` : `[${source[i]}\r
-]`;
-      continue;
-    }
-    pattern += source[i];
-    if (source[i] === "\\") {
-      isEscaped = true;
-    } else if (inCharGroup && source[i] === "]") {
-      inCharGroup = false;
-    } else if (!inCharGroup && source[i] === "[") {
-      inCharGroup = true;
-    }
-  }
-  try {
-    new RegExp(pattern);
-  } catch (e) {
-    console.warn(
-      `Could not convert regex pattern at ${refs.currentPath.join(
-        "/"
-      )} to a flag-independent form! Falling back to the flag-ignorant source`
-    );
-    return regex.source;
-  }
-  return pattern;
-}
-function parseRecordDef(def, refs) {
-  var _a17, _b, _c, _d, _e, _f;
-  const schema = {
-    type: "object",
-    additionalProperties: (_a17 = parseDef(def.valueType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    })) != null ? _a17 : refs.allowedAdditionalProperties
-  };
-  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
-    return {
-      ...schema,
-      propertyNames: {
-        enum: def.keyType._def.values
+        const fallbackConfig2 = {
+          ...configWithoutOutputSchema,
+          inputSchema: fallbackInputSchema
+        };
+        return tool(fallbackConfig2);
       }
-    };
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type, ...keyType } = parseBrandedDef(
-      def.keyType._def,
-      refs
-    );
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  }
-  return schema;
-}
-function parseMapDef(def, refs) {
-  if (refs.mapStrategy === "record") {
-    return parseRecordDef(def, refs);
-  }
-  const keys = parseDef(def.keyType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || parseAnyDef();
-  const values = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || parseAnyDef();
-  return {
-    type: "array",
-    maxItems: 125,
-    items: {
-      type: "array",
-      items: [keys, values],
-      minItems: 2,
-      maxItems: 2
-    }
-  };
-}
-function parseNativeEnumDef(def) {
-  const object2 = def.values;
-  const actualKeys = Object.keys(def.values).filter((key) => {
-    return typeof object2[object2[key]] !== "number";
-  });
-  const actualValues = actualKeys.map((key) => object2[key]);
-  const parsedTypes = Array.from(
-    new Set(actualValues.map((values) => typeof values))
-  );
-  return {
-    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
-    enum: actualValues
-  };
-}
-function parseNeverDef() {
-  return { not: parseAnyDef() };
-}
-function parseNullDef() {
-  return {
-    type: "null"
-  };
-}
-var primitiveMappings = {
-  ZodString: "string",
-  ZodNumber: "number",
-  ZodBigInt: "integer",
-  ZodBoolean: "boolean",
-  ZodNull: "null"
-};
-function parseUnionDef(def, refs) {
-  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-  if (options.every(
-    (x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length)
-  )) {
-    const types = options.reduce((types2, x) => {
-      const type = primitiveMappings[x._def.typeName];
-      return type && !types2.includes(type) ? [...types2, type] : types2;
-    }, []);
-    return {
-      type: types.length > 1 ? types : types[0]
-    };
-  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options.reduce(
-      (acc, x) => {
-        const type = typeof x._def.value;
-        switch (type) {
-          case "string":
-          case "number":
-          case "boolean":
-            return [...acc, type];
-          case "bigint":
-            return [...acc, "integer"];
-          case "object":
-            if (x._def.value === null)
-              return [...acc, "null"];
-          case "symbol":
-          case "undefined":
-          case "function":
-          default:
-            return acc;
-        }
-      },
-      []
-    );
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-      return {
-        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-        enum: options.reduce(
-          (acc, x) => {
-            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-          },
-          []
-        )
-      };
-    }
-  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-    return {
-      type: "string",
-      enum: options.reduce(
-        (acc, x) => [
-          ...acc,
-          ...x._def.values.filter((x2) => !acc.includes(x2))
-        ],
-        []
-      )
-    };
-  }
-  return asAnyOf(def, refs);
-}
-var asAnyOf = (def, refs) => {
-  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
-    (x, i) => parseDef(x._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "anyOf", `${i}`]
-    })
-  ).filter(
-    (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
-  );
-  return anyOf.length ? { anyOf } : void 0;
-};
-function parseNullableDef(def, refs) {
-  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
-    def.innerType._def.typeName
-  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-    return {
-      type: [
-        primitiveMappings[def.innerType._def.typeName],
-        "null"
-      ]
-    };
-  }
-  const base = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "0"]
-  });
-  return base && { anyOf: [base, { type: "null" }] };
-}
-function parseNumberDef(def) {
-  const res = {
-    type: "number"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "int":
-        res.type = "integer";
-        break;
-      case "min":
-        if (check.inclusive) {
-          res.minimum = check.value;
-        } else {
-          res.exclusiveMinimum = check.value;
-        }
-        break;
-      case "max":
-        if (check.inclusive) {
-          res.maximum = check.value;
-        } else {
-          res.exclusiveMaximum = check.value;
-        }
-        break;
-      case "multipleOf":
-        res.multipleOf = check.value;
-        break;
-    }
-  }
-  return res;
-}
-function parseObjectDef(def, refs) {
-  const result = {
-    type: "object",
-    properties: {}
-  };
-  const required = [];
-  const shape = def.shape();
-  for (const propName in shape) {
-    let propDef = shape[propName];
-    if (propDef === void 0 || propDef._def === void 0) {
-      continue;
-    }
-    const propOptional = safeIsOptional(propDef);
-    const parsedDef = parseDef(propDef._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "properties", propName],
-      propertyPath: [...refs.currentPath, "properties", propName]
-    });
-    if (parsedDef === void 0) {
-      continue;
-    }
-    result.properties[propName] = parsedDef;
-    if (!propOptional) {
-      required.push(propName);
-    }
-  }
-  if (required.length) {
-    result.required = required;
-  }
-  const additionalProperties = decideAdditionalProperties(def, refs);
-  if (additionalProperties !== void 0) {
-    result.additionalProperties = additionalProperties;
-  }
-  return result;
-}
-function decideAdditionalProperties(def, refs) {
-  if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef(def.catchall._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    });
-  }
-  switch (def.unknownKeys) {
-    case "passthrough":
-      return refs.allowedAdditionalProperties;
-    case "strict":
-      return refs.rejectedAdditionalProperties;
-    case "strip":
-      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
-  }
-}
-function safeIsOptional(schema) {
-  try {
-    return schema.isOptional();
-  } catch (e) {
-    return true;
-  }
-}
-var parseOptionalDef = (def, refs) => {
-  var _a17;
-  if (refs.currentPath.toString() === ((_a17 = refs.propertyPath) == null ? void 0 : _a17.toString())) {
-    return parseDef(def.innerType._def, refs);
-  }
-  const innerSchema = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "1"]
-  });
-  return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
-};
-var parsePipelineDef = (def, refs) => {
-  if (refs.pipeStrategy === "input") {
-    return parseDef(def.in._def, refs);
-  } else if (refs.pipeStrategy === "output") {
-    return parseDef(def.out._def, refs);
-  }
-  const a = parseDef(def.in._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", "0"]
-  });
-  const b = parseDef(def.out._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
-  });
-  return {
-    allOf: [a, b].filter((x) => x !== void 0)
-  };
-};
-function parsePromiseDef(def, refs) {
-  return parseDef(def.type._def, refs);
-}
-function parseSetDef(def, refs) {
-  const items = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items"]
-  });
-  const schema = {
-    type: "array",
-    uniqueItems: true,
-    items
-  };
-  if (def.minSize) {
-    schema.minItems = def.minSize.value;
-  }
-  if (def.maxSize) {
-    schema.maxItems = def.maxSize.value;
-  }
-  return schema;
-}
-function parseTupleDef(def, refs) {
-  if (def.rest) {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      items: def.items.map(
-        (x, i) => parseDef(x._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, "items", `${i}`]
-        })
-      ).reduce(
-        (acc, x) => x === void 0 ? acc : [...acc, x],
-        []
-      ),
-      additionalItems: parseDef(def.rest._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "additionalItems"]
-      })
-    };
-  } else {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      maxItems: def.items.length,
-      items: def.items.map(
-        (x, i) => parseDef(x._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, "items", `${i}`]
-        })
-      ).reduce(
-        (acc, x) => x === void 0 ? acc : [...acc, x],
-        []
-      )
-    };
-  }
-}
-function parseUndefinedDef() {
-  return {
-    not: parseAnyDef()
-  };
-}
-function parseUnknownDef() {
-  return parseAnyDef();
-}
-var parseReadonlyDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-var selectParser = (def, typeName, refs) => {
-  switch (typeName) {
-    case ZodFirstPartyTypeKind3.ZodString:
-      return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodNumber:
-      return parseNumberDef(def);
-    case ZodFirstPartyTypeKind3.ZodObject:
-      return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodBigInt:
-      return parseBigintDef(def);
-    case ZodFirstPartyTypeKind3.ZodBoolean:
-      return parseBooleanDef();
-    case ZodFirstPartyTypeKind3.ZodDate:
-      return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodUndefined:
-      return parseUndefinedDef();
-    case ZodFirstPartyTypeKind3.ZodNull:
-      return parseNullDef();
-    case ZodFirstPartyTypeKind3.ZodArray:
-      return parseArrayDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodUnion:
-    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodTuple:
-      return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodRecord:
-      return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodLiteral:
-      return parseLiteralDef(def);
-    case ZodFirstPartyTypeKind3.ZodEnum:
-      return parseEnumDef(def);
-    case ZodFirstPartyTypeKind3.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind3.ZodNullable:
-      return parseNullableDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodMap:
-      return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodSet:
-      return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodLazy:
-      return () => def.getter()._def;
-    case ZodFirstPartyTypeKind3.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodNaN:
-    case ZodFirstPartyTypeKind3.ZodNever:
-      return parseNeverDef();
-    case ZodFirstPartyTypeKind3.ZodEffects:
-      return parseEffectsDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodAny:
-      return parseAnyDef();
-    case ZodFirstPartyTypeKind3.ZodUnknown:
-      return parseUnknownDef();
-    case ZodFirstPartyTypeKind3.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodCatch:
-      return parseCatchDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case ZodFirstPartyTypeKind3.ZodFunction:
-    case ZodFirstPartyTypeKind3.ZodVoid:
-    case ZodFirstPartyTypeKind3.ZodSymbol:
-      return void 0;
-    default:
-      return /* @__PURE__ */ ((_) => void 0)(typeName);
-  }
-};
-function parseDef(def, refs, forceResolution = false) {
-  var _a17;
-  const seenItem = refs.seen.get(def);
-  if (refs.override) {
-    const overrideResult = (_a17 = refs.override) == null ? void 0 : _a17.call(
-      refs,
-      def,
-      refs,
-      seenItem,
-      forceResolution
-    );
-    if (overrideResult !== ignoreOverride) {
-      return overrideResult;
-    }
-  }
-  if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
-    if (seenSchema !== void 0) {
-      return seenSchema;
-    }
-  }
-  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
-  refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
-  const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
-  if (jsonSchema2) {
-    addMeta(def, refs, jsonSchema2);
-  }
-  if (refs.postProcess) {
-    const postProcessResult = refs.postProcess(jsonSchema2, def, refs);
-    newItem.jsonSchema = jsonSchema2;
-    return postProcessResult;
-  }
-  newItem.jsonSchema = jsonSchema2;
-  return jsonSchema2;
-}
-var get$ref = (item, refs) => {
-  switch (refs.$refStrategy) {
-    case "root":
-      return { $ref: item.path.join("/") };
-    case "relative":
-      return { $ref: getRelativePath(refs.currentPath, item.path) };
-    case "none":
-    case "seen": {
-      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
-        console.warn(
-          `Recursive reference detected at ${refs.currentPath.join(
-            "/"
-          )}! Defaulting to any`
-        );
-        return parseAnyDef();
-      }
-      return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
-    }
-  }
-};
-var addMeta = (def, refs, jsonSchema2) => {
-  if (def.description) {
-    jsonSchema2.description = def.description;
-  }
-  return jsonSchema2;
-};
-var getRefs = (options) => {
-  const _options = getDefaultOptions(options);
-  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
-  return {
-    ..._options,
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(
-      Object.entries(_options.definitions).map(([name17, def]) => [
-        def._def,
-        {
-          def: def._def,
-          path: [..._options.basePath, _options.definitionPath, name17],
-          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-          jsonSchema: void 0
-        }
-      ])
-    )
-  };
-};
-var zodToJsonSchema2 = (schema, options) => {
-  var _a17;
-  const refs = getRefs(options);
-  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
-    (acc, [name23, schema2]) => {
-      var _a23;
-      return {
-        ...acc,
-        [name23]: (_a23 = parseDef(
-          schema2._def,
-          {
-            ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name23]
-          },
-          true
-        )) != null ? _a23 : parseAnyDef()
-      };
-    },
-    {}
-  ) : void 0;
-  const name17 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
-  const main = (_a17 = parseDef(
-    schema._def,
-    name17 === void 0 ? refs : {
-      ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name17]
-    },
-    false
-  )) != null ? _a17 : parseAnyDef();
-  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
-  if (title !== void 0) {
-    main.title = title;
-  }
-  const combined = name17 === void 0 ? definitions ? {
-    ...main,
-    [refs.definitionPath]: definitions
-  } : main : {
-    $ref: [
-      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
-      refs.definitionPath,
-      name17
-    ].join("/"),
-    [refs.definitionPath]: {
-      ...definitions,
-      [name17]: main
-    }
-  };
-  combined.$schema = "http://json-schema.org/draft-07/schema#";
-  return combined;
-};
-var zod_to_json_schema_default = zodToJsonSchema2;
-function zod3Schema(zodSchema2, options) {
-  var _a17;
-  const useReferences = (_a17 = options == null ? void 0 : options.useReferences) != null ? _a17 : false;
-  return jsonSchema(
-    zod_to_json_schema_default(zodSchema2, {
-      $refStrategy: useReferences ? "root" : "none"
-    }),
-    {
-      validate: async (value) => {
-        const result = await zodSchema2.safeParseAsync(value);
-        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-      }
-    }
-  );
-}
-function zod4Schema(zodSchema2, options) {
-  var _a17;
-  const useReferences = (_a17 = options == null ? void 0 : options.useReferences) != null ? _a17 : false;
-  const z4JSONSchema = z4.toJSONSchema(zodSchema2, {
-    target: "draft-7",
-    io: "output",
-    reused: useReferences ? "ref" : "inline"
-  });
-  return jsonSchema(z4JSONSchema, {
-    validate: async (value) => {
-      const result = await z4.safeParseAsync(zodSchema2, value);
-      return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-    }
-  });
-}
-function isZod4Schema(zodSchema2) {
-  return "_zod" in zodSchema2;
-}
-function zodSchema(zodSchema2, options) {
-  if (isZod4Schema(zodSchema2)) {
-    return zod4Schema(zodSchema2, options);
-  } else {
-    return zod3Schema(zodSchema2, options);
-  }
-}
-var schemaSymbol = Symbol.for("vercel.ai.schema");
-function jsonSchema(jsonSchema2, {
-  validate
-} = {}) {
-  return {
-    [schemaSymbol]: true,
-    _type: void 0,
-    // should never be used directly
-    [validatorSymbol]: true,
-    jsonSchema: jsonSchema2,
-    validate
-  };
-}
-function isSchema(value) {
-  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
-}
-function asSchema(schema) {
-  return schema == null ? jsonSchema({
-    properties: {},
-    additionalProperties: false
-  }) : isSchema(schema) ? schema : zodSchema(schema);
-}
-var { btoa, atob } = globalThis;
-
-// node_modules/ai-v5/dist/index.mjs
-import { z } from "zod/v4";
-import { z as z6 } from "zod/v4";
-import { z as z5 } from "zod/v4";
-import { z as z3 } from "zod/v4";
-import { z as z2 } from "zod/v4";
-import { z as z42 } from "zod/v4";
-import { z as z7 } from "zod/v4";
-import { z as z9 } from "zod/v4";
-import { z as z8 } from "zod/v4";
-import { z as z10 } from "zod/v4";
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name17 in all)
-    __defProp(target, name17, { get: all[name17], enumerable: true });
-};
-var name14 = "AI_NoOutputSpecifiedError";
-var marker15 = `vercel.ai.error.${name14}`;
-var symbol15 = Symbol.for(marker15);
-var _a15;
-_a15 = symbol15;
-var name22 = "AI_InvalidArgumentError";
-var marker22 = `vercel.ai.error.${name22}`;
-var symbol22 = Symbol.for(marker22);
-var _a22;
-_a22 = symbol22;
-var name32 = "AI_InvalidStreamPartError";
-var marker32 = `vercel.ai.error.${name32}`;
-var symbol32 = Symbol.for(marker32);
-var _a32;
-_a32 = symbol32;
-var name42 = "AI_InvalidToolInputError";
-var marker42 = `vercel.ai.error.${name42}`;
-var symbol42 = Symbol.for(marker42);
-var _a42;
-_a42 = symbol42;
-var name52 = "AI_MCPClientError";
-var marker52 = `vercel.ai.error.${name52}`;
-var symbol52 = Symbol.for(marker52);
-var _a52;
-_a52 = symbol52;
-var name62 = "AI_NoImageGeneratedError";
-var marker62 = `vercel.ai.error.${name62}`;
-var symbol62 = Symbol.for(marker62);
-var _a62;
-_a62 = symbol62;
-var name72 = "AI_NoObjectGeneratedError";
-var marker72 = `vercel.ai.error.${name72}`;
-var symbol72 = Symbol.for(marker72);
-var _a72;
-var NoObjectGeneratedError = class extends AISDKError {
-  constructor({
-    message = "No object generated.",
-    cause,
-    text: text2,
-    response,
-    usage,
-    finishReason
-  }) {
-    super({ name: name72, message, cause });
-    this[_a72] = true;
-    this.text = text2;
-    this.response = response;
-    this.usage = usage;
-    this.finishReason = finishReason;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker72);
-  }
-};
-_a72 = symbol72;
-var name82 = "AI_NoOutputGeneratedError";
-var marker82 = `vercel.ai.error.${name82}`;
-var symbol82 = Symbol.for(marker82);
-var _a82;
-_a82 = symbol82;
-var name92 = "AI_NoSuchToolError";
-var marker92 = `vercel.ai.error.${name92}`;
-var symbol92 = Symbol.for(marker92);
-var _a92;
-_a92 = symbol92;
-var name102 = "AI_ToolCallRepairError";
-var marker102 = `vercel.ai.error.${name102}`;
-var symbol102 = Symbol.for(marker102);
-var _a102;
-_a102 = symbol102;
-var name112 = "AI_InvalidDataContentError";
-var marker112 = `vercel.ai.error.${name112}`;
-var symbol112 = Symbol.for(marker112);
-var _a112;
-_a112 = symbol112;
-var name122 = "AI_InvalidMessageRoleError";
-var marker122 = `vercel.ai.error.${name122}`;
-var symbol122 = Symbol.for(marker122);
-var _a122;
-_a122 = symbol122;
-var name132 = "AI_MessageConversionError";
-var marker132 = `vercel.ai.error.${name132}`;
-var symbol132 = Symbol.for(marker132);
-var _a132;
-_a132 = symbol132;
-var name142 = "AI_DownloadError";
-var marker142 = `vercel.ai.error.${name142}`;
-var symbol142 = Symbol.for(marker142);
-var _a142;
-_a142 = symbol142;
-var name15 = "AI_RetryError";
-var marker152 = `vercel.ai.error.${name15}`;
-var symbol152 = Symbol.for(marker152);
-var _a152;
-_a152 = symbol152;
-var dataContentSchema = z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a17, _b;
-      return (_b = (_a17 = globalThis.Buffer) == null ? void 0 : _a17.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-var jsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.null(),
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.record(z2.string(), jsonValueSchema),
-    z2.array(jsonValueSchema)
-  ])
-);
-var providerMetadataSchema = z3.record(
-  z3.string(),
-  z3.record(z3.string(), jsonValueSchema)
-);
-var textPartSchema = z42.object({
-  type: z42.literal("text"),
-  text: z42.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var imagePartSchema = z42.object({
-  type: z42.literal("image"),
-  image: z42.union([dataContentSchema, z42.instanceof(URL)]),
-  mediaType: z42.string().optional(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var filePartSchema = z42.object({
-  type: z42.literal("file"),
-  data: z42.union([dataContentSchema, z42.instanceof(URL)]),
-  filename: z42.string().optional(),
-  mediaType: z42.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var reasoningPartSchema = z42.object({
-  type: z42.literal("reasoning"),
-  text: z42.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolCallPartSchema = z42.object({
-  type: z42.literal("tool-call"),
-  toolCallId: z42.string(),
-  toolName: z42.string(),
-  input: z42.unknown(),
-  providerOptions: providerMetadataSchema.optional(),
-  providerExecuted: z42.boolean().optional()
-});
-var outputSchema = z42.discriminatedUnion("type", [
-  z42.object({
-    type: z42.literal("text"),
-    value: z42.string()
-  }),
-  z42.object({
-    type: z42.literal("json"),
-    value: jsonValueSchema
-  }),
-  z42.object({
-    type: z42.literal("error-text"),
-    value: z42.string()
-  }),
-  z42.object({
-    type: z42.literal("error-json"),
-    value: jsonValueSchema
-  }),
-  z42.object({
-    type: z42.literal("content"),
-    value: z42.array(
-      z42.union([
-        z42.object({
-          type: z42.literal("text"),
-          text: z42.string()
-        }),
-        z42.object({
-          type: z42.literal("media"),
-          data: z42.string(),
-          mediaType: z42.string()
-        })
-      ])
-    )
-  })
-]);
-var toolResultPartSchema = z42.object({
-  type: z42.literal("tool-result"),
-  toolCallId: z42.string(),
-  toolName: z42.string(),
-  output: outputSchema,
-  providerOptions: providerMetadataSchema.optional()
-});
-var systemModelMessageSchema = z5.object(
-  {
-    role: z5.literal("system"),
-    content: z5.string(),
-    providerOptions: providerMetadataSchema.optional()
-  }
-);
-var userModelMessageSchema = z5.object({
-  role: z5.literal("user"),
-  content: z5.union([
-    z5.string(),
-    z5.array(z5.union([textPartSchema, imagePartSchema, filePartSchema]))
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var assistantModelMessageSchema = z5.object({
-  role: z5.literal("assistant"),
-  content: z5.union([
-    z5.string(),
-    z5.array(
-      z5.union([
-        textPartSchema,
-        filePartSchema,
-        reasoningPartSchema,
-        toolCallPartSchema,
-        toolResultPartSchema
-      ])
-    )
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolModelMessageSchema = z5.object({
-  role: z5.literal("tool"),
-  content: z5.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional()
-});
-var modelMessageSchema = z5.union([
-  systemModelMessageSchema,
-  userModelMessageSchema,
-  assistantModelMessageSchema,
-  toolModelMessageSchema
-]);
-function stepCountIs(stepCount) {
-  return ({ steps }) => steps.length === stepCount;
-}
-var originalGenerateId = createIdGenerator({
-  prefix: "aitxt",
-  size: 24
-});
-var JsonToSseTransformStream = class extends TransformStream {
-  constructor() {
-    super({
-      transform(part, controller) {
-        controller.enqueue(`data: ${JSON.stringify(part)}
-
-`);
-      },
-      flush(controller) {
-        controller.enqueue("data: [DONE]\n\n");
-      }
-    });
-  }
-};
-var uiMessageChunkSchema = z7.union([
-  z7.strictObject({
-    type: z7.literal("text-start"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("text-delta"),
-    id: z7.string(),
-    delta: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("text-end"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("error"),
-    errorText: z7.string()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-input-start"),
-    toolCallId: z7.string(),
-    toolName: z7.string(),
-    providerExecuted: z7.boolean().optional(),
-    dynamic: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-input-delta"),
-    toolCallId: z7.string(),
-    inputTextDelta: z7.string()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-input-available"),
-    toolCallId: z7.string(),
-    toolName: z7.string(),
-    input: z7.unknown(),
-    providerExecuted: z7.boolean().optional(),
-    providerMetadata: providerMetadataSchema.optional(),
-    dynamic: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-input-error"),
-    toolCallId: z7.string(),
-    toolName: z7.string(),
-    input: z7.unknown(),
-    providerExecuted: z7.boolean().optional(),
-    providerMetadata: providerMetadataSchema.optional(),
-    dynamic: z7.boolean().optional(),
-    errorText: z7.string()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-output-available"),
-    toolCallId: z7.string(),
-    output: z7.unknown(),
-    providerExecuted: z7.boolean().optional(),
-    dynamic: z7.boolean().optional(),
-    preliminary: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-output-error"),
-    toolCallId: z7.string(),
-    errorText: z7.string(),
-    providerExecuted: z7.boolean().optional(),
-    dynamic: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning"),
-    text: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-start"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-delta"),
-    id: z7.string(),
-    delta: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-end"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-part-finish")
-  }),
-  z7.strictObject({
-    type: z7.literal("source-url"),
-    sourceId: z7.string(),
-    url: z7.string(),
-    title: z7.string().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("source-document"),
-    sourceId: z7.string(),
-    mediaType: z7.string(),
-    title: z7.string(),
-    filename: z7.string().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("file"),
-    url: z7.string(),
-    mediaType: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.string().startsWith("data-"),
-    id: z7.string().optional(),
-    data: z7.unknown(),
-    transient: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("start-step")
-  }),
-  z7.strictObject({
-    type: z7.literal("finish-step")
-  }),
-  z7.strictObject({
-    type: z7.literal("start"),
-    messageId: z7.string().optional(),
-    messageMetadata: z7.unknown().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("finish"),
-    messageMetadata: z7.unknown().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("abort")
-  }),
-  z7.strictObject({
-    type: z7.literal("message-metadata"),
-    messageMetadata: z7.unknown()
-  })
-]);
-function fixJson(input) {
-  const stack = ["ROOT"];
-  let lastValidIndex = -1;
-  let literalStart = null;
-  function processValueStart(char, i, swapState) {
-    {
-      switch (char) {
-        case '"': {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_STRING");
-          break;
-        }
-        case "f":
-        case "t":
-        case "n": {
-          lastValidIndex = i;
-          literalStart = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_LITERAL");
-          break;
-        }
-        case "-": {
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "0":
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_NUMBER");
-          break;
-        }
-        case "{": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_OBJECT_START");
-          break;
-        }
-        case "[": {
-          lastValidIndex = i;
-          stack.pop();
-          stack.push(swapState);
-          stack.push("INSIDE_ARRAY_START");
-          break;
-        }
-      }
-    }
-  }
-  function processAfterObjectValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_OBJECT_AFTER_COMMA");
-        break;
-      }
-      case "}": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  function processAfterArrayValue(char, i) {
-    switch (char) {
-      case ",": {
-        stack.pop();
-        stack.push("INSIDE_ARRAY_AFTER_COMMA");
-        break;
-      }
-      case "]": {
-        lastValidIndex = i;
-        stack.pop();
-        break;
-      }
-    }
-  }
-  for (let i = 0; i < input.length; i++) {
-    const char = input[i];
-    const currentState = stack[stack.length - 1];
-    switch (currentState) {
-      case "ROOT":
-        processValueStart(char, i, "FINISH");
-        break;
-      case "INSIDE_OBJECT_START": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-          case "}": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_COMMA": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_KEY": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_AFTER_KEY");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_KEY": {
-        switch (char) {
-          case ":": {
-            stack.pop();
-            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_OBJECT_BEFORE_VALUE": {
-        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        processAfterObjectValue(char, i);
-        break;
-      }
-      case "INSIDE_STRING": {
-        switch (char) {
-          case '"': {
-            stack.pop();
-            lastValidIndex = i;
-            break;
-          }
-          case "\\": {
-            stack.push("INSIDE_STRING_ESCAPE");
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_START": {
-        switch (char) {
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        switch (char) {
-          case ",": {
-            stack.pop();
-            stack.push("INSIDE_ARRAY_AFTER_COMMA");
-            break;
-          }
-          case "]": {
-            lastValidIndex = i;
-            stack.pop();
-            break;
-          }
-          default: {
-            lastValidIndex = i;
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_ARRAY_AFTER_COMMA": {
-        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
-        break;
-      }
-      case "INSIDE_STRING_ESCAPE": {
-        stack.pop();
-        lastValidIndex = i;
-        break;
-      }
-      case "INSIDE_NUMBER": {
-        switch (char) {
-          case "0":
-          case "1":
-          case "2":
-          case "3":
-          case "4":
-          case "5":
-          case "6":
-          case "7":
-          case "8":
-          case "9": {
-            lastValidIndex = i;
-            break;
-          }
-          case "e":
-          case "E":
-          case "-":
-          case ".": {
-            break;
-          }
-          case ",": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "}": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-              processAfterObjectValue(char, i);
-            }
-            break;
-          }
-          case "]": {
-            stack.pop();
-            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-              processAfterArrayValue(char, i);
-            }
-            break;
-          }
-          default: {
-            stack.pop();
-            break;
-          }
-        }
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, i + 1);
-        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
-          stack.pop();
-          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
-            processAfterObjectValue(char, i);
-          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
-            processAfterArrayValue(char, i);
-          }
-        } else {
-          lastValidIndex = i;
-        }
-        break;
-      }
-    }
-  }
-  let result = input.slice(0, lastValidIndex + 1);
-  for (let i = stack.length - 1; i >= 0; i--) {
-    const state = stack[i];
-    switch (state) {
-      case "INSIDE_STRING": {
-        result += '"';
-        break;
-      }
-      case "INSIDE_OBJECT_KEY":
-      case "INSIDE_OBJECT_AFTER_KEY":
-      case "INSIDE_OBJECT_AFTER_COMMA":
-      case "INSIDE_OBJECT_START":
-      case "INSIDE_OBJECT_BEFORE_VALUE":
-      case "INSIDE_OBJECT_AFTER_VALUE": {
-        result += "}";
-        break;
-      }
-      case "INSIDE_ARRAY_START":
-      case "INSIDE_ARRAY_AFTER_COMMA":
-      case "INSIDE_ARRAY_AFTER_VALUE": {
-        result += "]";
-        break;
-      }
-      case "INSIDE_LITERAL": {
-        const partialLiteral = input.substring(literalStart, input.length);
-        if ("true".startsWith(partialLiteral)) {
-          result += "true".slice(partialLiteral.length);
-        } else if ("false".startsWith(partialLiteral)) {
-          result += "false".slice(partialLiteral.length);
-        } else if ("null".startsWith(partialLiteral)) {
-          result += "null".slice(partialLiteral.length);
-        }
-      }
-    }
-  }
-  return result;
-}
-async function parsePartialJson(jsonText) {
-  if (jsonText === void 0) {
-    return { value: void 0, state: "undefined-input" };
-  }
-  let result = await safeParseJSON({ text: jsonText });
-  if (result.success) {
-    return { value: result.value, state: "successful-parse" };
-  }
-  result = await safeParseJSON({ text: fixJson(jsonText) });
-  if (result.success) {
-    return { value: result.value, state: "repaired-parse" };
-  }
-  return { value: void 0, state: "failed-parse" };
-}
-var originalGenerateId2 = createIdGenerator({
-  prefix: "aitxt",
-  size: 24
-});
-var originalGenerateId3 = createIdGenerator({ prefix: "aiobj", size: 24 });
-var originalGenerateId4 = createIdGenerator({ prefix: "aiobj", size: 24 });
-var output_exports = {};
-__export(output_exports, {
-  object: () => object,
-  text: () => text
-});
-var text = () => ({
-  type: "text",
-  responseFormat: { type: "text" },
-  async parsePartial({ text: text2 }) {
-    return { partial: text2 };
-  },
-  async parseOutput({ text: text2 }) {
-    return text2;
-  }
-});
-var object = ({
-  schema: inputSchema
-}) => {
-  const schema = asSchema(inputSchema);
-  return {
-    type: "object",
-    responseFormat: {
-      type: "json",
-      schema: schema.jsonSchema
-    },
-    async parsePartial({ text: text2 }) {
-      const result = await parsePartialJson(text2);
-      switch (result.state) {
-        case "failed-parse":
-        case "undefined-input":
-          return void 0;
-        case "repaired-parse":
-        case "successful-parse":
-          return {
-            // Note: currently no validation of partial results:
-            partial: result.value
-          };
-        default: {
-          const _exhaustiveCheck = result.state;
-          throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
-        }
-      }
-    },
-    async parseOutput({ text: text2 }, context) {
-      const parseResult = await safeParseJSON({ text: text2 });
-      if (!parseResult.success) {
-        throw new NoObjectGeneratedError({
-          message: "No object generated: could not parse the response.",
-          cause: parseResult.error,
-          text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
-        });
-      }
-      const validationResult = await safeValidateTypes({
-        value: parseResult.value,
-        schema
-      });
-      if (!validationResult.success) {
-        throw new NoObjectGeneratedError({
-          message: "No object generated: response did not match schema.",
-          cause: validationResult.error,
-          text: text2,
-          response: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
-        });
-      }
-      return validationResult.value;
-    }
-  };
-};
-var name16 = "AI_NoSuchProviderError";
-var marker16 = `vercel.ai.error.${name16}`;
-var symbol16 = Symbol.for(marker16);
-var _a16;
-_a16 = symbol16;
-var ClientOrServerImplementationSchema = z8.looseObject({
-  name: z8.string(),
-  version: z8.string()
-});
-var BaseParamsSchema = z8.looseObject({
-  _meta: z8.optional(z8.object({}).loose())
-});
-var ResultSchema = BaseParamsSchema;
-var RequestSchema = z8.object({
-  method: z8.string(),
-  params: z8.optional(BaseParamsSchema)
-});
-var ServerCapabilitiesSchema = z8.looseObject({
-  experimental: z8.optional(z8.object({}).loose()),
-  logging: z8.optional(z8.object({}).loose()),
-  prompts: z8.optional(
-    z8.looseObject({
-      listChanged: z8.optional(z8.boolean())
-    })
-  ),
-  resources: z8.optional(
-    z8.looseObject({
-      subscribe: z8.optional(z8.boolean()),
-      listChanged: z8.optional(z8.boolean())
-    })
-  ),
-  tools: z8.optional(
-    z8.looseObject({
-      listChanged: z8.optional(z8.boolean())
-    })
-  )
-});
-var InitializeResultSchema = ResultSchema.extend({
-  protocolVersion: z8.string(),
-  capabilities: ServerCapabilitiesSchema,
-  serverInfo: ClientOrServerImplementationSchema,
-  instructions: z8.optional(z8.string())
-});
-var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: z8.optional(z8.string())
-});
-var ToolSchema = z8.object({
-  name: z8.string(),
-  description: z8.optional(z8.string()),
-  inputSchema: z8.object({
-    type: z8.literal("object"),
-    properties: z8.optional(z8.object({}).loose())
-  }).loose()
-}).loose();
-var ListToolsResultSchema = PaginatedResultSchema.extend({
-  tools: z8.array(ToolSchema)
-});
-var TextContentSchema = z8.object({
-  type: z8.literal("text"),
-  text: z8.string()
-}).loose();
-var ImageContentSchema = z8.object({
-  type: z8.literal("image"),
-  data: z8.base64(),
-  mimeType: z8.string()
-}).loose();
-var ResourceContentsSchema = z8.object({
-  /**
-   * The URI of this resource.
-   */
-  uri: z8.string(),
-  /**
-   * The MIME type of this resource, if known.
-   */
-  mimeType: z8.optional(z8.string())
-}).loose();
-var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: z8.string()
-});
-var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: z8.base64()
-});
-var EmbeddedResourceSchema = z8.object({
-  type: z8.literal("resource"),
-  resource: z8.union([TextResourceContentsSchema, BlobResourceContentsSchema])
-}).loose();
-var CallToolResultSchema = ResultSchema.extend({
-  content: z8.array(
-    z8.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
-  ),
-  isError: z8.boolean().default(false).optional()
-}).or(
-  ResultSchema.extend({
-    toolResult: z8.unknown()
-  })
-);
-var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()])
-}).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
-  result: ResultSchema
-}).strict();
-var JSONRPCErrorSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
-  error: z9.object({
-    code: z9.number().int(),
-    message: z9.string(),
-    data: z9.optional(z9.unknown())
-  })
-}).strict();
-var JSONRPCNotificationSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION)
-}).merge(
-  z9.object({
-    method: z9.string(),
-    params: z9.optional(BaseParamsSchema)
-  })
-).strict();
-var JSONRPCMessageSchema = z9.union([
-  JSONRPCRequestSchema,
-  JSONRPCNotificationSchema,
-  JSONRPCResponseSchema,
-  JSONRPCErrorSchema
-]);
-var textUIPartSchema = z10.object({
-  type: z10.literal("text"),
-  text: z10.string(),
-  state: z10.enum(["streaming", "done"]).optional(),
-  providerMetadata: providerMetadataSchema.optional()
-});
-var reasoningUIPartSchema = z10.object({
-  type: z10.literal("reasoning"),
-  text: z10.string(),
-  state: z10.enum(["streaming", "done"]).optional(),
-  providerMetadata: providerMetadataSchema.optional()
-});
-var sourceUrlUIPartSchema = z10.object({
-  type: z10.literal("source-url"),
-  sourceId: z10.string(),
-  url: z10.string(),
-  title: z10.string().optional(),
-  providerMetadata: providerMetadataSchema.optional()
-});
-var sourceDocumentUIPartSchema = z10.object({
-  type: z10.literal("source-document"),
-  sourceId: z10.string(),
-  mediaType: z10.string(),
-  title: z10.string(),
-  filename: z10.string().optional(),
-  providerMetadata: providerMetadataSchema.optional()
-});
-var fileUIPartSchema = z10.object({
-  type: z10.literal("file"),
-  mediaType: z10.string(),
-  filename: z10.string().optional(),
-  url: z10.string(),
-  providerMetadata: providerMetadataSchema.optional()
-});
-var stepStartUIPartSchema = z10.object({
-  type: z10.literal("step-start")
-});
-var dataUIPartSchema = z10.object({
-  type: z10.string().startsWith("data-"),
-  id: z10.string().optional(),
-  data: z10.unknown()
-});
-var dynamicToolUIPartSchemas = [
-  z10.object({
-    type: z10.literal("dynamic-tool"),
-    toolName: z10.string(),
-    toolCallId: z10.string(),
-    state: z10.literal("input-streaming"),
-    input: z10.unknown().optional(),
-    output: z10.never().optional(),
-    errorText: z10.never().optional()
-  }),
-  z10.object({
-    type: z10.literal("dynamic-tool"),
-    toolName: z10.string(),
-    toolCallId: z10.string(),
-    state: z10.literal("input-available"),
-    input: z10.unknown(),
-    output: z10.never().optional(),
-    errorText: z10.never().optional(),
-    callProviderMetadata: providerMetadataSchema.optional()
-  }),
-  z10.object({
-    type: z10.literal("dynamic-tool"),
-    toolName: z10.string(),
-    toolCallId: z10.string(),
-    state: z10.literal("output-available"),
-    input: z10.unknown(),
-    output: z10.unknown(),
-    errorText: z10.never().optional(),
-    callProviderMetadata: providerMetadataSchema.optional(),
-    preliminary: z10.boolean().optional()
-  }),
-  z10.object({
-    type: z10.literal("dynamic-tool"),
-    toolName: z10.string(),
-    toolCallId: z10.string(),
-    state: z10.literal("output-error"),
-    input: z10.unknown(),
-    output: z10.never().optional(),
-    errorText: z10.string(),
-    callProviderMetadata: providerMetadataSchema.optional()
-  })
-];
-var toolUIPartSchemas = [
-  z10.object({
-    type: z10.string().startsWith("tool-"),
-    toolCallId: z10.string(),
-    state: z10.literal("input-streaming"),
-    input: z10.unknown().optional(),
-    output: z10.never().optional(),
-    errorText: z10.never().optional()
-  }),
-  z10.object({
-    type: z10.string().startsWith("tool-"),
-    toolCallId: z10.string(),
-    state: z10.literal("input-available"),
-    input: z10.unknown(),
-    output: z10.never().optional(),
-    errorText: z10.never().optional(),
-    callProviderMetadata: providerMetadataSchema.optional()
-  }),
-  z10.object({
-    type: z10.string().startsWith("tool-"),
-    toolCallId: z10.string(),
-    state: z10.literal("output-available"),
-    input: z10.unknown(),
-    output: z10.unknown(),
-    errorText: z10.never().optional(),
-    callProviderMetadata: providerMetadataSchema.optional(),
-    preliminary: z10.boolean().optional()
-  }),
-  z10.object({
-    type: z10.string().startsWith("tool-"),
-    toolCallId: z10.string(),
-    state: z10.literal("output-error"),
-    input: z10.unknown(),
-    output: z10.never().optional(),
-    errorText: z10.string(),
-    callProviderMetadata: providerMetadataSchema.optional()
-  })
-];
-var uiMessageSchema = z10.object({
-  id: z10.string(),
-  role: z10.enum(["system", "user", "assistant"]),
-  metadata: z10.unknown().optional(),
-  parts: z10.array(
-    z10.union([
-      textUIPartSchema,
-      reasoningUIPartSchema,
-      sourceUrlUIPartSchema,
-      sourceDocumentUIPartSchema,
-      fileUIPartSchema,
-      stepStartUIPartSchema,
-      dataUIPartSchema,
-      ...dynamicToolUIPartSchemas,
-      ...toolUIPartSchemas
-    ])
-  )
-});
+    }
+    const fallbackConfig = {
+      ...vercelToolConfig,
+      inputSchema: fallbackInputSchema
+    };
+    return tool(fallbackConfig);
+  }
+}
+function convertMastraToolsToVercelTools(mastraTools) {
+  return Object.fromEntries(
+    Object.entries(mastraTools).map(([name, mastraTool]) => {
+      const pureToolName = extractPureToolName(name);
+      return [
+        pureToolName,
+        convertMastraToolToVercelTool(pureToolName, mastraTool, {
+          originalName: name
+        })
+      ];
+    })
+  );
+}
 
-// utils/chat-helpers.ts
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createOllama } from "ollama-ai-provider";
-var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
-  if (!modelDefinition?.id || !modelDefinition?.provider) {
-    throw new Error(
-      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
-    );
+// ../shared/http-tool-calls.ts
+function flattenToolsets(toolsets) {
+  const flattened = {};
+  for (const serverTools of Object.values(toolsets || {})) {
+    if (serverTools && typeof serverTools === "object") {
+      Object.assign(flattened, serverTools);
+    }
   }
-  switch (modelDefinition.provider) {
-    case "anthropic":
-      return createAnthropic({ apiKey })(modelDefinition.id);
-    case "openai":
-      return createOpenAI({ apiKey })(modelDefinition.id);
-    case "deepseek":
-      return createOpenAI({ apiKey, baseURL: "https://api.deepseek.com/v1" })(
-        modelDefinition.id
-      );
-    case "google":
-      return createGoogleGenerativeAI({ apiKey })(modelDefinition.id);
-    case "ollama":
-      const baseUrl = ollamaBaseUrl || "http://localhost:11434/api";
-      return createOllama({
-        baseURL: `${baseUrl}`
-      })(modelDefinition.id, {
-        simulateStreaming: true
-      });
-    default:
-      throw new Error(
-        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
-      );
+  return flattened;
+}
+function buildIndexWithAliases(tools2) {
+  const index = {};
+  for (const [toolName, tool2] of Object.entries(tools2 || {})) {
+    if (!tool2 || typeof tool2 !== "object" || !("execute" in tool2)) continue;
+    const idx = toolName.indexOf("_");
+    const pure = idx > -1 && idx < toolName.length - 1 ? toolName.slice(idx + 1) : toolName;
+    if (!(toolName in index)) index[toolName] = tool2;
+    if (!(pure in index)) index[pure] = tool2;
+  }
+  return index;
+}
+var hasUnresolvedToolCalls = (messages) => {
+  const toolCallIds = /* @__PURE__ */ new Set();
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (!msg) continue;
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const c of msg.content) {
+        if (c?.type === "tool-call") toolCallIds.add(c.toolCallId);
+      }
+    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
+      for (const c of msg.content) {
+        if (c?.type === "tool-result") toolResultIds.add(c.toolCallId);
+      }
+    }
   }
+  for (const id of toolCallIds) if (!toolResultIds.has(id)) return true;
+  return false;
 };
+async function executeToolCallsFromMessages(messages, options) {
+  let tools2 = {};
+  if (options.client) {
+    const toolsets = await options.client.getToolsets();
+    tools2 = flattenToolsets(toolsets);
+  } else if (options.toolsets) {
+    tools2 = flattenToolsets(options.toolsets);
+  } else {
+    tools2 = options.tools;
+  }
+  const index = buildIndexWithAliases(tools2);
+  const existingToolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (!msg || msg.role !== "tool" || !Array.isArray(msg.content))
+      continue;
+    for (const c of msg.content) {
+      if (c?.type === "tool-result") existingToolResultIds.add(c.toolCallId);
+    }
+  }
+  const toolResultsToAdd = [];
+  for (const msg of messages) {
+    if (!msg || msg.role !== "assistant" || !Array.isArray(msg.content))
+      continue;
+    for (const content of msg.content) {
+      if (content?.type === "tool-call" && !existingToolResultIds.has(content.toolCallId)) {
+        try {
+          const toolName = content.toolName;
+          const tool2 = index[toolName];
+          if (!tool2) throw new Error(`Tool '${toolName}' not found`);
+          const input = content.input || {};
+          const result = await tool2.execute({ context: input });
+          let output;
+          if (result && typeof result === "object" && result.content) {
+            const rc = result.content;
+            if (rc && typeof rc === "object" && "text" in rc && typeof rc.text === "string") {
+              output = { type: "text", value: rc.text };
+            } else if (rc && typeof rc === "object" && "type" in rc && "value" in rc) {
+              output = {
+                type: rc.type || "text",
+                value: rc.value
+              };
+            } else {
+              output = { type: "text", value: JSON.stringify(rc) };
+            }
+          } else {
+            output = { type: "text", value: String(result) };
+          }
+          const toolResultMessage = {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: content.toolCallId,
+                toolName,
+                output
+              }
+            ]
+          };
+          toolResultsToAdd.push(toolResultMessage);
+        } catch (error) {
+          const errorOutput = {
+            type: "error-text",
+            value: error instanceof Error ? error.message : String(error)
+          };
+          const errorToolResultMessage = {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: content.toolCallId,
+                toolName: content.toolName,
+                output: errorOutput
+              }
+            ]
+          };
+          toolResultsToAdd.push(errorToolResultMessage);
+        }
+      }
+    }
+  }
+  messages.push(...toolResultsToAdd);
+}
 
 // routes/mcp/chat.ts
-var DEBUG_ENABLED = process.env.MCP_DEBUG !== "false";
+import { zodToJsonSchema as zodToJsonSchema3 } from "@alcyone-labs/zod-to-json-schema";
 var ELICITATION_TIMEOUT = 3e5;
 var MAX_AGENT_STEPS = 10;
-var dbg = (...args) => {
-  if (DEBUG_ENABLED) console.log("[mcp/chat]", ...args);
-};
+var BACKEND_FETCH_ERROR_MESSAGE = "We are having difficulties processing your message right now. Please try again later.";
 try {
   process.setMaxListeners?.(50);
 } catch {
@@ -3155,40 +845,82 @@ var sendSseEvent = (controller, encoder, event) => {
 
 `));
 };
-var handleAgentStepFinish = (streamingContext, text2, toolCalls, toolResults) => {
+var sendBackendErrorText = (streamingContext) => {
+  sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+    type: "text",
+    content: BACKEND_FETCH_ERROR_MESSAGE
+  });
+};
+var sendBackendRequest = async (baseUrl, authHeader, body, streamingContext) => {
   try {
-    if (toolCalls && Array.isArray(toolCalls)) {
-      for (const call of toolCalls) {
-        const currentToolCallId = ++streamingContext.toolCallId;
-        streamingContext.lastEmittedToolCallId = currentToolCallId;
-        if (streamingContext.controller && streamingContext.encoder) {
-          sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-            type: "tool_call",
-            toolCall: {
-              id: currentToolCallId,
-              name: call.name || call.toolName,
-              parameters: call.params || call.args || {},
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              status: "executing"
-            }
-          });
+    const res = await fetch(`${baseUrl}/streaming`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...authHeader ? { Authorization: authHeader } : {}
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      sendBackendErrorText(streamingContext);
+      return null;
+    }
+    try {
+      const data = await res.json();
+      return data;
+    } catch {
+      sendBackendErrorText(streamingContext);
+      return null;
+    }
+  } catch {
+    sendBackendErrorText(streamingContext);
+    return null;
+  }
+};
+var handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults, emitToolEvents = true) => {
+  try {
+    if (emitToolEvents) {
+      if (toolCalls && Array.isArray(toolCalls)) {
+        for (const call of toolCalls) {
+          const currentToolCallId = ++streamingContext.toolCallId;
+          streamingContext.lastEmittedToolCallId = currentToolCallId;
+          if (streamingContext.controller && streamingContext.encoder) {
+            sendSseEvent(
+              streamingContext.controller,
+              streamingContext.encoder,
+              {
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCallId,
+                  name: call.name || call.toolName,
+                  parameters: call.params || call.args || {},
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  status: "executing"
+                }
+              }
+            );
+          }
         }
       }
-    }
-    if (toolResults && Array.isArray(toolResults)) {
-      for (const result of toolResults) {
-        const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
-        if (streamingContext.controller && streamingContext.encoder) {
-          sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-            type: "tool_result",
-            toolResult: {
-              id: currentToolCallId,
-              toolCallId: currentToolCallId,
-              result: result.result,
-              error: result.error,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            }
-          });
+      if (toolResults && Array.isArray(toolResults)) {
+        for (const result of toolResults) {
+          const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
+          if (streamingContext.controller && streamingContext.encoder) {
+            sendSseEvent(
+              streamingContext.controller,
+              streamingContext.encoder,
+              {
+                type: "tool_result",
+                toolResult: {
+                  id: currentToolCallId,
+                  toolCallId: currentToolCallId,
+                  result: result.result,
+                  error: result.error,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                }
+              }
+            );
+          }
         }
       }
     }
@@ -3197,7 +929,7 @@ var handleAgentStepFinish = (streamingContext, text2, toolCalls, toolResults) =>
       sendSseEvent(streamingContext.controller, streamingContext.encoder, {
         type: "trace_step",
         step: streamingContext.stepIndex,
-        text: text2,
+        text,
         toolCalls: (toolCalls || []).map((c) => ({
           name: c.name || c.toolName,
           params: c.params || c.args || {}
@@ -3209,159 +941,252 @@ var handleAgentStepFinish = (streamingContext, text2, toolCalls, toolResults) =>
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
-  } catch (err) {
-    dbg("onStepFinish error", err);
+  } catch {
   }
 };
-var streamAgentResponse = async (streamingContext, stream) => {
-  let hasContent = false;
-  let chunkCount = 0;
-  for await (const chunk of stream.fullStream) {
-    chunkCount++;
-    if (chunk.type === "text-delta" && chunk.textDelta) {
-      hasContent = true;
-      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-        type: "text",
-        content: chunk.textDelta
-      });
+var createStreamingResponse = async (model, aiSdkTools, messages, streamingContext, provider, temperature, systemPrompt) => {
+  const messageHistory = (messages || []).map((m) => {
+    switch (m.role) {
+      case "system":
+        return { role: "system", content: m.content };
+      case "user":
+        return { role: "user", content: m.content };
+      case "assistant":
+        return { role: "assistant", content: m.content };
+      default:
+        return { role: "user", content: m.content };
     }
-    if (chunk.type === "tool-call" && chunk.toolName) {
-      const currentToolCallId = ++streamingContext.toolCallId;
-      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-        type: "tool_call",
-        toolCall: {
-          id: currentToolCallId,
-          name: chunk.toolName,
-          parameters: chunk.args || {},
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          status: "executing"
-        }
-      });
-    }
-    if (chunk.type === "tool-result" && chunk.result !== void 0) {
-      const currentToolCallId = streamingContext.toolCallId;
-      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-        type: "tool_result",
-        toolResult: {
-          id: currentToolCallId,
-          toolCallId: currentToolCallId,
-          result: chunk.result,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  let steps = 0;
+  while (steps < MAX_AGENT_STEPS) {
+    let accumulatedText = "";
+    const iterationToolCalls = [];
+    const iterationToolResults = [];
+    const streamResult = await streamText({
+      model,
+      system: systemPrompt || "You are a helpful assistant with access to MCP tools.",
+      temperature: temperature ?? getDefaultTemperatureByProvider(provider),
+      tools: aiSdkTools,
+      messages: messageHistory,
+      onChunk: async (chunk) => {
+        switch (chunk.chunk.type) {
+          case "text-delta":
+          case "reasoning-delta": {
+            const text = chunk.chunk.text;
+            if (text) {
+              accumulatedText += text;
+              sendSseEvent(
+                streamingContext.controller,
+                streamingContext.encoder,
+                {
+                  type: "text",
+                  content: text
+                }
+              );
+            }
+            break;
+          }
+          case "tool-input-start": {
+            break;
+          }
+          case "tool-call": {
+            const currentToolCallId = ++streamingContext.toolCallId;
+            streamingContext.lastEmittedToolCallId = currentToolCallId;
+            const name = chunk.chunk.toolName || chunk.chunk.name;
+            const parameters = chunk.chunk.input ?? chunk.chunk.parameters ?? chunk.chunk.args ?? {};
+            iterationToolCalls.push({ name, params: parameters });
+            sendSseEvent(
+              streamingContext.controller,
+              streamingContext.encoder,
+              {
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCallId,
+                  name,
+                  parameters,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  status: "executing"
+                }
+              }
+            );
+            break;
+          }
+          case "tool-result": {
+            const result = chunk.chunk.output ?? chunk.chunk.result ?? chunk.chunk.value;
+            const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : streamingContext.toolCallId;
+            iterationToolResults.push({ result });
+            sendSseEvent(
+              streamingContext.controller,
+              streamingContext.encoder,
+              {
+                type: "tool_result",
+                toolResult: {
+                  id: currentToolCallId,
+                  toolCallId: currentToolCallId,
+                  result,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                }
+              }
+            );
+            break;
+          }
+          default:
+            break;
         }
-      });
-    }
-    if (chunk.type === "error" && chunk.error) {
-      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-        type: "error",
-        error: chunk.error instanceof Error ? chunk.error.message : String(chunk.error)
-      });
-    }
-    if (chunk.type === "finish") {
-      break;
-    }
-  }
-  dbg("Streaming finished", { hasContent, chunkCount });
-  return { hasContent, chunkCount };
-};
-var fallbackToCompletion = async (agent, messages, streamingContext, provider, temperature) => {
-  try {
-    const result = await agent.generate(messages, {
-      temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature
-    });
-    console.log("result", result);
-    if (result.text && result.text.trim()) {
-      sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-        type: "text",
-        content: result.text
-      });
-    }
-  } catch (fallbackErr) {
-    sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-      type: "error",
-      error: fallbackErr instanceof Error ? fallbackErr.message : "Unknown error"
-    });
-  }
-};
-var fallbackToStreamV1Method = async (agent, messages, streamingContext, provider, temperature) => {
-  try {
-    const stream = await agent.stream(messages, {
-      maxSteps: MAX_AGENT_STEPS,
-      temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature,
-      onStepFinish: ({ text: text2, toolCalls, toolResults }) => {
-        handleAgentStepFinish(streamingContext, text2, toolCalls, toolResults);
       }
     });
-    let hasContent = false;
-    let chunkCount = 0;
-    for await (const chunk of stream.textStream) {
-      if (chunk && chunk.trim()) {
-        hasContent = true;
-        chunkCount++;
-        sendSseEvent(streamingContext.controller, streamingContext.encoder, {
-          type: "text",
-          content: chunk
-        });
-      }
-    }
-    dbg("Stream method finished", { hasContent, chunkCount });
-    if (!hasContent) {
-      dbg("No content from textStream; falling back to completion");
-      await fallbackToCompletion(
-        agent,
-        messages,
-        streamingContext,
-        provider,
-        temperature
-      );
-    }
-  } catch (streamErr) {
-    dbg("Stream method failed", streamErr);
-    await fallbackToCompletion(
-      agent,
-      messages,
+    await streamResult.consumeStream();
+    handleAgentStepFinish(
       streamingContext,
-      provider,
-      temperature
+      accumulatedText,
+      iterationToolCalls,
+      iterationToolResults,
+      false
     );
+    const resp = await streamResult.response;
+    const responseMessages = resp?.messages || [];
+    if (responseMessages.length) {
+      messageHistory.push(...responseMessages);
+      for (const m of responseMessages) {
+        if (m.role === "tool") {
+          const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
+          const value = m.content;
+          iterationToolResults.push({ result: value });
+          sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+            type: "tool_result",
+            toolResult: {
+              id: currentToolCallId,
+              toolCallId: currentToolCallId,
+              result: value,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+        }
+      }
+    }
+    steps++;
+    const finishReason = await streamResult.finishReason;
+    const shouldContinue = finishReason === "tool-calls" || accumulatedText.length === 0 && iterationToolResults.length > 0;
+    if (!shouldContinue) break;
   }
+  sendSseEvent(streamingContext.controller, streamingContext.encoder, {
+    type: "elicitation_complete"
+  });
+  sendSseEvent(
+    streamingContext.controller,
+    streamingContext.encoder,
+    "[DONE]"
+  );
 };
-var createStreamingResponse = async (agent, messages, streamingContext, provider, temperature) => {
-  try {
-    const stream = await agent.streamVNext(messages, {
-      stopWhen: stepCountIs(MAX_AGENT_STEPS),
-      modelSettings: {
-        temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature
+var sendMessagesToBackend = async (messages, streamingContext, mcpClientManager, baseUrl, authHeader, selectedServers) => {
+  const messageHistory = (messages || []).map((m) => {
+    switch (m.role) {
+      case "system":
+        return { role: "system", content: m.content };
+      case "user":
+        return { role: "user", content: m.content };
+      case "assistant":
+        return { role: "assistant", content: m.content };
+      default:
+        return { role: "user", content: m.content };
+    }
+  });
+  const flatTools = await mcpClientManager.getFlattenedToolsetsForEnabledServers(
+    selectedServers
+  );
+  const toolDefs = Object.entries(flatTools).map(([name, tool2]) => ({
+    name,
+    description: tool2?.description,
+    inputSchema: zodToJsonSchema3(tool2?.inputSchema)
+  }));
+  if (!baseUrl) {
+    throw new Error("CONVEX_HTTP_URL is not set");
+  }
+  let steps = 0;
+  while (steps < MAX_AGENT_STEPS) {
+    const data = await sendBackendRequest(
+      baseUrl,
+      authHeader,
+      {
+        tools: toolDefs,
+        messages: JSON.stringify(messageHistory)
       },
-      onStepFinish: ({ text: text2, toolCalls, toolResults }) => {
-        handleAgentStepFinish(streamingContext, text2, toolCalls, toolResults);
+      streamingContext
+    );
+    if (!data) break;
+    if (data?.ok && Array.isArray(data.messages)) {
+      for (const msg of data.messages) {
+        messageHistory.push(msg);
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+          for (const c of msg.content) {
+            if (c?.type === "text" && typeof c.text === "string") {
+              sendSseEvent(
+                streamingContext.controller,
+                streamingContext.encoder,
+                {
+                  type: "text",
+                  content: c.text
+                }
+              );
+            } else if (c?.type === "tool-call") {
+              const currentToolCallId = ++streamingContext.toolCallId;
+              streamingContext.lastEmittedToolCallId = currentToolCallId;
+              sendSseEvent(
+                streamingContext.controller,
+                streamingContext.encoder,
+                {
+                  type: "tool_call",
+                  toolCall: {
+                    id: currentToolCallId,
+                    name: c.toolName || c.name,
+                    parameters: c.input || c.parameters || c.args || {},
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                    status: "executing"
+                  }
+                }
+              );
+            }
+          }
+        }
       }
-    });
-    const { hasContent } = await streamAgentResponse(streamingContext, stream);
-    if (!hasContent) {
-      dbg("No content from fullStream; falling back to completion");
-      await fallbackToCompletion(
-        agent,
-        messages,
-        streamingContext,
-        provider,
-        temperature
-      );
+    } else {
+      sendBackendErrorText(streamingContext);
+      break;
     }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("V1 models are not supported for streamVNext")) {
-      dbg(
-        "streamVNext not supported for this model, falling back to stream method"
-      );
-      await fallbackToStreamV1Method(
-        agent,
-        messages,
-        streamingContext,
-        provider,
-        temperature
-      );
+    const beforeLen = messageHistory.length;
+    if (hasUnresolvedToolCalls(messageHistory)) {
+      await executeToolCallsFromMessages(messageHistory, {
+        tools: flatTools
+      });
+      const newMsgs = messageHistory.slice(beforeLen);
+      for (const m of newMsgs) {
+        if (m.role === "tool" && Array.isArray(m.content)) {
+          for (const tc of m.content) {
+            if (tc.type === "tool-result") {
+              const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
+              const out = tc.output;
+              const value = out && typeof out === "object" && "value" in out ? out.value : out;
+              sendSseEvent(
+                streamingContext.controller,
+                streamingContext.encoder,
+                {
+                  type: "tool_result",
+                  toolResult: {
+                    id: currentToolCallId,
+                    toolCallId: currentToolCallId,
+                    result: value,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  }
+                }
+              );
+            }
+          }
+        }
+      }
     } else {
-      throw error;
+      break;
     }
+    steps++;
   }
   sendSseEvent(streamingContext.controller, streamingContext.encoder, {
     type: "elicitation_complete"
@@ -3383,7 +1208,7 @@ chat.post("/", async (c) => {
       systemPrompt,
       temperature,
       messages,
-      ollamaBaseUrl,
+      ollamaBaseUrl: _ollama_unused,
       action,
       requestId,
       response
@@ -3413,24 +1238,36 @@ chat.post("/", async (c) => {
       }
       return c.json({ success: true });
     }
-    if (!model?.id || !apiKey || !messages) {
+    if (!messages) {
       return c.json(
         {
           success: false,
-          error: "model (with id), apiKey, and messages are required"
+          error: "messages are required"
         },
         400
       );
     }
-    const llmModel = createLlmModel(model, apiKey, ollamaBaseUrl);
-    const toolsets = await mcpClientManager.getFlattenedToolsetsForEnabledServers();
-    const agent = new Agent({
-      name: "MCP Chat Agent",
-      instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
-      model: llmModel,
-      tools: toolsets
-    });
+    const sendToBackend = provider === "meta" && Boolean(requestData.sendMessagesToBackend);
+    if (!sendToBackend && (!model?.id || !apiKey)) {
+      return c.json(
+        {
+          success: false,
+          error: "model (with id) and apiKey are required"
+        },
+        400
+      );
+    }
+    if (sendToBackend && !process.env.CONVEX_HTTP_URL) {
+      return c.json(
+        {
+          success: false,
+          error: "Server missing CONVEX_HTTP_URL configuration"
+        },
+        500
+      );
+    }
     const encoder = new TextEncoder2();
+    const authHeader = c.req.header("authorization") || void 0;
     const readableStream = new ReadableStream({
       async start(controller) {
         const streamingContext = {
@@ -3475,13 +1312,35 @@ chat.post("/", async (c) => {
           });
         });
         try {
-          await createStreamingResponse(
-            agent,
-            messages,
-            streamingContext,
-            provider,
-            temperature
-          );
+          if (sendToBackend) {
+            await sendMessagesToBackend(
+              messages,
+              streamingContext,
+              mcpClientManager,
+              process.env.CONVEX_HTTP_URL,
+              authHeader,
+              requestData.selectedServers
+            );
+          } else {
+            const flatTools = await mcpClientManager.getFlattenedToolsetsForEnabledServers(
+              requestData.selectedServers
+            );
+            const aiSdkTools = convertMastraToolsToVercelTools(flatTools);
+            const llmModel = createLlmModel(
+              model,
+              apiKey || "",
+              _ollama_unused
+            );
+            await createStreamingResponse(
+              llmModel,
+              aiSdkTools,
+              messages,
+              streamingContext,
+              provider,
+              temperature,
+              systemPrompt
+            );
+          }
         } catch (error) {
           sendSseEvent(controller, encoder, {
             type: "error",
@@ -3502,7 +1361,11 @@ chat.post("/", async (c) => {
     });
   } catch (error) {
     console.error("[mcp/chat] Error in chat API:", error);
-    mcpClientManager.clearElicitationCallback();
+    try {
+      mcpClientManager.clearElicitationCallback();
+    } catch (cleanupError) {
+      console.error("[mcp/chat] Error during cleanup:", cleanupError);
+    }
     return c.json(
       {
         success: false,
@@ -3699,13 +1562,13 @@ function normalizeToolName(toolName, serverIds) {
   }
   return toolName;
 }
-function extractToolSchema(tool) {
-  if (!tool?.inputSchema) return {};
-  const jsonSchema2 = tool.inputSchema.toJSON?.();
-  if (jsonSchema2 && typeof jsonSchema2 === "object") {
-    return jsonSchema2;
+function extractToolSchema(tool2) {
+  if (!tool2?.inputSchema) return {};
+  const jsonSchema = tool2.inputSchema.toJSON?.();
+  if (jsonSchema && typeof jsonSchema === "object") {
+    return jsonSchema;
   }
-  const zodDef = tool.inputSchema._def;
+  const zodDef = tool2.inputSchema._def;
   if (zodDef?.typeName === "ZodObject") {
     const baseSchema = {
       type: "object",
@@ -3795,12 +1658,12 @@ tests.post("/run-all", async (c) => {
             try {
               let serverConfigs = {};
               if (test.selectedServers && test.selectedServers.length > 0) {
-                for (const name17 of test.selectedServers) {
-                  if (allServers[name17]) serverConfigs[name17] = allServers[name17];
+                for (const name of test.selectedServers) {
+                  if (allServers[name]) serverConfigs[name] = allServers[name];
                 }
               } else {
-                for (const [name17, cfg] of Object.entries(allServers)) {
-                  serverConfigs[name17] = cfg;
+                for (const [name, cfg] of Object.entries(allServers)) {
+                  serverConfigs[name] = cfg;
                 }
               }
               const validation = validateMultipleServerConfigs(serverConfigs);
@@ -3815,9 +1678,9 @@ tests.post("/run-all", async (c) => {
               client = createMCPClientWithMultipleConnections(finalServers);
               const tools2 = await client.getTools();
               const toolsSchemas = Object.entries(tools2).map(
-                ([name17, tool]) => ({
-                  toolName: name17,
-                  inputSchema: extractToolSchema(tool)
+                ([name, tool2]) => ({
+                  toolName: name,
+                  inputSchema: extractToolSchema(tool2)
                 })
               );
               const runId = `${Date.now()}-${test.id}`;
@@ -3864,12 +1727,12 @@ tests.post("/run-all", async (c) => {
               let state = startJson;
               const serverIds = Object.keys(finalServers);
               while (state.kind === "tool_call") {
-                const name17 = state.toolName;
+                const name = state.toolName;
                 const args = state.args || {};
-                const tool = tools2[name17];
+                const tool2 = tools2[name];
                 try {
-                  const result = await tool?.execute({ context: args });
-                  calledTools.add(name17);
+                  const result = await tool2?.execute({ context: args });
+                  calledTools.add(name);
                   controller.enqueue(
                     encoder.encode(
                       `data: ${JSON.stringify({
@@ -3877,7 +1740,7 @@ tests.post("/run-all", async (c) => {
                         testId: test.id,
                         step: ++step,
                         text: "Executed tool",
-                        toolCalls: [normalizeToolName(name17, serverIds)],
+                        toolCalls: [normalizeToolName(name, serverIds)],
                         toolResults: [result]
                       })}
 
@@ -3906,7 +1769,7 @@ tests.post("/run-all", async (c) => {
                             {
                               type: "tool-result",
                               toolCallId: state.toolCallId,
-                              toolName: name17,
+                              toolName: name,
                               output: result
                             }
                           ]
@@ -3933,7 +1796,7 @@ tests.post("/run-all", async (c) => {
                   state = stepJson;
                 } catch (err) {
                   throw new Error(
-                    `Tool '${name17}' failed: ${err instanceof Error ? err.message : String(err)}`
+                    `Tool '${name}' failed: ${err instanceof Error ? err.message : String(err)}`
                   );
                 }
               }
@@ -4048,7 +1911,7 @@ var oauth_default = oauth;
 
 // routes/mcp/export.ts
 import { Hono as Hono9 } from "hono";
-import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
+import { zodToJsonSchema as zodToJsonSchema4 } from "@alcyone-labs/zod-to-json-schema";
 var exporter = new Hono9();
 exporter.post("/server", async (c) => {
   try {
@@ -4063,17 +1926,17 @@ exporter.post("/server", async (c) => {
     }
     const flattenedTools = await mcp2.getToolsetsForServer(serverId);
     const tools2 = [];
-    for (const [name17, tool] of Object.entries(flattenedTools)) {
-      let inputSchema = tool.inputSchema;
+    for (const [name, tool2] of Object.entries(flattenedTools)) {
+      let inputSchema = tool2.inputSchema;
       try {
-        inputSchema = zodToJsonSchema3(inputSchema);
+        inputSchema = zodToJsonSchema4(inputSchema);
       } catch {
       }
       tools2.push({
-        name: name17,
-        description: tool.description,
+        name,
+        description: tool2.description,
         inputSchema,
-        outputSchema: tool.outputSchema
+        outputSchema: tool2.outputSchema
       });
     }
     const resources2 = mcp2.getResourcesForServer(serverId).map((r) => ({
@@ -4867,8 +2730,8 @@ var interceptor_default = interceptor;
 import { Hono as Hono11 } from "hono";
 
 // services/mcp-http-bridge.ts
-import { z as z11 } from "zod";
-import { zodToJsonSchema as zodToJsonSchema4 } from "zod-to-json-schema";
+import { z as z2 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema5 } from "@alcyone-labs/zod-to-json-schema";
 function buildInitializeResult(serverId, mode) {
   if (mode === "adapter") {
     return {
@@ -4899,8 +2762,8 @@ function buildInitializeResult(serverId, mode) {
 function toJsonSchemaMaybe(schema) {
   try {
     if (schema && typeof schema === "object") {
-      if (schema instanceof z11.ZodType || "_def" in schema && "parse" in schema) {
-        return zodToJsonSchema4(schema);
+      if (schema instanceof z2.ZodType || "_def" in schema && "parse" in schema) {
+        return zodToJsonSchema5(schema);
       }
     }
   } catch {
@@ -4925,11 +2788,11 @@ async function handleJsonRpc(serverId, body, clientManager, mode) {
       }
       case "tools/list": {
         const toolsets = await clientManager.getToolsetsForServer(serverId);
-        const tools2 = Object.keys(toolsets).map((name17) => ({
-          name: name17,
-          description: toolsets[name17].description,
-          inputSchema: toJsonSchemaMaybe(toolsets[name17].inputSchema),
-          outputSchema: toJsonSchemaMaybe(toolsets[name17].outputSchema)
+        const tools2 = Object.keys(toolsets).map((name) => ({
+          name,
+          description: toolsets[name].description,
+          inputSchema: toJsonSchemaMaybe(toolsets[name].inputSchema),
+          outputSchema: toJsonSchemaMaybe(toolsets[name].outputSchema)
         }));
         return respond({ result: { tools: tools2 } });
       }
@@ -5344,9 +3207,14 @@ var MCPJamClientManager = class {
     });
     return flattenedTools;
   }
-  async getFlattenedToolsetsForEnabledServers() {
+  async getFlattenedToolsetsForEnabledServers(serverNameFilter) {
     const allFlattenedTools = {};
+    const allServerIdsFromFilter = serverNameFilter?.map(
+      (serverName) => this.getServerIdForName(serverName)
+    );
     for (const [serverId, client] of this.mcpClients.entries()) {
+      if (serverNameFilter && !allServerIdsFromFilter?.includes(serverId))
+        continue;
       if (this.getConnectionStatus(serverId) !== "connected") continue;
       try {
         const toolsets = await client.getToolsets();
@@ -5471,12 +3339,12 @@ var MCPJamClientManager = class {
     if (!client) return;
     const toolsets = await client.getToolsets();
     const flattenedTools = this.flattenToolsets(toolsets);
-    for (const [name17, tool] of Object.entries(flattenedTools)) {
-      this.toolRegistry.set(`${serverId}:${name17}`, {
-        name: name17,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        outputSchema: tool.outputSchema,
+    for (const [name, tool2] of Object.entries(flattenedTools)) {
+      this.toolRegistry.set(`${serverId}:${name}`, {
+        name,
+        description: tool2.description,
+        inputSchema: tool2.inputSchema,
+        outputSchema: tool2.outputSchema,
         serverId
       });
     }
@@ -5535,16 +3403,16 @@ var MCPJamClientManager = class {
   }
   async executeToolDirect(toolName, parameters = {}) {
     let serverId = "";
-    let name17 = toolName;
+    let name = toolName;
     if (toolName.includes(":")) {
       const [sid, n] = toolName.split(":", 2);
       serverId = this.resolveServerId(sid) || "";
-      name17 = n;
+      name = n;
     } else {
-      for (const tool2 of this.toolRegistry.values()) {
-        if (tool2.name === toolName) {
-          serverId = tool2.serverId;
-          name17 = toolName;
+      for (const tool3 of this.toolRegistry.values()) {
+        if (tool3.name === toolName) {
+          serverId = tool3.serverId;
+          name = toolName;
           break;
         }
       }
@@ -5556,7 +3424,7 @@ var MCPJamClientManager = class {
           const flattenedTools2 = this.flattenToolsets(toolsets2);
           if (flattenedTools2[toolName]) {
             serverId = clientServerId;
-            name17 = toolName;
+            name = toolName;
             break;
           }
         } catch {
@@ -5571,10 +3439,10 @@ var MCPJamClientManager = class {
       throw new Error(`No MCP client available for server: ${serverId}`);
     const toolsets = await client.getToolsets();
     const flattenedTools = this.flattenToolsets(toolsets);
-    const tool = flattenedTools[name17];
-    if (!tool)
-      throw new Error(`Tool '${name17}' not found in server '${serverId}'`);
-    const schema = tool.inputSchema;
+    const tool2 = flattenedTools[name];
+    if (!tool2)
+      throw new Error(`Tool '${name}' not found in server '${serverId}'`);
+    const schema = tool2.inputSchema;
     const hasContextProperty = schema && typeof schema === "object" && schema.properties && Object.prototype.hasOwnProperty.call(
       schema.properties,
       "context"
@@ -5587,7 +3455,7 @@ var MCPJamClientManager = class {
     for (const args of attempts) {
       try {
         console.log("args", args);
-        const result = await tool.execute(args);
+        const result = await tool2.execute(args);
         if (result && result.isError) {
           const errorText = result.content && result.content[0] && result.content[0].text ? result.content[0].text : "Unknown error";
           throw new Error(errorText);
@@ -5707,8 +3575,8 @@ function getMCPConfigFromEnv() {
       console.log("Parsed config data:", config);
       if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
         const servers2 = Object.entries(config.mcpServers).map(
-          ([name17, serverConfig]) => ({
-            name: name17,
+          ([name, serverConfig]) => ({
+            name,
             type: serverConfig.type || "stdio",
             // Default to stdio if not specified
             command: serverConfig.command,
@@ -5756,17 +3624,26 @@ try {
 } catch {
 }
 var app = new Hono13();
+try {
+  const envFile = process.env.NODE_ENV === "production" ? ".env.production" : ".env.development";
+  dotenv.config({ path: envFile });
+  if (!process.env.CONVEX_HTTP_URL) {
+    dotenv.config();
+  }
+} catch (error) {
+  console.warn("[startup] Failed loading env files", error);
+}
 var mcpJamClientManager = new MCPJamClientManager();
 app.use("*", async (c, next) => {
   c.mcpJamClientManager = mcpJamClientManager;
   await next();
 });
 app.use("*", logger());
-var serverPort = process.env.PORT || "3000";
+var serverPort = process.env.PORT || "3001";
 var corsOrigins = [
   `http://localhost:${serverPort}`,
   "http://localhost:3000"
-  // Keep for development
+  // Keep for frontend development
 ];
 app.use(
   "*",
@@ -5902,7 +3779,7 @@ if (process.env.NODE_ENV === "production") {
     });
   });
 }
-var port = parseInt(process.env.PORT || "3000");
+var port = parseInt(process.env.PORT || "3001");
 var hostname = process.env.NODE_ENV === "production" ? "127.0.0.1" : "localhost";
 logBox(`http://${hostname}:${port}`, "\u{1F680} Inspector Launched");
 var server = serve({