@mcpjam/inspector 0.9.4 → 0.9.6

package/dist/server/index.js

@@ -1,213 +1,58 @@
 // index.ts
 import { serve } from "@hono/node-server";
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { readFileSync } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 
 // routes/mcp/index.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono9 } from "hono";
 
 // routes/mcp/connect.ts
 import { Hono } from "hono";
-
-// utils/mcp-utils.ts
-import { MCPClient } from "@mastra/mcp";
-function validateServerConfig(serverConfig) {
-  if (!serverConfig) {
-    return {
-      success: false,
-      error: {
-        message: "Server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const config = { ...serverConfig };
-  if (config.url) {
-    try {
-      if (typeof config.url === "string") {
-        const parsed = new URL(config.url);
-        parsed.search = "";
-        parsed.hash = "";
-        config.url = parsed;
-      } else if (typeof config.url === "object" && !config.url.href) {
-        return {
-          success: false,
-          error: {
-            message: "Invalid URL configuration",
-            status: 400
-          }
-        };
-      }
-      if (config.oauth?.access_token) {
-        const authHeaders = {
-          Authorization: `Bearer ${config.oauth.access_token}`,
-          ...config.requestInit?.headers || {}
-        };
-        config.requestInit = {
-          ...config.requestInit,
-          headers: authHeaders
-        };
-        config.eventSourceInit = {
-          fetch(input, init) {
-            const headers = new Headers(init?.headers || {});
-            headers.set(
-              "Authorization",
-              `Bearer ${config.oauth.access_token}`
-            );
-            if (config.requestInit?.headers) {
-              const requestHeaders = new Headers(config.requestInit.headers);
-              requestHeaders.forEach((value, key) => {
-                if (key.toLowerCase() !== "authorization") {
-                  headers.set(key, value);
-                }
-              });
-            }
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      } else if (config.requestInit?.headers) {
-        config.eventSourceInit = {
-          fetch(input, init) {
-            const headers = new Headers(init?.headers || {});
-            const requestHeaders = new Headers(config.requestInit.headers);
-            requestHeaders.forEach((value, key) => {
-              headers.set(key, value);
-            });
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          message: `Invalid URL format: ${error}`,
-          status: 400
-        }
-      };
-    }
-  }
-  return {
-    success: true,
-    config
-  };
-}
-function createMCPClient(config, id) {
-  return new MCPClient({
-    id,
-    servers: {
-      server: config
-    }
-  });
-}
-var validateMultipleServerConfigs = (serverConfigs) => {
-  if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
-    return {
-      success: false,
-      error: {
-        message: "At least one server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const validConfigs = {};
-  const errors = {};
-  let hasErrors = false;
-  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
-    const validationResult = validateServerConfig(serverConfig);
-    if (validationResult.success && validationResult.config) {
-      validConfigs[serverName] = validationResult.config;
-    } else {
-      hasErrors = true;
-      let errorMessage = "Configuration validation failed";
-      if (validationResult.error) {
-        errorMessage = validationResult.error.message;
-      }
-      errors[serverName] = errorMessage;
-    }
-  }
-  if (!hasErrors) {
-    return {
-      success: true,
-      validConfigs
-    };
-  }
-  if (Object.keys(validConfigs).length > 0) {
-    return {
-      success: false,
-      validConfigs,
-      errors
-    };
-  }
-  return {
-    success: false,
-    errors,
-    error: {
-      message: "All server configurations failed validation",
-      status: 400
-    }
-  };
-};
-function createMCPClientWithMultipleConnections(serverConfigs) {
-  const normalizedConfigs = {};
-  for (const [serverName, config] of Object.entries(serverConfigs)) {
-    const normalizedName = normalizeServerConfigName(serverName);
-    normalizedConfigs[normalizedName] = config;
-  }
-  return new MCPClient({
-    id: `chat-${Date.now()}`,
-    servers: normalizedConfigs
-  });
-}
-function normalizeServerConfigName(serverName) {
-  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-}
-
-// routes/mcp/connect.ts
 var connect = new Hono();
 connect.post("/", async (c) => {
   try {
-    const { serverConfig } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      const error = validation.error;
+    const { serverConfig, serverId } = await c.req.json();
+    if (!serverConfig) {
       return c.json(
         {
           success: false,
-          error: error.message
+          error: "serverConfig is required"
         },
-        error.status
+        400
       );
     }
-    let client;
-    try {
-      client = createMCPClient(validation.config, `test-${Date.now()}`);
-    } catch (error) {
+    if (!serverId) {
       return c.json(
         {
           success: false,
-          error: `Failed to create a MCP client. Please double check your server configuration: ${JSON.stringify(serverConfig)}`,
-          details: error instanceof Error ? error.message : "Unknown error"
+          error: "serverId is required"
         },
-        500
+        400
       );
     }
+    const mcpClientManager = c.mcpJamClientManager;
     try {
-      await client.getTools();
-      await client.disconnect();
-      return c.json({
-        success: true
-      });
+      await mcpClientManager.connectToServer(serverId, serverConfig);
+      const status = mcpClientManager.getConnectionStatus(serverId);
+      if (status === "connected") {
+        return c.json({
+          success: true,
+          status: "connected"
+        });
+      } else {
+        return c.json(
+          {
+            success: false,
+            error: "Connection failed",
+            status
+          },
+          500
+        );
+      }
     } catch (error) {
       return c.json(
         {
@@ -231,16 +76,119 @@ connect.post("/", async (c) => {
 });
 var connect_default = connect;
 
-// routes/mcp/tools.ts
+// routes/mcp/servers.ts
 import { Hono as Hono2 } from "hono";
+var servers = new Hono2();
+servers.get("/", async (c) => {
+  try {
+    const mcpJamClientManager2 = c.mcpJamClientManager;
+    const connectedServers = mcpJamClientManager2.getConnectedServers();
+    const serverList = Object.entries(connectedServers).map(
+      ([serverId, serverInfo]) => ({
+        id: serverId,
+        name: serverId,
+        status: serverInfo.status,
+        config: serverInfo.config
+      })
+    );
+    return c.json({
+      success: true,
+      servers: serverList
+    });
+  } catch (error) {
+    console.error("Error listing servers:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+servers.get("/status/:serverId", async (c) => {
+  try {
+    const serverId = c.req.param("serverId");
+    const mcpJamClientManager2 = c.mcpJamClientManager;
+    const status = mcpJamClientManager2.getConnectionStatus(serverId);
+    return c.json({
+      success: true,
+      serverId,
+      status
+    });
+  } catch (error) {
+    console.error("Error getting server status:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+servers.delete("/:serverId", async (c) => {
+  try {
+    const serverId = c.req.param("serverId");
+    const mcpJamClientManager2 = c.mcpJamClientManager;
+    await mcpJamClientManager2.disconnectFromServer(serverId);
+    return c.json({
+      success: true,
+      message: `Disconnected from server: ${serverId}`
+    });
+  } catch (error) {
+    console.error("Error disconnecting server:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+servers.post("/reconnect", async (c) => {
+  try {
+    const { serverId, serverConfig } = await c.req.json();
+    if (!serverId || !serverConfig) {
+      return c.json(
+        {
+          success: false,
+          error: "serverId and serverConfig are required"
+        },
+        400
+      );
+    }
+    const mcpJamClientManager2 = c.mcpJamClientManager;
+    await mcpJamClientManager2.disconnectFromServer(serverId);
+    await mcpJamClientManager2.connectToServer(serverId, serverConfig);
+    const status = mcpJamClientManager2.getConnectionStatus(serverId);
+    return c.json({
+      success: true,
+      serverId,
+      status,
+      message: `Reconnected to server: ${serverId}`
+    });
+  } catch (error) {
+    console.error("Error reconnecting server:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var servers_default = servers;
+
+// routes/mcp/tools.ts
+import { Hono as Hono3 } from "hono";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { TextEncoder } from "util";
-var tools = new Hono2();
+import { TextEncoder as TextEncoder2 } from "util";
+var tools = new Hono3();
 var pendingElicitations = /* @__PURE__ */ new Map();
 tools.post("/", async (c) => {
-  let client = null;
-  let encoder = null;
-  let streamController = null;
   let action;
   let toolName;
   try {
@@ -267,8 +215,18 @@ tools.post("/", async (c) => {
           400
         );
       }
-      const pending = pendingElicitations.get(requestId);
-      if (!pending) {
+      const mcpJamClientManager2 = c.mcpJamClientManager;
+      const success = mcpJamClientManager2.respondToElicitation(
+        requestId,
+        response
+      );
+      if (!success) {
+        const pending = pendingElicitations.get(requestId);
+        if (pending) {
+          pending.resolve(response);
+          pendingElicitations.delete(requestId);
+          return c.json({ success: true });
+        }
         return c.json(
           {
             success: false,
@@ -277,177 +235,171 @@ tools.post("/", async (c) => {
           404
         );
       }
-      pending.resolve(response);
-      pendingElicitations.delete(requestId);
       return c.json({ success: true });
     }
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    encoder = new TextEncoder();
+    const encoder = new TextEncoder2();
     const readableStream = new ReadableStream({
       async start(controller) {
-        streamController = controller;
         try {
-          const clientId = `tools-${action}-${Date.now()}`;
-          client = createMCPClient(validation.config, clientId);
-          if (action === "list") {
+          if (!serverConfig) {
             controller.enqueue(
               encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tools_loading",
-                  message: "Fetching tools from server..."
-                })}
+                `data: ${JSON.stringify({ type: "tool_error", error: "serverConfig is required" })}
 
 `
               )
             );
-            const tools2 = await client.getTools();
-            const toolsWithJsonSchema = Object.fromEntries(
-              Object.entries(tools2).map(([toolName2, tool]) => {
-                return [
-                  toolName2,
-                  {
-                    ...tool,
-                    inputSchema: zodToJsonSchema(
-                      tool.inputSchema
-                    )
-                  }
-                ];
-              })
-            );
+            controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+            controller.close();
+            return;
+          }
+          const mcpJamClientManager2 = c.mcpJamClientManager;
+          const serverId = serverConfig.name || serverConfig.id || "server";
+          await mcpJamClientManager2.connectToServer(serverId, serverConfig);
+          mcpJamClientManager2.setElicitationCallback(async (request) => {
+            const { requestId: requestId2, message, schema } = request;
             controller.enqueue(
               encoder.encode(
                 `data: ${JSON.stringify({
-                  type: "tools_list",
-                  tools: toolsWithJsonSchema
+                  type: "elicitation_request",
+                  requestId: requestId2,
+                  message,
+                  schema,
+                  toolName: toolName || "unknown",
+                  timestamp: /* @__PURE__ */ new Date()
                 })}
 
 `
               )
             );
-          } else if (action === "execute") {
-            if (!toolName) {
+            return new Promise((resolve, reject) => {
+              pendingElicitations.set(requestId2, {
+                resolve: (response2) => {
+                  resolve(response2);
+                  pendingElicitations.delete(requestId2);
+                },
+                reject: (error) => {
+                  reject(error);
+                  pendingElicitations.delete(requestId2);
+                }
+              });
+              setTimeout(() => {
+                if (pendingElicitations.has(requestId2)) {
+                  pendingElicitations.delete(requestId2);
+                  reject(new Error("Elicitation timeout"));
+                }
+              }, 3e5);
+            });
+          });
+          if (action === "list") {
+            try {
+              const flattenedTools = await mcpJamClientManager2.getToolsetsForServer(serverId);
+              const toolsWithJsonSchema = {};
+              for (const [name, tool] of Object.entries(flattenedTools)) {
+                let inputSchema = tool.inputSchema;
+                try {
+                  inputSchema = zodToJsonSchema(inputSchema);
+                } catch {
+                }
+                toolsWithJsonSchema[name] = {
+                  name,
+                  description: tool.description,
+                  inputSchema,
+                  outputSchema: tool.outputSchema
+                };
+              }
               controller.enqueue(
                 encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_error",
-                    error: "Tool name is required for execution"
-                  })}
+                  `data: ${JSON.stringify({ type: "tools_list", tools: toolsWithJsonSchema })}
 
 `
                 )
               );
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+              controller.close();
               return;
-            }
-            controller.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_executing",
-                  toolName,
-                  parameters: parameters || {},
-                  message: "Executing tool..."
-                })}
+            } catch (err) {
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
 
 `
-              )
-            );
-            const tools2 = await client.getTools();
-            const tool = tools2[toolName];
-            if (!tool) {
+                )
+              );
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+              controller.close();
+              return;
+            }
+          }
+          if (action === "execute") {
+            if (!toolName) {
               controller.enqueue(
                 encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_error",
-                    error: `Tool '${toolName}' not found`
-                  })}
+                  `data: ${JSON.stringify({ type: "tool_error", error: "Tool name is required for execution" })}
 
 `
                 )
               );
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+              controller.close();
               return;
             }
-            const toolArgs = parameters && typeof parameters === "object" ? parameters : {};
-            const elicitationHandler = async (elicitationRequest) => {
-              const requestId2 = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-              if (streamController && encoder) {
-                streamController.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({
-                      type: "elicitation_request",
-                      requestId: requestId2,
-                      message: elicitationRequest.message,
-                      schema: elicitationRequest.requestedSchema,
-                      timestamp: /* @__PURE__ */ new Date()
-                    })}
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({ type: "tool_executing", toolName, parameters: parameters || {}, message: "Executing tool..." })}
 
 `
-                  )
-                );
-              }
-              return new Promise((resolve, reject) => {
-                pendingElicitations.set(requestId2, { resolve, reject });
-                setTimeout(() => {
-                  if (pendingElicitations.has(requestId2)) {
-                    pendingElicitations.delete(requestId2);
-                    reject(new Error("Elicitation timeout"));
-                  }
-                }, 3e5);
-              });
-            };
-            if (client.elicitation && client.elicitation.onRequest) {
-              const serverName = "server";
-              client.elicitation.onRequest(serverName, elicitationHandler);
-            }
-            const result = await tool.execute({
-              context: toolArgs
-            });
+              )
+            );
+            const exec = await mcpJamClientManager2.executeToolDirect(
+              toolName,
+              parameters || {}
+            );
             controller.enqueue(
               encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_result",
-                  toolName,
-                  result
-                })}
+                `data: ${JSON.stringify({ type: "tool_result", toolName, result: exec.result })}
 
 `
               )
             );
             controller.enqueue(
               encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "elicitation_complete",
-                  toolName
-                })}
+                `data: ${JSON.stringify({ type: "elicitation_complete", toolName })}
 
 `
               )
             );
-          }
-          controller.enqueue(encoder.encode(`data: [DONE]
+            controller.enqueue(encoder.encode(`data: [DONE]
 
 `));
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : "Unknown error";
+            controller.close();
+            return;
+          }
+        } catch (err) {
           controller.enqueue(
             encoder.encode(
-              `data: ${JSON.stringify({
-                type: "tool_error",
-                error: errorMsg
-              })}
+              `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
 
 `
             )
           );
+          controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+          controller.close();
         } finally {
-          if (client) {
-            await client.disconnect();
+          const mcpJamClientManager2 = c.mcpJamClientManager;
+          if (mcpJamClientManager2) {
+            mcpJamClientManager2.clearElicitationCallback();
           }
-          controller.close();
         }
       }
     });
@@ -460,12 +412,6 @@ tools.post("/", async (c) => {
     });
   } catch (error) {
     const errorMsg = error instanceof Error ? error.message : "Unknown error";
-    if (client) {
-      try {
-        await client.disconnect();
-      } catch (cleanupError) {
-      }
-    }
     return c.json(
       {
         success: false,
@@ -478,30 +424,17 @@ tools.post("/", async (c) => {
 var tools_default = tools;
 
 // routes/mcp/resources.ts
-import { Hono as Hono3 } from "hono";
-var resources = new Hono3();
+import { Hono as Hono4 } from "hono";
+var resources = new Hono4();
 resources.post("/list", async (c) => {
   try {
-    const { serverConfig } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    const client = createMCPClient(
-      validation.config,
-      `resources-list-${Date.now()}`
-    );
-    try {
-      const resources2 = await client.resources.list();
-      await client.disconnect();
-      return c.json({ resources: resources2 });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
+    const { serverId } = await c.req.json();
+    if (!serverId) {
+      return c.json({ success: false, error: "serverId is required" }, 400);
     }
+    const mcpClientManager = c.mcpJamClientManager;
+    const serverResources = mcpClientManager.getResourcesForServer(serverId);
+    return c.json({ resources: { [serverId]: serverResources } });
   } catch (error) {
     console.error("Error fetching resources:", error);
     return c.json(
@@ -515,13 +448,9 @@ resources.post("/list", async (c) => {
 });
 resources.post("/read", async (c) => {
   try {
-    const { serverConfig, uri } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
+    const { serverId, uri } = await c.req.json();
+    if (!serverId) {
+      return c.json({ success: false, error: "serverId is required" }, 400);
     }
     if (!uri) {
       return c.json(
@@ -532,18 +461,9 @@ resources.post("/read", async (c) => {
         400
       );
     }
-    const client = createMCPClient(
-      validation.config,
-      `resources-read-${Date.now()}`
-    );
-    try {
-      const content = await client.resources.read("server", uri);
-      await client.disconnect();
-      return c.json({ content });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
-    }
+    const mcpClientManager = c.mcpJamClientManager;
+    const content = await mcpClientManager.getResource(uri, serverId);
+    return c.json({ content });
   } catch (error) {
     console.error("Error reading resource:", error);
     return c.json(
@@ -558,30 +478,17 @@ resources.post("/read", async (c) => {
 var resources_default = resources;
 
 // routes/mcp/prompts.ts
-import { Hono as Hono4 } from "hono";
-var prompts = new Hono4();
+import { Hono as Hono5 } from "hono";
+var prompts = new Hono5();
 prompts.post("/list", async (c) => {
   try {
-    const { serverConfig } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
-    }
-    const client = createMCPClient(
-      validation.config,
-      `prompts-list-${Date.now()}`
-    );
-    try {
-      const prompts2 = await client.prompts.list();
-      await client.disconnect();
-      return c.json({ prompts: prompts2 });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
+    const { serverId } = await c.req.json();
+    if (!serverId) {
+      return c.json({ success: false, error: "serverId is required" }, 400);
     }
+    const mcpJamClientManager2 = c.mcpJamClientManager;
+    const serverPrompts = mcpJamClientManager2.getPromptsForServer(serverId);
+    return c.json({ prompts: { [serverId]: serverPrompts } });
   } catch (error) {
     console.error("Error fetching prompts:", error);
     return c.json(
@@ -595,13 +502,9 @@ prompts.post("/list", async (c) => {
 });
 prompts.post("/get", async (c) => {
   try {
-    const { serverConfig, name, args } = await c.req.json();
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      return c.json(
-        { success: false, error: validation.error.message },
-        validation.error.status
-      );
+    const { serverId, name, args } = await c.req.json();
+    if (!serverId) {
+      return c.json({ success: false, error: "serverId is required" }, 400);
     }
     if (!name) {
       return c.json(
@@ -612,22 +515,13 @@ prompts.post("/get", async (c) => {
         400
       );
     }
-    const client = createMCPClient(
-      validation.config,
-      `prompts-get-${Date.now()}`
+    const mcpJamClientManager2 = c.mcpJamClientManager;
+    const content = await mcpJamClientManager2.getPrompt(
+      name,
+      serverId,
+      args || {}
     );
-    try {
-      const content = await client.prompts.get({
-        serverName: "server",
-        name,
-        args: args || {}
-      });
-      await client.disconnect();
-      return c.json({ content });
-    } catch (error) {
-      await client.disconnect();
-      throw error;
-    }
+    return c.json({ content });
   } catch (error) {
     console.error("Error getting prompt:", error);
     return c.json(
@@ -642,14 +536,16 @@ prompts.post("/get", async (c) => {
 var prompts_default = prompts;
 
 // routes/mcp/chat.ts
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { Agent } from "@mastra/core/agent";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOllama } from "ollama-ai-provider";
-import { TextEncoder as TextEncoder2 } from "util";
+import { TextEncoder as TextEncoder3 } from "util";
 
 // ../client/src/lib/chat-utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
 function getDefaultTemperatureByProvider(provider) {
   switch (provider) {
     case "openai":
@@ -673,7 +569,7 @@ try {
 } catch {
 }
 var pendingElicitations2 = /* @__PURE__ */ new Map();
-var chat = new Hono5();
+var chat = new Hono6();
 var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
   if (!modelDefinition?.id || !modelDefinition?.provider) {
     throw new Error(
@@ -696,40 +592,11 @@ var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
       })(modelDefinition.id, {
         simulateStreaming: true
       });
-    default:
-      throw new Error(
-        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
-      );
-  }
-};
-var createElicitationHandler = (streamingContext) => {
-  return async (elicitationRequest) => {
-    const requestId = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    if (streamingContext.controller && streamingContext.encoder) {
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({
-            type: "elicitation_request",
-            requestId,
-            message: elicitationRequest.message,
-            schema: elicitationRequest.requestedSchema,
-            timestamp: /* @__PURE__ */ new Date()
-          })}
-
-`
-        )
-      );
-    }
-    return new Promise((resolve, reject) => {
-      pendingElicitations2.set(requestId, { resolve, reject });
-      setTimeout(() => {
-        if (pendingElicitations2.has(requestId)) {
-          pendingElicitations2.delete(requestId);
-          reject(new Error("Elicitation timeout"));
-        }
-      }, ELICITATION_TIMEOUT);
-    });
-  };
+    default:
+      throw new Error(
+        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
+      );
+  }
 };
 var wrapToolsWithStreaming = (tools2, streamingContext) => {
   const wrappedTools = {};
@@ -862,6 +729,29 @@ var handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults) =>
         }
       }
     }
+    streamingContext.stepIndex = (streamingContext.stepIndex || 0) + 1;
+    if (streamingContext.controller && streamingContext.encoder) {
+      streamingContext.controller.enqueue(
+        streamingContext.encoder.encode(
+          `data: ${JSON.stringify({
+            type: "trace_step",
+            step: streamingContext.stepIndex,
+            text,
+            toolCalls: (toolCalls || []).map((c) => ({
+              name: c.name || c.toolName,
+              params: c.params || c.args || {}
+            })),
+            toolResults: (toolResults || []).map((r) => ({
+              result: r.result,
+              error: r.error
+            })),
+            timestamp: /* @__PURE__ */ new Date()
+          })}
+
+`
+        )
+      );
+    }
   } catch (err) {
     dbg("onStepFinish error", err);
   }
@@ -916,15 +806,6 @@ var fallbackToCompletion = async (agent, messages, streamingContext, provider) =
     );
   }
 };
-var safeDisconnect = async (client) => {
-  if (client) {
-    try {
-      await client.disconnect();
-    } catch (cleanupError) {
-      console.warn("[mcp/chat] Error cleaning up MCP client:", cleanupError);
-    }
-  }
-};
 var createStreamingResponse = async (agent, messages, toolsets, streamingContext, provider) => {
   const stream = await agent.stream(messages, {
     maxSteps: MAX_AGENT_STEPS,
@@ -955,7 +836,7 @@ var createStreamingResponse = async (agent, messages, toolsets, streamingContext
   );
 };
 chat.post("/", async (c) => {
-  let client = null;
+  const mcpClientManager = c.mcpJamClientManager;
   try {
     const requestData = await c.req.json();
     const {
@@ -994,110 +875,592 @@ chat.post("/", async (c) => {
       pendingElicitations2.delete(requestId);
       return c.json({ success: true });
     }
-    if (!model?.id || !apiKey || !messages) {
-      return c.json(
-        {
-          success: false,
-          error: "model (with id), apiKey, and messages are required"
-        },
-        400
-      );
+    if (!model?.id || !apiKey || !messages) {
+      return c.json(
+        {
+          success: false,
+          error: "model (with id), apiKey, and messages are required"
+        },
+        400
+      );
+    }
+    if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+      return c.json(
+        {
+          success: false,
+          error: "No server configs provided"
+        },
+        400
+      );
+    }
+    const serverErrors = {};
+    const connectedServers = [];
+    for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
+      try {
+        await mcpClientManager.connectToServer(serverName, serverConfig);
+        connectedServers.push(serverName);
+        dbg("Connected to server", { serverName });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        serverErrors[serverName] = errorMessage;
+        dbg("Failed to connect to server", { serverName, error: errorMessage });
+      }
+    }
+    if (connectedServers.length === 0) {
+      return c.json(
+        {
+          success: false,
+          error: "Failed to connect to any servers",
+          details: serverErrors
+        },
+        400
+      );
+    }
+    if (Object.keys(serverErrors).length > 0) {
+      dbg("Some servers failed to connect", {
+        connectedServers,
+        failedServers: Object.keys(serverErrors),
+        errors: serverErrors
+      });
+    }
+    const llmModel = createLlmModel(model, apiKey, ollamaBaseUrl);
+    const agent = new Agent({
+      name: "MCP Chat Agent",
+      instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
+      model: llmModel,
+      tools: void 0
+      // Start without tools, add them in streaming context
+    });
+    const formattedMessages = messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content
+    }));
+    const allTools = mcpClientManager.getAvailableTools();
+    const toolsByServer = {};
+    for (const tool of allTools) {
+      if (!toolsByServer[tool.serverId]) {
+        toolsByServer[tool.serverId] = {};
+      }
+      toolsByServer[tool.serverId][tool.name] = {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        execute: async (params) => {
+          return await mcpClientManager.executeToolDirect(
+            `${tool.serverId}:${tool.name}`,
+            params
+          );
+        }
+      };
+    }
+    dbg("Streaming start", {
+      connectedServers,
+      toolCount: allTools.length,
+      messageCount: formattedMessages.length
+    });
+    const encoder = new TextEncoder3();
+    const readableStream = new ReadableStream({
+      async start(controller) {
+        const streamingContext = {
+          controller,
+          encoder,
+          toolCallId: 0,
+          lastEmittedToolCallId: null,
+          stepIndex: 0
+        };
+        const flattenedTools = {};
+        Object.values(toolsByServer).forEach((serverTools) => {
+          Object.assign(flattenedTools, serverTools);
+        });
+        const streamingWrappedTools = wrapToolsWithStreaming(
+          flattenedTools,
+          streamingContext
+        );
+        const streamingAgent = new Agent({
+          name: agent.name,
+          instructions: agent.instructions,
+          model: agent.model,
+          tools: Object.keys(streamingWrappedTools).length > 0 ? streamingWrappedTools : void 0
+        });
+        mcpClientManager.setElicitationCallback(async (request) => {
+          const elicitationRequest = {
+            message: request.message,
+            requestedSchema: request.schema
+          };
+          if (streamingContext.controller && streamingContext.encoder) {
+            streamingContext.controller.enqueue(
+              streamingContext.encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "elicitation_request",
+                  requestId: request.requestId,
+                  message: elicitationRequest.message,
+                  schema: elicitationRequest.requestedSchema,
+                  timestamp: /* @__PURE__ */ new Date()
+                })}
+
+`
+              )
+            );
+          }
+          return new Promise((resolve, reject) => {
+            pendingElicitations2.set(request.requestId, { resolve, reject });
+            setTimeout(() => {
+              if (pendingElicitations2.has(request.requestId)) {
+                pendingElicitations2.delete(request.requestId);
+                reject(new Error("Elicitation timeout"));
+              }
+            }, ELICITATION_TIMEOUT);
+          });
+        });
+        try {
+          await createStreamingResponse(
+            streamingAgent,
+            formattedMessages,
+            toolsByServer,
+            streamingContext,
+            provider
+          );
+        } catch (error) {
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({
+                type: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              })}
+
+`
+            )
+          );
+        } finally {
+          mcpClientManager.clearElicitationCallback();
+          controller.close();
+        }
+      }
+    });
+    return new Response(readableStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("[mcp/chat] Error in chat API:", error);
+    mcpClientManager.clearElicitationCallback();
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var chat_default = chat;
+
+// routes/mcp/tests.ts
+import { Hono as Hono7 } from "hono";
+import { writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { createOllama as createOllama2 } from "ollama-ai-provider";
+import { Agent as Agent2 } from "@mastra/core/agent";
+
+// utils/mcp-utils.ts
+import { MCPClient } from "@mastra/mcp";
+function validateServerConfig(serverConfig) {
+  if (!serverConfig) {
+    return {
+      success: false,
+      error: {
+        message: "Server configuration is required",
+        status: 400
+      }
+    };
+  }
+  const config = { ...serverConfig };
+  if (config.url) {
+    try {
+      if (typeof config.url === "string") {
+        const parsed = new URL(config.url);
+        parsed.search = "";
+        parsed.hash = "";
+        config.url = parsed;
+      } else if (typeof config.url === "object" && !config.url.href) {
+        return {
+          success: false,
+          error: {
+            message: "Invalid URL configuration",
+            status: 400
+          }
+        };
+      }
+      if (config.oauth?.access_token) {
+        const authHeaders = {
+          Authorization: `Bearer ${config.oauth.access_token}`,
+          ...config.requestInit?.headers || {}
+        };
+        config.requestInit = {
+          ...config.requestInit,
+          headers: authHeaders
+        };
+        config.eventSourceInit = {
+          fetch(input, init) {
+            const headers = new Headers(init?.headers || {});
+            headers.set(
+              "Authorization",
+              `Bearer ${config.oauth.access_token}`
+            );
+            if (config.requestInit?.headers) {
+              const requestHeaders = new Headers(config.requestInit.headers);
+              requestHeaders.forEach((value, key) => {
+                if (key.toLowerCase() !== "authorization") {
+                  headers.set(key, value);
+                }
+              });
+            }
+            return fetch(input, {
+              ...init,
+              headers
+            });
+          }
+        };
+      } else if (config.requestInit?.headers) {
+        config.eventSourceInit = {
+          fetch(input, init) {
+            const headers = new Headers(init?.headers || {});
+            const requestHeaders = new Headers(config.requestInit.headers);
+            requestHeaders.forEach((value, key) => {
+              headers.set(key, value);
+            });
+            return fetch(input, {
+              ...init,
+              headers
+            });
+          }
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          message: `Invalid URL format: ${error}`,
+          status: 400
+        }
+      };
+    }
+  }
+  return {
+    success: true,
+    config
+  };
+}
+function generateUniqueServerID(serverName) {
+  const normalizedBase = normalizeServerConfigName(serverName);
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${normalizedBase}_${timestamp}_${random}`;
+}
+var validateMultipleServerConfigs = (serverConfigs) => {
+  if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+    return {
+      success: false,
+      error: {
+        message: "At least one server configuration is required",
+        status: 400
+      }
+    };
+  }
+  const validConfigs = {};
+  const serverNameMapping = {};
+  const errors = {};
+  let hasErrors = false;
+  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
+    const validationResult = validateServerConfig(serverConfig);
+    if (validationResult.success && validationResult.config) {
+      const serverID = generateUniqueServerID(serverName);
+      validConfigs[serverID] = validationResult.config;
+      serverNameMapping[serverID] = serverName;
+    } else {
+      hasErrors = true;
+      let errorMessage = "Configuration validation failed";
+      if (validationResult.error) {
+        errorMessage = validationResult.error.message;
+      }
+      errors[serverName] = errorMessage;
+    }
+  }
+  if (!hasErrors) {
+    return {
+      success: true,
+      validConfigs,
+      serverNameMapping
+    };
+  }
+  if (Object.keys(validConfigs).length > 0) {
+    return {
+      success: false,
+      validConfigs,
+      serverNameMapping,
+      errors
+    };
+  }
+  return {
+    success: false,
+    errors,
+    error: {
+      message: "All server configurations failed validation",
+      status: 400
+    }
+  };
+};
+function createMCPClientWithMultipleConnections(serverConfigs) {
+  const originalMCPClient = new MCPClient({
+    id: `chat-${Date.now()}`,
+    servers: serverConfigs
+  });
+  const originalGetTools = originalMCPClient.getTools.bind(originalMCPClient);
+  originalMCPClient.getTools = async () => {
+    const tools2 = await originalGetTools();
+    const fixedTools = {};
+    for (const [toolName, toolConfig] of Object.entries(tools2)) {
+      const parts = toolName.split("_");
+      if (parts.length >= 3 && parts[0] === parts[1]) {
+        const fixedName = parts.slice(1).join("_");
+        fixedTools[fixedName] = toolConfig;
+      } else {
+        fixedTools[toolName] = toolConfig;
+      }
     }
-    if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+    return fixedTools;
+  };
+  return originalMCPClient;
+}
+function normalizeServerConfigName(serverName) {
+  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+}
+
+// routes/mcp/tests.ts
+var tests = new Hono7();
+tests.post("/generate", async (c) => {
+  try {
+    const body = await c.req.json();
+    const test = body?.test;
+    const servers2 = body?.servers;
+    const model = body?.model;
+    if (!test?.id || !test?.prompt || !servers2 || Object.keys(servers2).length === 0) {
       return c.json(
-        {
-          success: false,
-          error: "No server configs provided"
-        },
+        { success: false, error: "Missing test, servers, or prompt" },
         400
       );
     }
-    const validation = validateMultipleServerConfigs(serverConfigs);
-    if (!validation.success) {
-      dbg(
-        "Server config validation failed",
-        validation.errors || validation.error
-      );
-      return c.json(
-        {
-          success: false,
-          error: validation.error.message,
-          details: validation.errors
-        },
-        validation.error.status
-      );
+    const safeName = String(test.title || test.id).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+    const filename = `@TestAgent_${safeName || test.id}.ts`;
+    const fileContents = `import { Agent } from "@mastra/core/agent";
+import { MCPClient } from "@mastra/mcp";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOllama } from "ollama-ai-provider";
+
+const servers = ${JSON.stringify(servers2, null, 2)} as const;
+
+function createModel() {
+  const def = ${JSON.stringify(model || null)} as any;
+  if (!def) throw new Error("Model not provided by UI when generating test agent");
+  switch (def.provider) {
+    case "anthropic": return createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })(def.id);
+    case "openai": return createOpenAI({ apiKey: process.env.OPENAI_API_KEY! })(def.id);
+    case "deepseek": return createOpenAI({ apiKey: process.env.DEEPSEEK_API_KEY!, baseURL: "https://api.deepseek.com/v1" })(def.id);
+    case "ollama": return createOllama({ baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434" })(def.id, { simulateStreaming: true });
+    default: throw new Error("Unsupported provider: " + def.provider);
+  }
+}
+
+export const createTestAgent = async () => {
+  const mcp = new MCPClient({ servers });
+  const toolsets = await mcp.getToolsets();
+  return new Agent({
+    name: ${JSON.stringify(test.title || "Test Agent")},
+    instructions: ${JSON.stringify(test.prompt)},
+    model: createModel(),
+    tools: undefined,
+    defaultGenerateOptions: { toolChoice: "auto" }
+  });
+};
+`;
+    const targetPath = join(process.cwd(), "server", "agents", filename);
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, fileContents, "utf8");
+    return c.json({ success: true, file: `server/agents/${filename}` });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    return c.json({ success: false, error: msg }, 500);
+  }
+});
+var tests_default = tests;
+tests.post("/run-all", async (c) => {
+  const encoder = new TextEncoder();
+  try {
+    let createModel2 = function(model) {
+      switch (model.provider) {
+        case "anthropic":
+          return createAnthropic2({
+            apiKey: providerApiKeys?.anthropic || process.env.ANTHROPIC_API_KEY || ""
+          })(model.id);
+        case "openai":
+          return createOpenAI2({
+            apiKey: providerApiKeys?.openai || process.env.OPENAI_API_KEY || ""
+          })(model.id);
+        case "deepseek":
+          return createOpenAI2({
+            apiKey: providerApiKeys?.deepseek || process.env.DEEPSEEK_API_KEY || "",
+            baseURL: "https://api.deepseek.com/v1"
+          })(model.id);
+        case "ollama":
+          return createOllama2({
+            baseURL: ollamaBaseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434"
+          })(model.id, { simulateStreaming: true });
+        default:
+          throw new Error(`Unsupported provider: ${model.provider}`);
+      }
+    };
+    var createModel = createModel2;
+    const body = await c.req.json();
+    const testsInput = body?.tests || [];
+    const allServers = body?.allServers || {};
+    const providerApiKeys = body?.providerApiKeys || {};
+    const ollamaBaseUrl = body?.ollamaBaseUrl;
+    const maxConcurrency = Math.max(
+      1,
+      Math.min(8, body?.concurrency ?? 5)
+    );
+    if (!Array.isArray(testsInput) || testsInput.length === 0) {
+      return c.json({ success: false, error: "No tests provided" }, 400);
     }
-    client = createMCPClientWithMultipleConnections(validation.validConfigs);
-    const llmModel = createLlmModel(model, apiKey, ollamaBaseUrl);
-    const tools2 = await client.getTools();
-    const agent = new Agent({
-      name: "MCP Chat Agent",
-      instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
-      model: llmModel,
-      tools: void 0
-      // Start without tools, add them in streaming context
-    });
-    const formattedMessages = messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content
-    }));
-    const toolsets = await client.getToolsets();
-    dbg("Streaming start", {
-      toolsetServers: Object.keys(toolsets),
-      messageCount: formattedMessages.length
-    });
-    const encoder = new TextEncoder2();
     const readableStream = new ReadableStream({
       async start(controller) {
-        const streamingContext = {
-          controller,
-          encoder,
-          toolCallId: 0,
-          lastEmittedToolCallId: null
-        };
-        const streamingWrappedTools = wrapToolsWithStreaming(
-          tools2,
-          streamingContext
-        );
-        const streamingAgent = new Agent({
-          name: agent.name,
-          instructions: agent.instructions,
-          model: agent.model,
-          tools: Object.keys(streamingWrappedTools).length > 0 ? streamingWrappedTools : void 0
-        });
-        if (client?.elicitation?.onRequest) {
-          for (const serverName of Object.keys(serverConfigs)) {
-            const normalizedName = normalizeServerConfigName(serverName);
-            const elicitationHandler = createElicitationHandler(streamingContext);
-            client.elicitation.onRequest(normalizedName, elicitationHandler);
-          }
-        }
-        try {
-          if (client) {
-            await createStreamingResponse(
-              streamingAgent,
-              formattedMessages,
-              toolsets,
-              streamingContext,
-              provider
-            );
-          } else {
-            throw new Error("MCP client is null");
+        let active = 0;
+        let index = 0;
+        let failed = false;
+        const runNext = async () => {
+          if (index >= testsInput.length) {
+            if (active === 0) {
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "run_complete", passed: !failed })}
+
+`
+                )
+              );
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+              controller.close();
+            }
+            return;
           }
-        } catch (error) {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "error",
-                error: error instanceof Error ? error.message : "Unknown error"
-              })}
+          const test = testsInput[index++];
+          active++;
+          (async () => {
+            const calledTools = /* @__PURE__ */ new Set();
+            const expectedSet = new Set(test.expectedTools || []);
+            let step = 0;
+            let client = null;
+            try {
+              let serverConfigs = {};
+              if (test.selectedServers && test.selectedServers.length > 0) {
+                for (const name of test.selectedServers) {
+                  if (allServers[name]) serverConfigs[name] = allServers[name];
+                }
+              } else {
+                for (const [name, cfg] of Object.entries(allServers)) {
+                  serverConfigs[name] = cfg;
+                }
+              }
+              const validation = validateMultipleServerConfigs(serverConfigs);
+              let finalServers = {};
+              if (validation.success && validation.validConfigs) {
+                finalServers = validation.validConfigs;
+              } else if (validation.validConfigs && Object.keys(validation.validConfigs).length > 0) {
+                finalServers = validation.validConfigs;
+              } else {
+                throw new Error("No valid MCP server configs for test");
+              }
+              client = createMCPClientWithMultipleConnections(finalServers);
+              const model = createModel2(test.model);
+              const agent = new Agent2({
+                name: `TestAgent-${test.id}`,
+                instructions: "You are a helpful assistant with access to MCP tools",
+                model
+              });
+              const toolsets = await client.getToolsets();
+              const stream = await agent.stream(
+                [{ role: "user", content: test.prompt || "" }],
+                {
+                  maxSteps: 10,
+                  toolsets,
+                  onStepFinish: ({ text, toolCalls, toolResults }) => {
+                    step += 1;
+                    (toolCalls || []).forEach((c2) => {
+                      const toolName = c2?.name || c2?.toolName;
+                      if (toolName) {
+                        calledTools.add(toolName);
+                      }
+                    });
+                    controller.enqueue(
+                      encoder.encode(
+                        `data: ${JSON.stringify({
+                          type: "trace_step",
+                          testId: test.id,
+                          step,
+                          text,
+                          toolCalls,
+                          toolResults
+                        })}
 
 `
-            )
-          );
-        } finally {
-          await safeDisconnect(client);
-          controller.close();
+                      )
+                    );
+                  }
+                }
+              );
+              for await (const _ of stream.textStream) {
+              }
+              const called = Array.from(calledTools);
+              const missing = Array.from(expectedSet).filter(
+                (t) => !calledTools.has(t)
+              );
+              const unexpected = called.filter((t) => !expectedSet.has(t));
+              const passed = missing.length === 0 && unexpected.length === 0;
+              if (!passed) failed = true;
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "result", testId: test.id, passed, calledTools: called, missingTools: missing, unexpectedTools: unexpected })}
+
+`
+                )
+              );
+            } catch (err) {
+              failed = true;
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "result", testId: test.id, passed: false, error: err?.message })}
+
+`
+                )
+              );
+            } finally {
+              try {
+                await client?.disconnect();
+              } catch {
+              }
+              active--;
+              runNext();
+            }
+          })();
+        };
+        for (let i = 0; i < Math.min(maxConcurrency, testsInput.length); i++) {
+          runNext();
         }
       }
     });
@@ -1108,23 +1471,17 @@ chat.post("/", async (c) => {
         Connection: "keep-alive"
       }
     });
-  } catch (error) {
-    console.error("[mcp/chat] Error in chat API:", error);
-    await safeDisconnect(client);
+  } catch (err) {
     return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
+      { success: false, error: err?.message || "Unknown error" },
       500
     );
   }
 });
-var chat_default = chat;
 
 // routes/mcp/oauth.ts
-import { Hono as Hono6 } from "hono";
-var oauth = new Hono6();
+import { Hono as Hono8 } from "hono";
+var oauth = new Hono8();
 oauth.get("/metadata", async (c) => {
   try {
     const url = c.req.query("url");
@@ -1170,7 +1527,7 @@ oauth.get("/metadata", async (c) => {
 var oauth_default = oauth;
 
 // routes/mcp/index.ts
-var mcp = new Hono7();
+var mcp = new Hono9();
 mcp.get("/health", (c) => {
   return c.json({
     service: "MCP API",
@@ -1180,12 +1537,378 @@ mcp.get("/health", (c) => {
 });
 mcp.route("/chat", chat_default);
 mcp.route("/connect", connect_default);
+mcp.route("/servers", servers_default);
 mcp.route("/tools", tools_default);
+mcp.route("/tests", tests_default);
 mcp.route("/resources", resources_default);
 mcp.route("/prompts", prompts_default);
 mcp.route("/oauth", oauth_default);
 var mcp_default = mcp;
 
+// services/mcpjam-client-manager.ts
+import { MCPClient as MCPClient2 } from "@mastra/mcp";
+function generateUniqueServerId(serverId) {
+  const normalizedBase = serverId.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${normalizedBase}_${timestamp}_${random}`;
+}
+var MCPJamClientManager = class {
+  mcpClients = /* @__PURE__ */ new Map();
+  statuses = /* @__PURE__ */ new Map();
+  configs = /* @__PURE__ */ new Map();
+  // Map original server names to unique IDs
+  serverIdMapping = /* @__PURE__ */ new Map();
+  // Track in-flight connections to avoid duplicate concurrent connects
+  pendingConnections = /* @__PURE__ */ new Map();
+  toolRegistry = /* @__PURE__ */ new Map();
+  resourceRegistry = /* @__PURE__ */ new Map();
+  promptRegistry = /* @__PURE__ */ new Map();
+  // Store for pending elicitation requests with Promise resolvers
+  pendingElicitations = /* @__PURE__ */ new Map();
+  // Optional callback for handling elicitation requests
+  elicitationCallback;
+  // Helper method to get unique ID for a server name
+  getServerUniqueId(serverName) {
+    return this.serverIdMapping.get(serverName);
+  }
+  // Public method to get server ID for external use (like frontend)
+  getServerIdForName(serverName) {
+    return this.serverIdMapping.get(serverName);
+  }
+  async connectToServer(serverId, serverConfig) {
+    const pending = this.pendingConnections.get(serverId);
+    if (pending) {
+      await pending;
+      return;
+    }
+    const connectPromise = (async () => {
+      let id = this.serverIdMapping.get(serverId);
+      if (!id) {
+        id = generateUniqueServerId(serverId);
+        this.serverIdMapping.set(serverId, id);
+      }
+      if (this.mcpClients.has(id)) return;
+      const validation = validateServerConfig(serverConfig);
+      if (!validation.success) {
+        this.statuses.set(id, "error");
+        throw new Error(validation.error.message);
+      }
+      this.configs.set(id, validation.config);
+      this.statuses.set(id, "connecting");
+      const client = new MCPClient2({
+        id: `mcpjam-${id}`,
+        servers: { [id]: validation.config }
+      });
+      try {
+        await client.getTools();
+        this.mcpClients.set(id, client);
+        this.statuses.set(id, "connected");
+        if (client.elicitation?.onRequest) {
+          client.elicitation.onRequest(
+            id,
+            async (elicitationRequest) => {
+              return await this.handleElicitationRequest(elicitationRequest);
+            }
+          );
+        }
+        await this.discoverServerResources(id);
+      } catch (err) {
+        this.statuses.set(id, "error");
+        try {
+          await client.disconnect();
+        } catch {
+        }
+        this.mcpClients.delete(id);
+        throw err;
+      }
+    })().finally(() => {
+      this.pendingConnections.delete(serverId);
+    });
+    this.pendingConnections.set(serverId, connectPromise);
+    await connectPromise;
+  }
+  async disconnectFromServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return;
+    const client = this.mcpClients.get(id);
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+    }
+    this.mcpClients.delete(id);
+    this.statuses.set(id, "disconnected");
+    this.serverIdMapping.delete(serverId);
+    for (const key of Array.from(this.toolRegistry.keys())) {
+      const item = this.toolRegistry.get(key);
+      if (item.serverId === id) this.toolRegistry.delete(key);
+    }
+    for (const key of Array.from(this.resourceRegistry.keys())) {
+      const item = this.resourceRegistry.get(key);
+      if (item.serverId === id) this.resourceRegistry.delete(key);
+    }
+    for (const key of Array.from(this.promptRegistry.keys())) {
+      const item = this.promptRegistry.get(key);
+      if (item.serverId === id) this.promptRegistry.delete(key);
+    }
+  }
+  getConnectionStatus(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    return id ? this.statuses.get(id) || "disconnected" : "disconnected";
+  }
+  getConnectedServers() {
+    const servers2 = {};
+    for (const [originalName, uniqueId] of this.serverIdMapping.entries()) {
+      servers2[originalName] = {
+        status: this.statuses.get(uniqueId) || "disconnected",
+        config: this.configs.get(uniqueId)
+      };
+    }
+    return servers2;
+  }
+  async discoverAllResources() {
+    const serverIds = Array.from(this.mcpClients.keys());
+    await Promise.all(serverIds.map((id) => this.discoverServerResources(id)));
+  }
+  async discoverServerResources(serverId) {
+    const client = this.mcpClients.get(serverId);
+    if (!client) return;
+    const toolsets = await client.getToolsets();
+    const flattenedTools = {};
+    Object.values(toolsets).forEach((serverTools) => {
+      Object.assign(flattenedTools, serverTools);
+    });
+    for (const [name, tool] of Object.entries(flattenedTools)) {
+      this.toolRegistry.set(`${serverId}:${name}`, {
+        name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        serverId
+      });
+    }
+    try {
+      const res = await client.resources.list();
+      for (const [, list] of Object.entries(res)) {
+        for (const r of list) {
+          this.resourceRegistry.set(`${serverId}:${r.uri}`, {
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType,
+            serverId
+          });
+        }
+      }
+    } catch {
+    }
+    try {
+      const prompts2 = await client.prompts.list();
+      for (const [, list] of Object.entries(prompts2)) {
+        for (const p of list) {
+          this.promptRegistry.set(`${serverId}:${p.name}`, {
+            name: p.name,
+            description: p.description,
+            arguments: p.arguments,
+            serverId
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  getAvailableTools() {
+    return Array.from(this.toolRegistry.values());
+  }
+  async getToolsetsForServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const client = this.mcpClients.get(id);
+    if (!client) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const toolsets = await client.getToolsets();
+    const flattenedTools = {};
+    Object.values(toolsets).forEach((serverTools) => {
+      Object.assign(flattenedTools, serverTools);
+    });
+    return flattenedTools;
+  }
+  getAvailableResources() {
+    return Array.from(this.resourceRegistry.values());
+  }
+  getResourcesForServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return [];
+    return Array.from(this.resourceRegistry.values()).filter(
+      (r) => r.serverId === id
+    );
+  }
+  getAvailablePrompts() {
+    return Array.from(this.promptRegistry.values());
+  }
+  getPromptsForServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return [];
+    return Array.from(this.promptRegistry.values()).filter(
+      (p) => p.serverId === id
+    );
+  }
+  async executeToolDirect(toolName, parameters = {}) {
+    let serverId = "";
+    let name = toolName;
+    if (toolName.includes(":")) {
+      const [sid, n] = toolName.split(":", 2);
+      const mappedId = this.getServerUniqueId(sid);
+      serverId = mappedId || (this.mcpClients.has(sid) ? sid : "");
+      name = n;
+    } else {
+      for (const tool2 of this.toolRegistry.values()) {
+        if (tool2.name === toolName) {
+          serverId = tool2.serverId;
+          name = toolName;
+          break;
+        }
+      }
+    }
+    if (!serverId) {
+      for (const [clientServerId, client2] of this.mcpClients.entries()) {
+        try {
+          const toolsets2 = await client2.getToolsets();
+          const flattenedTools2 = {};
+          Object.values(toolsets2).forEach((serverTools) => {
+            Object.assign(flattenedTools2, serverTools);
+          });
+          if (flattenedTools2[toolName]) {
+            serverId = clientServerId;
+            name = toolName;
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!serverId) {
+      throw new Error(`Tool not found in any connected server: ${toolName}`);
+    }
+    const client = this.mcpClients.get(serverId);
+    if (!client)
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    const toolsets = await client.getToolsets();
+    const flattenedTools = {};
+    Object.values(toolsets).forEach((serverTools) => {
+      Object.assign(flattenedTools, serverTools);
+    });
+    const tool = flattenedTools[name];
+    if (!tool)
+      throw new Error(`Tool '${name}' not found in server '${serverId}'`);
+    const schema = tool.inputSchema;
+    const hasContextProperty = schema && typeof schema === "object" && schema.properties && Object.prototype.hasOwnProperty.call(
+      schema.properties,
+      "context"
+    );
+    const requiresContext = hasContextProperty || schema && Array.isArray(schema.required) && schema.required.includes("context");
+    const contextWrapped = { context: parameters || {} };
+    const direct = parameters || {};
+    const attempts = requiresContext ? [contextWrapped, direct] : [direct, contextWrapped];
+    let lastError = void 0;
+    for (const args of attempts) {
+      try {
+        const result = await tool.execute(args);
+        return { result };
+      } catch (err) {
+        lastError = err;
+      }
+    }
+    throw lastError;
+  }
+  async getResource(resourceUri, serverId) {
+    let uri = resourceUri;
+    const mappedId = this.getServerUniqueId(serverId);
+    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
+    if (!resolvedServerId) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const client = this.mcpClients.get(resolvedServerId);
+    if (!client) throw new Error("No MCP client available");
+    const content = await client.resources.read(resolvedServerId, uri);
+    return { contents: content?.contents || [] };
+  }
+  async getPrompt(promptName, serverId, args) {
+    const mappedId = this.getServerUniqueId(serverId);
+    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
+    if (!resolvedServerId) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const client = this.mcpClients.get(resolvedServerId);
+    if (!client) throw new Error("No MCP client available");
+    const content = await client.prompts.get({
+      serverName: resolvedServerId,
+      name: promptName,
+      args: args || {}
+    });
+    return { content };
+  }
+  /**
+   * Handles elicitation requests from MCP servers during direct tool execution
+   */
+  async handleElicitationRequest(elicitationRequest) {
+    const requestId = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    return new Promise((resolve, reject) => {
+      this.pendingElicitations.set(requestId, { resolve, reject });
+      if (this.elicitationCallback) {
+        this.elicitationCallback({
+          requestId,
+          message: elicitationRequest.message,
+          schema: elicitationRequest.requestedSchema
+        }).then(resolve).catch(reject);
+      } else {
+        const error = new Error("ELICITATION_REQUIRED");
+        error.elicitationRequest = {
+          requestId,
+          message: elicitationRequest.message,
+          schema: elicitationRequest.requestedSchema
+        };
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Responds to a pending elicitation request
+   */
+  respondToElicitation(requestId, response) {
+    const pending = this.pendingElicitations.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    pending.resolve(response);
+    this.pendingElicitations.delete(requestId);
+    return true;
+  }
+  /**
+   * Gets the pending elicitations map for external access
+   */
+  getPendingElicitations() {
+    return this.pendingElicitations;
+  }
+  /**
+   * Sets a callback to handle elicitation requests
+   */
+  setElicitationCallback(callback) {
+    this.elicitationCallback = callback;
+  }
+  /**
+   * Clears the elicitation callback
+   */
+  clearElicitationCallback() {
+    this.elicitationCallback = void 0;
+  }
+};
+
 // index.ts
 function logBox(content, title) {
   const lines = content.split("\n");
@@ -1219,7 +1942,12 @@ function getMCPConfigFromEnv() {
     // Default name for CLI-provided servers
   };
 }
-var app = new Hono8();
+var app = new Hono10();
+var mcpJamClientManager = new MCPJamClientManager();
+app.use("*", async (c, next) => {
+  c.mcpJamClientManager = mcpJamClientManager;
+  await next();
+});
 app.use("*", logger());
 var serverPort = process.env.PORT || "3001";
 var corsOrigins = [
@@ -1251,7 +1979,7 @@ if (process.env.NODE_ENV === "production") {
     if (path.startsWith("/api/")) {
       return c.notFound();
     }
-    const indexPath = join(process.cwd(), "dist", "client", "index.html");
+    const indexPath = join2(process.cwd(), "dist", "client", "index.html");
     let htmlContent = readFileSync(indexPath, "utf-8");
     const mcpConfig = getMCPConfigFromEnv();
     if (mcpConfig) {