@mcpjam/inspector 0.9.63 → 1.0.1

package/dist/server/index.js

@@ -272,6 +272,8 @@ tools.post("/list", async (c) => {
   }
 });
 tools.post("/execute", async (c) => {
+  const mcp2 = c.mcpJamClientManager;
+  let state = null;
   try {
     const { serverId, toolName, parameters } = await c.req.json();
     if (!serverId) return c.json({ error: "serverId is required" }, 400);
@@ -279,19 +281,20 @@ tools.post("/execute", async (c) => {
     if (activeExecution) {
       return c.json({ error: "Another execution is already in progress" }, 409);
     }
-    const mcp2 = c.mcpJamClientManager;
     const status = mcp2.getConnectionStatus(serverId);
     if (status !== "connected") {
       return c.json({ error: `Server '${serverId}' is not connected` }, 400);
     }
     const executionId = `exec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    const state = {
+    const execPromise = Promise.resolve().then(() => mcp2.executeToolDirect(toolName, parameters || {})).catch((error) => {
+      if (state) state.error = error;
+      throw error;
+    });
+    state = {
       id: executionId,
       serverId,
       toolName,
-      execPromise: Promise.resolve().then(
-        () => mcp2.executeToolDirect(toolName, parameters || {})
-      ),
+      execPromise,
       completed: false,
       queue: [],
       waiters: []
@@ -360,20 +363,27 @@ tools.post("/execute", async (c) => {
       202
     );
   } catch (err) {
+    if (state && activeExecution === state) {
+      state.error = state.error ?? err;
+      state.waiters.length = 0;
+      state.queue.length = 0;
+      activeExecution = null;
+      mcp2.clearElicitationCallback();
+    }
     const msg = err instanceof Error ? err.message : String(err);
     return c.json({ error: msg }, 500);
   }
 });
 tools.post("/respond", async (c) => {
+  const mcp2 = c.mcpJamClientManager;
+  const state = activeExecution;
   try {
     const { requestId, response } = await c.req.json();
     if (!requestId) return c.json({ error: "requestId is required" }, 400);
-    if (!activeExecution) return c.json({ error: "No active execution" }, 404);
-    const mcp2 = c.mcpJamClientManager;
+    if (!state) return c.json({ error: "No active execution" }, 404);
     const ok = mcp2.respondToElicitation(requestId, response);
     if (!ok)
       return c.json({ error: "No pending elicitation for requestId" }, 404);
-    const state = activeExecution;
     try {
       const race = await Promise.race([
         state.execPromise.then((res) => ({ kind: "done", res })),
@@ -408,10 +418,24 @@ tools.post("/respond", async (c) => {
         202
       );
     } catch (e) {
+      state.error = state.error ?? e;
+      state.waiters.length = 0;
+      state.queue.length = 0;
+      if (activeExecution === state) {
+        activeExecution = null;
+        mcp2.clearElicitationCallback();
+      }
       const msg = e instanceof Error ? e.message : String(e);
       return c.json({ error: msg }, 500);
     }
   } catch (err) {
+    if (state && activeExecution === state) {
+      state.error = state.error ?? err;
+      state.waiters.length = 0;
+      state.queue.length = 0;
+      activeExecution = null;
+      mcp2.clearElicitationCallback();
+    }
     const msg = err instanceof Error ? err.message : String(err);
     return c.json({ error: msg }, 500);
   }
@@ -543,9 +567,14 @@ import { Hono as Hono6 } from "hono";
 import { streamText } from "ai";
 
 // ../shared/types.ts
-var isMCPJamProvidedModel = (provider) => {
-  const MCPJAM_PROVIDERS = ["meta"];
-  return MCPJAM_PROVIDERS.includes(provider);
+var MCPJAM_PROVIDED_MODEL_IDS = [
+  "meta-llama/llama-3.3-70b-instruct",
+  "openai/gpt-oss-120b",
+  "x-ai/grok-4-fast",
+  "openai/gpt-5-nano"
+];
+var isMCPJamProvidedModel = (modelId) => {
+  return MCPJAM_PROVIDED_MODEL_IDS.includes(modelId);
 };
 
 // routes/mcp/chat.ts
@@ -671,13 +700,6 @@ function ensureOutputSchema(schema) {
   }
   return schema;
 }
-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);
@@ -743,10 +765,9 @@ function convertMastraToolToVercelTool(toolName, mastraTool, options) {
 function convertMastraToolsToVercelTools(mastraTools) {
   return Object.fromEntries(
     Object.entries(mastraTools).map(([name, mastraTool]) => {
-      const pureToolName = extractPureToolName(name);
       return [
-        pureToolName,
-        convertMastraToolToVercelTool(pureToolName, mastraTool, {
+        name,
+        convertMastraToolToVercelTool(name, mastraTool, {
           originalName: name
         })
       ];
@@ -889,7 +910,8 @@ var runBackendConversation = async (options) => {
   while (step < options.maxSteps) {
     const payload = {
       tools: options.toolDefinitions,
-      messages: JSON.stringify(options.messageHistory)
+      messages: JSON.stringify(options.messageHistory),
+      model: options.modelId
     };
     const data = await options.fetchBackend(payload);
     if (!data || !data.ok || !Array.isArray(data.messages)) {
@@ -1208,7 +1230,7 @@ var createStreamingResponse = async (model, aiSdkTools, messages, streamingConte
     "[DONE]"
   );
 };
-var sendMessagesToBackend = async (messages, streamingContext, mcpClientManager, baseUrl, authHeader, selectedServers) => {
+var sendMessagesToBackend = async (messages, streamingContext, mcpClientManager, baseUrl, modelId, authHeader, selectedServers) => {
   const messageHistory = (messages || []).map((m) => {
     switch (m.role) {
       case "system":
@@ -1262,6 +1284,7 @@ var sendMessagesToBackend = async (messages, streamingContext, mcpClientManager,
   await runBackendConversation({
     maxSteps: MAX_AGENT_STEPS,
     messageHistory,
+    modelId,
     toolDefinitions: toolDefs,
     fetchBackend: async (payload) => {
       const data = await sendBackendRequest(
@@ -1367,7 +1390,7 @@ chat.post("/", async (c) => {
         400
       );
     }
-    const sendToBackend = isMCPJamProvidedModel(provider) && Boolean(requestData.sendMessagesToBackend);
+    const sendToBackend = model?.id && isMCPJamProvidedModel(model.id) && Boolean(requestData.sendMessagesToBackend);
     if (!sendToBackend && (!model?.id || !apiKey)) {
       return c.json(
         {
@@ -1438,6 +1461,7 @@ chat.post("/", async (c) => {
               streamingContext,
               mcpClientManager,
               process.env.CONVEX_HTTP_URL,
+              model.id,
               authHeader,
               requestData.selectedServers
             );
@@ -1985,13 +2009,13 @@ async function handleProxy(c) {
       const xfProto = req.headers.get("x-forwarded-proto");
       const xfHost = req.headers.get("x-forwarded-host");
       const host = xfHost || req.headers.get("host");
-      let proto2 = xfProto;
-      if (!proto2) {
+      let proto = xfProto;
+      if (!proto) {
         const originHeader = req.headers.get("origin");
-        if (originHeader && /^https:/i.test(originHeader)) proto2 = "https";
+        if (originHeader && /^https:/i.test(originHeader)) proto = "https";
       }
-      if (!proto2) proto2 = "http";
-      const proxyOrigin = host ? `${proto2}://${host}` : new URL(req.url).origin;
+      if (!proto) proto = "http";
+      const proxyOrigin = host ? `${proto}://${host}` : new URL(req.url).origin;
       const sessionId = crypto.randomUUID();
       interceptorStore.setSessionEndpoint(
         id,
@@ -3688,14 +3712,14 @@ var require_node_gyp_build = __commonJS({
   "../common/temp/node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
     var fs = __require("fs");
     var path = __require("path");
-    var os2 = __require("os");
+    var os = __require("os");
     var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
     var vars = process.config && process.config.variables || {};
     var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
     var abi = process.versions.modules;
     var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
-    var arch = process.env.npm_config_arch || os2.arch();
-    var platform = process.env.npm_config_platform || os2.platform();
+    var arch = process.env.npm_config_arch || os.arch();
+    var platform = process.env.npm_config_platform || os.platform();
     var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
     var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
     var uv = (process.versions.uv || "").split(".")[0];
@@ -7402,502 +7426,8 @@ var wrapper_default = import_websocket.default;
 var nodeWebSocket = wrapper_default;
 setDefaultWebSocketConstructor(nodeWebSocket);
 
-// ../evals-cli/node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code2) => `\x1B[${code2 + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code2) => `\x1B[${38 + offset};5;${code2}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    // 21 isn't widely supported and 22 does the same thing
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    // Bright color
-    blackBright: [90, 39],
-    gray: [90, 39],
-    // Alias of `blackBright`
-    grey: [90, 39],
-    // Alias of `blackBright`
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    // Bright color
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    // Alias of `bgBlackBright`
-    bgGrey: [100, 49],
-    // Alias of `bgBlackBright`
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = /* @__PURE__ */ new Map();
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          /* eslint-disable no-bitwise */
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-          /* eslint-enable no-bitwise */
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code2) {
-        if (code2 < 8) {
-          return 30 + code2;
-        }
-        if (code2 < 16) {
-          return 90 + (code2 - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code2 >= 232) {
-          red = ((code2 - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code2 -= 16;
-          const remainder = code2 % 36;
-          red = Math.floor(code2 / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// ../evals-cli/node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "process";
-import os from "os";
-import tty from "tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== void 0) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === void 0) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
-  }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if (env.TERM === "wezterm") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version2 >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// ../evals-cli/node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-    endIndex = index + 1;
-    index = string.indexOf("\n", endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// ../evals-cli/node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = /* @__PURE__ */ Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === void 0 ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk2 = (...strings) => strings.join(" ");
-  applyOptions(chalk2, options);
-  Object.setPrototypeOf(chalk2, createChalk.prototype);
-  return chalk2;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {
-}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === void 0) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === void 0) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== void 0) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf("\n");
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
 // ../evals-cli/src/utils/logger.ts
+import chalk from "chalk";
 var MAX_CONTENT_LENGTH = 160;
 var Logger = class {
   static activeStream = null;
@@ -7929,7 +7459,7 @@ var Logger = class {
   static suiteIntro(options) {
     const { testCount, startedAt } = options;
     this.logLine(
-      source_default.bold.blue(
+      chalk.bold.blue(
         `\u25B8 Running ${testCount} test${testCount === 1 ? "" : "s"} (${startedAt.toISOString()})`
       )
     );
@@ -7938,42 +7468,42 @@ var Logger = class {
     const { durationMs, passed, failed } = options;
     const total = passed + failed;
     const summary = `${passed}/${total} passed \u2022 ${this.formatDuration(durationMs)}`;
-    const prefix = failed === 0 ? source_default.green("\u2714") : source_default.red("\u2716");
+    const prefix = failed === 0 ? chalk.green("\u2714") : chalk.red("\u2716");
     this.logLine(`${prefix} ${summary}`);
   }
   static header(version2) {
-    this.logLine(source_default.bold.blue(`MCPJAM CLI ${version2}`));
+    this.logLine(chalk.bold.blue(`MCPJAM CLI ${version2}`));
     this.logLine("");
   }
   static initiateTestMessage(serverCount, toolCount, serverNames, testCount) {
     this.logLine("");
-    this.logLine(source_default.bold.blue("Running tests"));
+    this.logLine(chalk.bold.blue("Running tests"));
     const serverLabel = serverCount === 1 ? "server" : "servers";
     const serverList = serverNames.length > 0 ? serverNames.join(", ") : "none";
     this.logLine(
-      `Connected to ${source_default.white.bold(serverCount)} ${serverLabel}: ${source_default.gray(serverList)}`
+      `Connected to ${chalk.white.bold(serverCount)} ${serverLabel}: ${chalk.gray(serverList)}`
     );
     const toolLabel = toolCount === 1 ? "tool" : "tools";
-    this.logLine(`Found ${source_default.white.bold(toolCount)} total ${toolLabel}`);
+    this.logLine(`Found ${chalk.white.bold(toolCount)} total ${toolLabel}`);
     const testLabel = testCount === 1 ? "test" : "tests";
-    this.logLine(`Running ${source_default.white.bold(testCount)} ${testLabel}`);
+    this.logLine(`Running ${chalk.white.bold(testCount)} ${testLabel}`);
     this.logLine("");
   }
   static logTestGroupTitle(testNumber, testName, modelProvider, modelId) {
-    this.logLine(source_default.cyan.bold(`Test ${testNumber}: ${testName}`));
-    this.logLine(source_default.gray(`Using ${modelProvider}:${modelId}`));
+    this.logLine(chalk.cyan.bold(`Test ${testNumber}: ${testName}`));
+    this.logLine(chalk.gray(`Using ${modelProvider}:${modelId}`));
     this.logLine("");
   }
   static testRunStart(options) {
     const { runNumber, totalRuns } = options;
     const parts = [`run ${runNumber}/${totalRuns}`];
-    this.logLine(source_default.cyanBright(parts.join(" \u2022 ")));
+    this.logLine(chalk.cyanBright(parts.join(" \u2022 ")));
   }
   static conversation(options) {
     const { messages } = options;
     this.closeActiveStream();
     if (!messages.length) {
-      this.logLine(source_default.dim("(no messages)"));
+      this.logLine(chalk.dim("(no messages)"));
       return;
     }
     messages.forEach((message, index) => {
@@ -8005,7 +7535,7 @@ var Logger = class {
   }
   static testRunResult(options) {
     const { passed, durationMs, usage } = options;
-    const status = passed ? source_default.green("PASS") : source_default.red("FAIL");
+    const status = passed ? chalk.green("PASS") : chalk.red("FAIL");
     this.logLine(`${status} (${this.formatDuration(durationMs)})`);
     if (usage) {
       const usageParts = [];
@@ -8019,49 +7549,49 @@ var Logger = class {
         usageParts.push(`total ${usage.totalTokens}`);
       }
       if (usageParts.length > 0) {
-        this.logLine(source_default.gray(`Tokens \u2022 ${usageParts.join(" \u2022 ")}`));
+        this.logLine(chalk.gray(`Tokens \u2022 ${usageParts.join(" \u2022 ")}`));
       }
     }
     this.logLine("");
     this.logLine("");
   }
   static info(message) {
-    this.logLine(source_default.blue(`\u2139 ${message}`));
+    this.logLine(chalk.blue(`\u2139 ${message}`));
   }
   static warn(message) {
-    this.logLine(source_default.yellow(`\u26A0 ${message}`));
+    this.logLine(chalk.yellow(`\u26A0 ${message}`));
   }
   static success(message) {
-    this.logLine(source_default.green(`\u2713 ${message}`));
+    this.logLine(chalk.green(`\u2713 ${message}`));
   }
   static error(message) {
     this.logLine("");
-    this.logLine(source_default.red(`\u2715 Error: ${message}`));
+    this.logLine(chalk.red(`\u2715 Error: ${message}`));
   }
   static errorWithExit(message) {
     this.logLine("");
-    this.logLine(source_default.red(`\u2715 Error: ${message}`));
+    this.logLine(chalk.red(`\u2715 Error: ${message}`));
     process.exit(1);
   }
   static progress(current, total, testName) {
     const progress = `[${current}/${total}]`;
-    this.logLine(source_default.gray(`${progress} ${testName}...`));
+    this.logLine(chalk.gray(`${progress} ${testName}...`));
   }
   static testStarting(testName) {
-    this.logLine(source_default.gray(`  Running ${testName}...`));
+    this.logLine(chalk.gray(`  Running ${testName}...`));
   }
   static testError(testName, error) {
-    this.logLine(source_default.red(`  \u2715 ${testName} failed: ${error}`));
+    this.logLine(chalk.red(`  \u2715 ${testName} failed: ${error}`));
   }
   static connectionError(serverName, error) {
-    this.logLine(source_default.red(`  \u2715 Failed to connect to ${serverName}: ${error}`));
+    this.logLine(chalk.red(`  \u2715 Failed to connect to ${serverName}: ${error}`));
   }
   static apiKeyError(provider, error) {
-    this.logLine(source_default.red(`  \u2715 API key error for ${provider}: ${error}`));
+    this.logLine(chalk.red(`  \u2715 API key error for ${provider}: ${error}`));
   }
   static modelCreationError(provider, modelId, error) {
     this.logLine(
-      source_default.red(
+      chalk.red(
         `  \u2715 Failed to create ${provider} model "${modelId}": ${error}`
       )
     );
@@ -8176,11 +7706,11 @@ var Logger = class {
     }
   }
   static logToolCall(toolCall) {
-    const header = source_default.whiteBright(`[tool-call] ${toolCall.toolName}`);
+    const header = chalk.whiteBright(`[tool-call] ${toolCall.toolName}`);
     this.logLine(header);
     const jsonArgs = toolCall.args ? JSON.parse(toolCall.args) : null;
     if (toolCall.args) {
-      this.logLine(source_default.gray(this.truncate(toolCall.args)));
+      this.logLine(chalk.gray(this.truncate(toolCall.args)));
     }
   }
   static beginStreamingMessage(role) {
@@ -8202,18 +7732,18 @@ var Logger = class {
   }
   static streamToolResult(toolName, output) {
     this.closeActiveStream();
-    const header = source_default.whiteBright(`[tool-result] ${toolName}`);
+    const header = chalk.whiteBright(`[tool-result] ${toolName}`);
     this.logLine(header);
     if (output !== void 0) {
-      this.logLine(source_default.gray(this.truncate(this.stringify(output))));
+      this.logLine(chalk.gray(this.truncate(this.stringify(output))));
     }
   }
   static streamToolError(toolName, error) {
     this.closeActiveStream();
-    const header = source_default.whiteBright(`[tool-error] ${toolName}`);
+    const header = chalk.whiteBright(`[tool-error] ${toolName}`);
     this.logLine(header);
     this.logLine(
-      source_default.red(this.truncate(this.stringify(error ?? "Unknown error")))
+      chalk.red(this.truncate(this.stringify(error ?? "Unknown error")))
     );
   }
   static renderBox(lines, options) {
@@ -8228,7 +7758,7 @@ var Logger = class {
     lines.forEach((line, index) => {
       const padded = line.padEnd(width, " ");
       const isStatusLine = index === statusIndex;
-      const colouredContent = isStatusLine ? statusColor(padded) : source_default.white(padded);
+      const colouredContent = isStatusLine ? statusColor(padded) : chalk.white(padded);
       this.logLine(
         `${borderColor("| ")}${colouredContent}${borderColor(" |")}`
       );
@@ -8270,15 +7800,15 @@ var Logger = class {
   static colorRole(role) {
     switch (role) {
       case "user":
-        return source_default.bold.whiteBright("user");
+        return chalk.bold.whiteBright("user");
       case "assistant":
-        return source_default.bold.whiteBright("assistant");
+        return chalk.bold.whiteBright("assistant");
       case "tool":
-        return source_default.bold.whiteBright("tool");
+        return chalk.bold.whiteBright("tool");
       case "system":
-        return source_default.bold.whiteBright("system");
+        return chalk.bold.whiteBright("system");
       default:
-        return source_default.cyan(role);
+        return chalk.cyan(role);
     }
   }
 };
@@ -8600,8 +8130,14 @@ var accumulateTokenCount = (current, increment) => {
 };
 var prepareSuite = async (validatedTests, mcpClientOptions, validatedLlms) => {
   const mcpClient = new MCPClient(mcpClientOptions);
-  const availableTools = await mcpClient.getTools();
-  const vercelTools = convertMastraToolsToVercelTools(availableTools);
+  const toolsets = await mcpClient.getToolsets();
+  const availableTools = {};
+  Object.values(toolsets).forEach((serverTools) => {
+    Object.assign(availableTools, serverTools);
+  });
+  const vercelTools = convertMastraToolsToVercelTools(
+    availableTools
+  );
   const serverNames = Object.keys(mcpClientOptions.servers);
   Logger.initiateTestMessage(
     serverNames.length,
@@ -8661,6 +8197,7 @@ var runIterationViaBackend = async ({
     await runBackendConversation({
       maxSteps: MAX_STEPS,
       messageHistory,
+      modelId: test.model,
       toolDefinitions: toolDefs,
       fetchBackend: async (payload) => {
         try {
@@ -8782,41 +8319,60 @@ var runIteration = async ({
   });
   while (stepCount < MAX_STEPS) {
     let assistantStreaming = false;
-    const streamResult = await streamText2({
-      model: createLlmModel2(provider, model, llms),
-      system,
-      temperature,
-      tools: tools2,
-      toolChoice,
-      messages: messageHistory,
-      onChunk: async (chunk) => {
-        switch (chunk.chunk.type) {
-          case "text-delta":
-          case "reasoning-delta": {
-            if (!assistantStreaming) {
-              Logger.beginStreamingMessage("assistant");
-              assistantStreaming = true;
+    let streamResult;
+    try {
+      streamResult = await streamText2({
+        model: createLlmModel2(provider, model, llms),
+        system,
+        temperature,
+        tools: tools2,
+        toolChoice,
+        messages: messageHistory,
+        onChunk: async (chunk) => {
+          switch (chunk.chunk.type) {
+            case "text-delta":
+            case "reasoning-delta": {
+              if (!assistantStreaming) {
+                Logger.beginStreamingMessage("assistant");
+                assistantStreaming = true;
+              }
+              Logger.appendStreamingText(chunk.chunk.text);
+              break;
             }
-            Logger.appendStreamingText(chunk.chunk.text);
-            break;
-          }
-          case "tool-call": {
-            if (assistantStreaming) {
-              Logger.finishStreamingMessage();
-              assistantStreaming = false;
+            case "tool-call": {
+              if (assistantStreaming) {
+                Logger.finishStreamingMessage();
+                assistantStreaming = false;
+              }
+              Logger.streamToolCall(chunk.chunk.toolName, chunk.chunk.input);
+              break;
             }
-            Logger.streamToolCall(chunk.chunk.toolName, chunk.chunk.input);
-            break;
-          }
-          case "tool-result": {
-            Logger.streamToolResult(chunk.chunk.toolName, chunk.chunk.output);
-            break;
+            case "tool-result": {
+              Logger.streamToolResult(chunk.chunk.toolName, chunk.chunk.output);
+              break;
+            }
+            default:
+              break;
           }
-          default:
-            break;
         }
-      }
-    });
+      });
+    } catch (error) {
+      const errorMessage = error?.message || String(error);
+      Logger.error(errorMessage);
+      const evaluation2 = evaluateResults(test.expectedToolCalls, []);
+      await recorder.finishIteration({
+        iterationId,
+        passed: false,
+        toolsCalled: [],
+        usage: {
+          inputTokens: void 0,
+          outputTokens: void 0,
+          totalTokens: void 0
+        },
+        messages: messageHistory
+      });
+      return evaluation2;
+    }
     await streamResult.consumeStream();
     if (assistantStreaming) {
       Logger.finishStreamingMessage();
@@ -8893,7 +8449,7 @@ var runTestCase = async ({
   let failedRuns = 0;
   const testCaseId = await recorder.recordTestCase(test, testIndex);
   for (let runIndex = 0; runIndex < runs; runIndex++) {
-    const usesBackend = isMCPJamProvidedModel(provider);
+    const usesBackend = isMCPJamProvidedModel(model);
     const evaluation = usesBackend && convexUrl && authToken ? await runIterationViaBackend({
       test,
       runIndex,
@@ -9021,9 +8577,10 @@ function transformServerConfigsToEnvironment(serverIds, clientManager) {
     servers: servers2
   };
 }
-function transformLLMConfigToLlmsConfig(llmConfig) {
+function transformLLMConfigToLlmsConfig(llmConfig, modelId) {
   const llms = {};
-  if (isMCPJamProvidedModel(llmConfig.provider)) {
+  const isMCPJamModel = modelId && isMCPJamProvidedModel(modelId);
+  if (isMCPJamModel) {
     llms.openrouter = "BACKEND_EXECUTION";
   } else {
     const providerKey = llmConfig.provider.toLowerCase();
@@ -9036,6 +8593,154 @@ function transformLLMConfigToLlmsConfig(llmConfig) {
   return validated.data;
 }
 
+// services/eval-agent.ts
+var AGENT_SYSTEM_PROMPT = `You are an AI agent specialized in creating realistic test cases for MCP (Model Context Protocol) servers.
+
+**About MCP:**
+The Model Context Protocol enables AI assistants to securely access external data and tools. MCP servers expose tools, resources, and prompts that AI models can use to accomplish user tasks. Your test cases should reflect real-world usage patterns where users ask an AI assistant to perform tasks, and the assistant uses MCP tools to fulfill those requests.
+
+**Your Task:**
+Generate 6 test cases with varying complexity levels that mimic how real users would interact with an AI assistant using these MCP tools.
+
+**Test Case Distribution:**
+- **2 EASY tests** (single tool): Simple, straightforward tasks using one tool
+- **2 MEDIUM tests** (2+ tools): Multi-step workflows requiring 2-3 tools in sequence or parallel
+- **2 HARD tests** (3+ tools): Complex scenarios requiring 3+ tools, conditional logic, or cross-server operations
+
+**Guidelines:**
+1. **Realistic User Queries**: Write queries as if a real user is talking to an AI assistant (e.g., "Help me find all tasks due this week" not "Call the list_tasks tool")
+2. **Natural Workflows**: Chain tools together in logical sequences that solve real problems
+3. **Cross-Server Tests**: If multiple servers are available, create tests that use tools from different servers together
+4. **Specific Details**: Include concrete examples (dates, names, values) to make tests actionable
+5. **Judge Requirements**: Clearly define what success looks like for each test
+6. **Test Titles**: Write clear, descriptive titles WITHOUT difficulty prefixes (e.g., "Read project configuration" not "EASY: Read project configuration")
+
+**Output Format (CRITICAL):**
+Respond with ONLY a valid JSON array. No explanations, no markdown code blocks, just the raw JSON array.
+
+Example:
+[
+  {
+    "title": "Read project configuration",
+    "query": "Show me the contents of config.json in the current project",
+    "runs": 1,
+    "expectedToolCalls": ["read_file"],
+    "judgeRequirement": "Successfully reads and returns the file contents"
+  },
+  {
+    "title": "Find and analyze recent tasks",
+    "query": "Find all tasks created this week and summarize their status",
+    "runs": 1,
+    "expectedToolCalls": ["list_tasks", "get_task_details"],
+    "judgeRequirement": "First lists tasks filtered by date, then retrieves details for each task found"
+  },
+  {
+    "title": "Cross-server project setup",
+    "query": "Create a new project folder, initialize a git repository, and create a task to track the project setup",
+    "runs": 1,
+    "expectedToolCalls": ["create_directory", "git_init", "create_task"],
+    "judgeRequirement": "Successfully creates directory, initializes git, and creates a tracking task with appropriate details"
+  }
+]`;
+async function generateTestCases(tools2, convexHttpUrl, convexAuthToken) {
+  const serverGroups = tools2.reduce(
+    (acc, tool2) => {
+      if (!acc[tool2.serverId]) {
+        acc[tool2.serverId] = [];
+      }
+      acc[tool2.serverId].push(tool2);
+      return acc;
+    },
+    {}
+  );
+  const serverCount = Object.keys(serverGroups).length;
+  const totalTools = tools2.length;
+  const toolsContext = Object.entries(serverGroups).map(([serverId, serverTools]) => {
+    const toolsList = serverTools.map((tool2) => {
+      return `  - ${tool2.name}: ${tool2.description || "No description"}
+    Input: ${JSON.stringify(tool2.inputSchema)}`;
+    }).join("\n");
+    return `**Server: ${serverId}** (${serverTools.length} tools)
+${toolsList}`;
+  }).join("\n\n");
+  const crossServerGuidance = serverCount > 1 ? `
+**IMPORTANT**: You have ${serverCount} servers available. Create at least 2 test cases that use tools from MULTIPLE servers to test cross-server workflows.` : "";
+  const userPrompt = `Generate 6 test cases for the following MCP server tools:
+
+${toolsContext}
+
+**Available Resources:**
+- ${serverCount} MCP server(s)
+- ${totalTools} total tools${crossServerGuidance}
+
+**Remember:**
+1. Create exactly 6 tests: 2 EASY (1 tool), 2 MEDIUM (2-3 tools), 2 HARD (3+ tools)
+2. Write realistic user queries that sound natural
+3. Use specific examples (dates, filenames, values)
+4. Chain tools in logical sequences
+5. Respond with ONLY a JSON array - no other text or markdown`;
+  const messageHistory = [
+    { role: "system", content: AGENT_SYSTEM_PROMPT },
+    { role: "user", content: userPrompt }
+  ];
+  const response = await fetch(`${convexHttpUrl}/streaming`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${convexAuthToken}`
+    },
+    body: JSON.stringify({
+      model: "meta-llama/llama-3.3-70b-instruct",
+      tools: [],
+      messages: JSON.stringify(messageHistory)
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to generate test cases: ${errorText}`);
+  }
+  const data = await response.json();
+  if (!data.ok || !Array.isArray(data.messages)) {
+    throw new Error("Invalid response from backend LLM");
+  }
+  let assistantResponse = "";
+  for (const msg of data.messages) {
+    if (msg.role === "assistant") {
+      const content = msg.content;
+      if (typeof content === "string") {
+        assistantResponse += content;
+      } else if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === "text" && item.text) {
+            assistantResponse += item.text;
+          }
+        }
+      }
+    }
+  }
+  try {
+    const jsonMatch = assistantResponse.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const jsonText = jsonMatch ? jsonMatch[1].trim() : assistantResponse.trim();
+    const testCases = JSON.parse(jsonText);
+    if (!Array.isArray(testCases)) {
+      throw new Error("Response is not an array");
+    }
+    const validatedTests = testCases.map((tc) => ({
+      title: tc.title || "Untitled Test",
+      query: tc.query || "",
+      runs: typeof tc.runs === "number" ? tc.runs : 1,
+      expectedToolCalls: Array.isArray(tc.expectedToolCalls) ? tc.expectedToolCalls : [],
+      judgeRequirement: tc.judgeRequirement
+    }));
+    return validatedTests;
+  } catch (parseError) {
+    console.error("Failed to parse LLM response:", assistantResponse);
+    throw new Error(
+      `Failed to parse test cases from LLM response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`
+    );
+  }
+}
+
 // routes/mcp/evals.ts
 var evals = new Hono10();
 var RunEvalsRequestSchema = z3.object({
@@ -9081,7 +8786,8 @@ evals.post("/run", async (c) => {
       serverIds,
       clientManager
     );
-    const llms = transformLLMConfigToLlmsConfig(llmConfig);
+    const modelId = tests.length > 0 ? tests[0].model : void 0;
+    const llms = transformLLMConfigToLlmsConfig(llmConfig, modelId);
     const convexUrl = process.env.CONVEX_URL;
     if (!convexUrl) {
       throw new Error("CONVEX_URL is not set");
@@ -9100,7 +8806,8 @@ evals.post("/run", async (c) => {
       convexHttpUrl,
       convexAuthToken
     ).catch((error) => {
-      console.error("[Hono:Evals] Error running evals:", error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("[Error running evals:", errorMessage);
     });
     return c.json({
       success: true,
@@ -9116,6 +8823,63 @@ evals.post("/run", async (c) => {
     );
   }
 });
+var GenerateTestsRequestSchema = z3.object({
+  serverIds: z3.array(z3.string()).min(1, "At least one server must be selected"),
+  convexAuthToken: z3.string()
+});
+evals.post("/generate-tests", async (c) => {
+  try {
+    const body = await c.req.json();
+    const validationResult = GenerateTestsRequestSchema.safeParse(body);
+    if (!validationResult.success) {
+      return c.json(
+        {
+          error: "Invalid request body",
+          details: validationResult.error.errors
+        },
+        400
+      );
+    }
+    const { serverIds, convexAuthToken } = validationResult.data;
+    const clientManager = c.mcpJamClientManager;
+    const allTools = clientManager.getAvailableTools();
+    const serverIdSet = new Set(
+      serverIds.map((name) => clientManager.getServerIdForName(name)).filter(Boolean)
+    );
+    const filteredTools = allTools.filter(
+      (tool2) => serverIdSet.has(tool2.serverId)
+    );
+    if (filteredTools.length === 0) {
+      return c.json(
+        {
+          error: "No tools found for selected servers"
+        },
+        400
+      );
+    }
+    const convexHttpUrl = process.env.CONVEX_HTTP_URL;
+    if (!convexHttpUrl) {
+      throw new Error("CONVEX_HTTP_URL is not set");
+    }
+    const testCases = await generateTestCases(
+      filteredTools,
+      convexHttpUrl,
+      convexAuthToken
+    );
+    return c.json({
+      success: true,
+      tests: testCases
+    });
+  } catch (error) {
+    console.error("Error in /evals/generate-tests:", error);
+    return c.json(
+      {
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
 var evals_default = evals;
 
 // routes/mcp/http-adapters.ts
@@ -9360,13 +9124,13 @@ function createHttpHandler(mode, routePrefix) {
         const xfProto = c.req.header("x-forwarded-proto");
         const xfHost = c.req.header("x-forwarded-host");
         const host = xfHost || c.req.header("host");
-        let proto2 = xfProto;
-        if (!proto2) {
+        let proto = xfProto;
+        if (!proto) {
           const originHeader = c.req.header("origin");
-          if (originHeader && /^https:/i.test(originHeader)) proto2 = "https";
+          if (originHeader && /^https:/i.test(originHeader)) proto = "https";
         }
-        if (!proto2) proto2 = "http";
-        const origin = host ? `${proto2}://${host}` : incomingUrl.origin;
+        if (!proto) proto = "http";
+        const origin = host ? `${proto}://${host}` : incomingUrl.origin;
         endpointBase = `${origin}/api/mcp/${routePrefix}/${serverId}/messages`;
       }
       const sessionId = crypto.randomUUID();
@@ -9588,23 +9352,22 @@ function validateServerConfig(serverConfig) {
         };
       }
       if (config.oauth?.access_token) {
+        const accessToken = config.oauth.access_token;
         const authHeaders = {
-          Authorization: `Bearer ${config.oauth.access_token}`,
+          Authorization: `Bearer ${accessToken}`,
           ...config.requestInit?.headers || {}
         };
         config.requestInit = {
           ...config.requestInit,
           headers: authHeaders
         };
+        const requestInitHeaders = config.requestInit?.headers;
         config.eventSourceInit = {
           fetch(input, init2) {
             const headers = new Headers(init2?.headers || {});
-            headers.set(
-              "Authorization",
-              `Bearer ${config.oauth.access_token}`
-            );
-            if (config.requestInit?.headers) {
-              const requestHeaders = new Headers(config.requestInit.headers);
+            headers.set("Authorization", `Bearer ${accessToken}`);
+            if (requestInitHeaders) {
+              const requestHeaders = new Headers(requestInitHeaders);
               requestHeaders.forEach((value, key) => {
                 if (key.toLowerCase() !== "authorization") {
                   headers.set(key, value);
@@ -9617,6 +9380,7 @@ function validateServerConfig(serverConfig) {
             });
           }
         };
+        delete config.oauth;
       } else if (config.requestInit?.headers) {
         config.eventSourceInit = {
           fetch(input, init2) {