@mcpjam/inspector 0.9.3 → 0.9.5

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(
+            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,15 +536,196 @@ 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";
+
+// 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
+  };
+}
+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 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;
+      }
+    }
+    return fixedTools;
+  };
+  return originalMCPClient;
+}
+function normalizeServerConfigName(serverName) {
+  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+}
+
+// routes/mcp/chat.ts
 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 { MCPClient as MCPClient2 } from "@mastra/mcp";
-import { TextEncoder as TextEncoder2 } from "util";
-var chat = new Hono5();
+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":
+      return 1;
+    case "anthropic":
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+// routes/mcp/chat.ts
 var DEBUG_ENABLED = process.env.MCP_DEBUG !== "false";
+var ELICITATION_TIMEOUT = 3e5;
+var MAX_AGENT_STEPS = 10;
 var dbg = (...args) => {
   if (DEBUG_ENABLED) console.log("[mcp/chat]", ...args);
 };
@@ -659,6 +734,310 @@ try {
 } catch {
 }
 var pendingElicitations2 = /* @__PURE__ */ new Map();
+var chat = new Hono6();
+var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
+  if (!modelDefinition?.id || !modelDefinition?.provider) {
+    throw new Error(
+      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
+    );
+  }
+  switch (modelDefinition.provider) {
+    case "anthropic":
+      return createAnthropic({ apiKey })(modelDefinition.id);
+    case "openai":
+      return createOpenAI({ apiKey })(modelDefinition.id);
+    case "deepseek":
+      return createOpenAI({ apiKey, baseURL: "https://api.deepseek.com/v1" })(
+        modelDefinition.id
+      );
+    case "ollama":
+      const baseUrl = ollamaBaseUrl || "http://localhost:11434";
+      return createOllama({
+        baseURL: `${baseUrl}`
+      })(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);
+    });
+  };
+};
+var wrapToolsWithStreaming = (tools2, streamingContext) => {
+  const wrappedTools = {};
+  for (const [name, tool] of Object.entries(tools2)) {
+    wrappedTools[name] = {
+      ...tool,
+      execute: async (params) => {
+        const currentToolCallId = ++streamingContext.toolCallId;
+        const startedAt = Date.now();
+        if (streamingContext.controller && streamingContext.encoder) {
+          streamingContext.controller.enqueue(
+            streamingContext.encoder.encode(
+              `data: ${JSON.stringify({
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCallId,
+                  name,
+                  parameters: params,
+                  timestamp: /* @__PURE__ */ new Date(),
+                  status: "executing"
+                }
+              })}
+
+`
+            )
+          );
+        }
+        dbg("Tool executing", { name, currentToolCallId, params });
+        try {
+          const result = await tool.execute(params);
+          dbg("Tool result", {
+            name,
+            currentToolCallId,
+            ms: Date.now() - startedAt
+          });
+          if (streamingContext.controller && streamingContext.encoder) {
+            streamingContext.controller.enqueue(
+              streamingContext.encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tool_result",
+                  toolResult: {
+                    id: currentToolCallId,
+                    toolCallId: currentToolCallId,
+                    result,
+                    timestamp: /* @__PURE__ */ new Date()
+                  }
+                })}
+
+`
+              )
+            );
+          }
+          return result;
+        } catch (error) {
+          dbg("Tool error", {
+            name,
+            currentToolCallId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          if (streamingContext.controller && streamingContext.encoder) {
+            streamingContext.controller.enqueue(
+              streamingContext.encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "tool_result",
+                  toolResult: {
+                    id: currentToolCallId,
+                    toolCallId: currentToolCallId,
+                    error: error instanceof Error ? error.message : String(error),
+                    timestamp: /* @__PURE__ */ new Date()
+                  }
+                })}
+
+`
+              )
+            );
+          }
+          throw error;
+        }
+      }
+    };
+  }
+  return wrappedTools;
+};
+var handleAgentStepFinish = (streamingContext, text, toolCalls, toolResults) => {
+  try {
+    if (toolCalls && Array.isArray(toolCalls)) {
+      for (const call of toolCalls) {
+        const currentToolCallId = ++streamingContext.toolCallId;
+        streamingContext.lastEmittedToolCallId = currentToolCallId;
+        if (streamingContext.controller && streamingContext.encoder) {
+          streamingContext.controller.enqueue(
+            streamingContext.encoder.encode(
+              `data: ${JSON.stringify({
+                type: "tool_call",
+                toolCall: {
+                  id: currentToolCallId,
+                  name: call.name || call.toolName,
+                  parameters: call.params || call.args || {},
+                  timestamp: /* @__PURE__ */ new Date(),
+                  status: "executing"
+                }
+              })}
+
+`
+            )
+          );
+        }
+      }
+    }
+    if (toolResults && Array.isArray(toolResults)) {
+      for (const result of toolResults) {
+        const currentToolCallId = streamingContext.lastEmittedToolCallId != null ? streamingContext.lastEmittedToolCallId : ++streamingContext.toolCallId;
+        if (streamingContext.controller && streamingContext.encoder) {
+          streamingContext.controller.enqueue(
+            streamingContext.encoder.encode(
+              `data: ${JSON.stringify({
+                type: "tool_result",
+                toolResult: {
+                  id: currentToolCallId,
+                  toolCallId: currentToolCallId,
+                  result: result.result,
+                  error: result.error,
+                  timestamp: /* @__PURE__ */ new Date()
+                }
+              })}
+
+`
+            )
+          );
+        }
+      }
+    }
+    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);
+  }
+};
+var streamAgentResponse = async (streamingContext, stream) => {
+  let hasContent = false;
+  let chunkCount = 0;
+  for await (const chunk of stream.textStream) {
+    if (chunk && chunk.trim()) {
+      hasContent = true;
+      chunkCount++;
+      streamingContext.controller.enqueue(
+        streamingContext.encoder.encode(
+          `data: ${JSON.stringify({ type: "text", content: chunk })}
+
+`
+        )
+      );
+    }
+  }
+  dbg("Streaming finished", { hasContent, chunkCount });
+  return { hasContent, chunkCount };
+};
+var fallbackToCompletion = async (agent, messages, streamingContext, provider) => {
+  try {
+    const result = await agent.generate(messages, {
+      temperature: getDefaultTemperatureByProvider(provider)
+    });
+    if (result.text && result.text.trim()) {
+      streamingContext.controller.enqueue(
+        streamingContext.encoder.encode(
+          `data: ${JSON.stringify({
+            type: "text",
+            content: result.text
+          })}
+
+`
+        )
+      );
+    }
+  } catch (fallbackErr) {
+    streamingContext.controller.enqueue(
+      streamingContext.encoder.encode(
+        `data: ${JSON.stringify({
+          type: "text",
+          content: "Failed to generate response. Please try again. ",
+          error: fallbackErr instanceof Error ? fallbackErr.message : "Unknown error"
+        })}
+
+`
+      )
+    );
+  }
+};
+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,
+    temperature: getDefaultTemperatureByProvider(provider),
+    toolsets,
+    onStepFinish: ({ text, toolCalls, toolResults }) => {
+      handleAgentStepFinish(streamingContext, text, toolCalls, toolResults);
+    }
+  });
+  const { hasContent } = await streamAgentResponse(streamingContext, stream);
+  if (!hasContent) {
+    dbg("No content from textStream; falling back to completion");
+    await fallbackToCompletion(agent, messages, streamingContext, provider);
+  }
+  streamingContext.controller.enqueue(
+    streamingContext.encoder.encode(
+      `data: ${JSON.stringify({
+        type: "elicitation_complete"
+      })}
+
+`
+    )
+  );
+  streamingContext.controller.enqueue(
+    streamingContext.encoder.encode(`data: [DONE]
+
+`)
+  );
+};
 chat.post("/", async (c) => {
   let client = null;
   try {
@@ -666,6 +1045,7 @@ chat.post("/", async (c) => {
     const {
       serverConfigs,
       model,
+      provider,
       apiKey,
       systemPrompt,
       messages,
@@ -698,7 +1078,7 @@ chat.post("/", async (c) => {
       pendingElicitations2.delete(requestId);
       return c.json({ success: true });
     }
-    if (!model || !model.id || !apiKey || !messages) {
+    if (!model?.id || !apiKey || !messages) {
       return c.json(
         {
           success: false,
@@ -707,345 +1087,357 @@ chat.post("/", async (c) => {
         400
       );
     }
-    dbg("Incoming chat request", {
-      provider: model?.provider,
-      modelId: model?.id,
-      messageCount: messages?.length,
-      serverCount: serverConfigs ? Object.keys(serverConfigs).length : 0
-    });
-    if (serverConfigs && Object.keys(serverConfigs).length > 0) {
-      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
-        );
-      }
-      client = createMCPClientWithMultipleConnections(validation.validConfigs);
-      dbg("Created MCP client with servers", Object.keys(validation.validConfigs));
-    } else {
-      client = new MCPClient2({
-        id: `chat-${Date.now()}`,
-        servers: {}
-      });
-      dbg("Created MCP client without servers");
-    }
-    const llmModel = getLlmModel(model, apiKey, ollamaBaseUrl);
-    dbg("LLM model initialized", { provider: model.provider, id: model.id });
-    let toolCallId = 0;
-    let streamController = null;
-    let encoder = null;
-    let lastEmittedToolCallId = null;
-    const elicitationHandler = async (elicitationRequest) => {
-      const requestId2 = `elicit_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-      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()
-            })}
-
-`
-          )
-        );
-      }
-      dbg("Elicitation requested", { requestId: requestId2 });
-      return new Promise((resolve, reject) => {
-        pendingElicitations2.set(requestId2, { resolve, reject });
-        setTimeout(() => {
-          if (pendingElicitations2.has(requestId2)) {
-            pendingElicitations2.delete(requestId2);
-            reject(new Error("Elicitation timeout"));
-          }
-        }, 3e5);
-      });
-    };
-    if (client.elicitation && client.elicitation.onRequest && serverConfigs) {
-      for (const serverName of Object.keys(serverConfigs)) {
-        const normalizedName = serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-        client.elicitation.onRequest(normalizedName, elicitationHandler);
-        dbg("Registered elicitation handler", { serverName, normalizedName });
-      }
+    if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+      return c.json(
+        {
+          success: false,
+          error: "No server configs provided"
+        },
+        400
+      );
     }
-    const tools2 = await client.getTools();
-    const originalTools = tools2 && Object.keys(tools2).length > 0 ? tools2 : {};
-    const wrappedTools = {};
-    for (const [name, tool] of Object.entries(originalTools)) {
-      wrappedTools[name] = {
-        ...tool,
-        execute: async (params) => {
-          const currentToolCallId = ++toolCallId;
-          const startedAt = Date.now();
-          if (streamController && encoder) {
-            streamController.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({
-                  type: "tool_call",
-                  toolCall: {
-                    id: currentToolCallId,
-                    name,
-                    parameters: params,
-                    timestamp: /* @__PURE__ */ new Date(),
-                    status: "executing"
-                  }
-                })}
-
-`
-              )
-            );
-          }
-          dbg("Tool executing", { name, currentToolCallId, params });
-          try {
-            const result = await tool.execute(params);
-            dbg("Tool result", { name, currentToolCallId, ms: Date.now() - startedAt });
-            if (streamController && encoder) {
-              streamController.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_result",
-                    toolResult: {
-                      id: currentToolCallId,
-                      toolCallId: currentToolCallId,
-                      result,
-                      timestamp: /* @__PURE__ */ new Date()
-                    }
-                  })}
-
-`
-                )
-              );
-            }
-            return result;
-          } catch (error) {
-            dbg("Tool error", { name, currentToolCallId, error: error instanceof Error ? error.message : String(error) });
-            if (streamController && encoder) {
-              streamController.enqueue(
-                encoder.encode(
-                  `data: ${JSON.stringify({
-                    type: "tool_result",
-                    toolResult: {
-                      id: currentToolCallId,
-                      toolCallId: currentToolCallId,
-                      error: error instanceof Error ? error.message : String(error),
-                      timestamp: /* @__PURE__ */ new Date()
-                    }
-                  })}
-
-`
-                )
-              );
-            }
-            throw error;
-          }
-        }
-      };
+    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
+      );
     }
+    client = createMCPClientWithMultipleConnections(validation.validConfigs);
+    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: Object.keys(wrappedTools).length > 0 ? wrappedTools : void 0
+      tools: void 0
+      // Start without tools, add them in streaming context
     });
     const formattedMessages = messages.map((msg) => ({
       role: msg.role,
       content: msg.content
     }));
-    const toolsets = serverConfigs ? await client.getToolsets() : void 0;
+    const toolsets = await client.getToolsets();
     dbg("Streaming start", {
-      toolsetServers: toolsets ? Object.keys(toolsets) : [],
+      toolsetServers: Object.keys(toolsets),
       messageCount: formattedMessages.length
     });
-    let streamedAnyText = false;
-    const stream = await agent.stream(formattedMessages, {
-      maxSteps: 10,
-      // Allow up to 10 steps for tool usage
-      toolsets,
-      onStepFinish: ({ text, toolCalls, toolResults }) => {
+    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(toolsets).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
+        });
+        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 (text && streamController && encoder) {
-            streamedAnyText = true;
-            streamController.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "text", content: text })}
-
-`
-              )
+          if (client) {
+            await createStreamingResponse(
+              streamingAgent,
+              formattedMessages,
+              toolsets,
+              streamingContext,
+              provider
             );
+          } else {
+            throw new Error("MCP client is null");
           }
-          const tcList = toolCalls;
-          if (tcList && Array.isArray(tcList)) {
-            for (const call of tcList) {
-              const currentToolCallId = ++toolCallId;
-              lastEmittedToolCallId = currentToolCallId;
-              if (streamController && encoder) {
-                streamController.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({
-                      type: "tool_call",
-                      toolCall: {
-                        id: currentToolCallId,
-                        name: call.name || call.toolName,
-                        parameters: call.params || call.args || {},
-                        timestamp: /* @__PURE__ */ new Date(),
-                        status: "executing"
-                      }
-                    })}
-
-`
-                  )
-                );
-              }
-            }
-          }
-          const trList = toolResults;
-          if (trList && Array.isArray(trList)) {
-            for (const result of trList) {
-              const currentToolCallId = lastEmittedToolCallId != null ? lastEmittedToolCallId : ++toolCallId;
-              if (streamController && encoder) {
-                streamController.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({
-                      type: "tool_result",
-                      toolResult: {
-                        id: currentToolCallId,
-                        toolCallId: currentToolCallId,
-                        result: result.result,
-                        error: result.error,
-                        timestamp: /* @__PURE__ */ new Date()
-                      }
-                    })}
+        } catch (error) {
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({
+                type: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              })}
 
 `
-                  )
-                );
-              }
-            }
-          }
-        } catch (err) {
-          dbg("onStepFinish error", err);
+            )
+          );
+        } finally {
+          await safeDisconnect(client);
+          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);
+    await safeDisconnect(client);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
       },
-      onFinish: ({ text, finishReason }) => {
-        dbg("onFinish called", { finishReason, hasText: Boolean(text) });
-        try {
-          if (text && streamController && encoder) {
-            streamedAnyText = true;
-            streamController.enqueue(
-              encoder.encode(
-                `data: ${JSON.stringify({ type: "text", content: text })}
+      500
+    );
+  }
+});
+var chat_default = chat;
 
-`
-              )
-            );
-          }
-        } catch (err) {
-          dbg("onFinish enqueue error", err);
-        }
+// 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";
+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: "Missing test, servers, or prompt" },
+        400
+      );
+    }
+    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}`);
       }
-    });
-    encoder = new TextEncoder2();
+    };
+    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);
+    }
     const readableStream = new ReadableStream({
       async start(controller) {
-        streamController = controller;
-        try {
-          let hasContent = false;
-          let chunkCount = 0;
-          for await (const chunk of stream.textStream) {
-            if (chunk && chunk.trim()) {
-              hasContent = true;
-              chunkCount++;
+        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: "text", content: chunk })}
+                  `data: ${JSON.stringify({ type: "run_complete", passed: !failed })}
 
 `
                 )
               );
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+              controller.close();
             }
+            return;
           }
-          dbg("Streaming finished", { hasContent, chunkCount });
-          if (!hasContent && !streamedAnyText) {
-            dbg("No content from textStream/callbacks; falling back to generate()");
+          const test = testsInput[index++];
+          active++;
+          (async () => {
+            const calledTools = /* @__PURE__ */ new Set();
+            const expectedSet = new Set(test.expectedTools || []);
+            let step = 0;
+            let client = null;
             try {
-              const gen = await agent.generate(formattedMessages, {
-                maxSteps: 10,
-                toolsets
-              });
-              const finalText = gen.text || "";
-              if (finalText) {
-                controller.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({ type: "text", content: finalText })}
-
-`
-                  )
-                );
+              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 {
-                dbg("generate() also returned empty text");
-                controller.enqueue(
-                  encoder.encode(
-                    `data: ${JSON.stringify({ type: "text", content: "I apologize, but I couldn't generate a response. Please try again." })}
+                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
+                        })}
 
 `
-                  )
-                );
+                      )
+                    );
+                  }
+                }
+              );
+              for await (const _ of stream.textStream) {
               }
-            } catch (fallbackErr) {
-              console.error("[mcp/chat] Fallback generate() error:", fallbackErr);
+              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: "error", error: fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr) })}
+                  `data: ${JSON.stringify({ type: "result", testId: test.id, passed, calledTools: called, missingTools: missing, unexpectedTools: unexpected })}
 
 `
                 )
               );
-            }
-          }
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "elicitation_complete"
-              })}
-
-`
-            )
-          );
-          controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-        } catch (error) {
-          console.error("[mcp/chat] Streaming error:", error);
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "error",
-                error: error instanceof Error ? error.message : "Unknown error"
-              })}
+            } catch (err) {
+              failed = true;
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "result", testId: test.id, passed: false, error: err?.message })}
 
 `
-            )
-          );
-        } finally {
-          if (client) {
-            try {
-              await client.disconnect();
-            } catch (cleanupError) {
-              console.warn(
-                "[mcp/chat] Error cleaning up MCP client after streaming:",
-                cleanupError
+                )
               );
+            } finally {
+              try {
+                await client?.disconnect();
+              } catch {
+              }
+              active--;
+              runNext();
             }
-          }
-          controller.close();
+          })();
+        };
+        for (let i = 0; i < Math.min(maxConcurrency, testsInput.length); i++) {
+          runNext();
         }
       }
     });
@@ -1056,55 +1448,17 @@ chat.post("/", async (c) => {
         Connection: "keep-alive"
       }
     });
-  } catch (error) {
-    console.error("[mcp/chat] Error in chat API:", error);
-    if (client) {
-      try {
-        await client.disconnect();
-      } catch (cleanupError) {
-        console.warn("Error cleaning up MCP client after error:", cleanupError);
-      }
-    }
+  } catch (err) {
     return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
+      { success: false, error: err?.message || "Unknown error" },
       500
     );
   }
 });
-var getLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
-  if (!modelDefinition || !modelDefinition.id || !modelDefinition.provider) {
-    throw new Error(
-      `Invalid model definition: ${JSON.stringify(modelDefinition)}`
-    );
-  }
-  switch (modelDefinition.provider) {
-    case "anthropic":
-      return createAnthropic({ apiKey })(modelDefinition.id);
-    case "openai":
-      return createOpenAI({ apiKey })(modelDefinition.id);
-    case "ollama":
-      const baseUrl = ollamaBaseUrl || "http://localhost:11434";
-      return createOllama({
-        // The provider expects the root Ollama URL; it internally targets the /api endpoints
-        baseURL: `${baseUrl}`
-      })(modelDefinition.id, {
-        simulateStreaming: true
-        // Enable streaming for Ollama models
-      });
-    default:
-      throw new Error(
-        `Unsupported provider: ${modelDefinition.provider} for model: ${modelDefinition.id}`
-      );
-  }
-};
-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");
@@ -1150,7 +1504,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",
@@ -1160,12 +1514,311 @@ 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 normalizeServerId(serverId) {
+  return serverId.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+}
+var MCPJamClientManager = class {
+  mcpClients = /* @__PURE__ */ new Map();
+  statuses = /* @__PURE__ */ new Map();
+  configs = /* @__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;
+  async connectToServer(serverId, serverConfig) {
+    const id = normalizeServerId(serverId);
+    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) {
+        const normalizedName = normalizeServerConfigName(serverId);
+        client.elicitation.onRequest(
+          normalizedName,
+          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;
+    }
+  }
+  async disconnectFromServer(serverId) {
+    const id = normalizeServerId(serverId);
+    const client = this.mcpClients.get(id);
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+    }
+    this.mcpClients.delete(id);
+    this.statuses.set(id, "disconnected");
+    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 = normalizeServerId(serverId);
+    return this.statuses.get(id) || "disconnected";
+  }
+  getConnectedServers() {
+    const servers2 = {};
+    for (const [serverId, status] of this.statuses.entries()) {
+      servers2[serverId] = {
+        status,
+        config: this.configs.get(serverId)
+      };
+    }
+    return servers2;
+  }
+  async discoverAllResources() {
+    const serverIds = Array.from(this.mcpClients.keys());
+    await Promise.all(serverIds.map((id) => this.discoverServerResources(id)));
+  }
+  async discoverServerResources(serverId) {
+    const id = normalizeServerId(serverId);
+    const client = this.mcpClients.get(id);
+    if (!client) return;
+    const tools2 = await client.getTools();
+    for (const [name, tool] of Object.entries(tools2)) {
+      this.toolRegistry.set(`${id}:${name}`, {
+        name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        serverId: id
+      });
+    }
+    try {
+      const res = await client.resources.list();
+      for (const [group, list] of Object.entries(res)) {
+        for (const r of list) {
+          this.resourceRegistry.set(`${id}:${r.uri}`, {
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType,
+            serverId: id
+          });
+        }
+      }
+    } catch {
+    }
+    try {
+      const prompts2 = await client.prompts.list();
+      for (const [group, list] of Object.entries(prompts2)) {
+        for (const p of list) {
+          this.promptRegistry.set(`${id}:${p.name}`, {
+            name: p.name,
+            description: p.description,
+            arguments: p.arguments,
+            serverId: id
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  getAvailableTools() {
+    return Array.from(this.toolRegistry.values());
+  }
+  async getToolsetsForServer(serverId) {
+    const id = normalizeServerId(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 = normalizeServerId(serverId);
+    return Array.from(this.resourceRegistry.values()).filter(
+      (r) => r.serverId === id
+    );
+  }
+  getAvailablePrompts() {
+    return Array.from(this.promptRegistry.values());
+  }
+  getPromptsForServer(serverId) {
+    const id = normalizeServerId(serverId);
+    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);
+      serverId = normalizeServerId(sid);
+      name = n;
+    } else {
+      for (const [key, tool2] of this.toolRegistry.entries()) {
+        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 result = await tool.execute({ context: parameters || {} });
+    return { result };
+  }
+  async getResource(resourceUri, serverId) {
+    let uri = resourceUri;
+    const client = this.mcpClients.get(serverId);
+    if (!client) throw new Error("No MCP client available");
+    const content = await client.resources.read(serverId, uri);
+    return { contents: content?.contents || [] };
+  }
+  async getPrompt(promptName, serverId, args) {
+    const client = this.mcpClients.get(serverId);
+    if (!client) throw new Error("No MCP client available");
+    const content = await client.prompts.get({
+      serverName: serverId,
+      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");
@@ -1199,7 +1852,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 = [
@@ -1231,7 +1889,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) {