@mcpjam/inspector 0.9.4 → 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(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,61 +502,215 @@ 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) {
+    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(
-        { success: false, error: validation.error.message },
-        validation.error.status
+        {
+          success: false,
+          error: "Prompt name is required"
+        },
+        400
       );
     }
-    if (!name) {
-      return c.json(
-        {
-          success: false,
-          error: "Prompt name is required"
-        },
-        400
-      );
+    const mcpJamClientManager2 = c.mcpJamClientManager;
+    const content = await mcpJamClientManager2.getPrompt(
+      name,
+      serverId,
+      args || {}
+    );
+    return c.json({ content });
+  } catch (error) {
+    console.error("Error getting prompt:", error);
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var prompts_default = prompts;
+
+// routes/mcp/chat.ts
+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
     }
-    const client = createMCPClient(
-      validation.config,
-      `prompts-get-${Date.now()}`
-    );
-    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;
+  };
+};
+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;
+      }
     }
-  } catch (error) {
-    console.error("Error getting prompt:", error);
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-var prompts_default = prompts;
+    return fixedTools;
+  };
+  return originalMCPClient;
+}
+function normalizeServerConfigName(serverName) {
+  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+}
 
 // routes/mcp/chat.ts
-import { Hono as Hono5 } 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 +734,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(
@@ -862,6 +923,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);
   }
@@ -1029,7 +1113,6 @@ chat.post("/", async (c) => {
     }
     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.",
@@ -1046,17 +1129,22 @@ chat.post("/", async (c) => {
       toolsetServers: Object.keys(toolsets),
       messageCount: formattedMessages.length
     });
-    const encoder = new TextEncoder2();
+    const encoder = new TextEncoder3();
     const readableStream = new ReadableStream({
       async start(controller) {
         const streamingContext = {
           controller,
           encoder,
           toolCallId: 0,
-          lastEmittedToolCallId: null
+          lastEmittedToolCallId: null,
+          stepIndex: 0
         };
+        const flattenedTools = {};
+        Object.values(toolsets).forEach((serverTools) => {
+          Object.assign(flattenedTools, serverTools);
+        });
         const streamingWrappedTools = wrapToolsWithStreaming(
-          tools2,
+          flattenedTools,
           streamingContext
         );
         const streamingAgent = new Agent({
@@ -1122,9 +1210,255 @@ chat.post("/", async (c) => {
 });
 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";
+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}`);
+      }
+    };
+    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) {
+        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;
+          }
+          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
+                        })}
+
+`
+                      )
+                    );
+                  }
+                }
+              );
+              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();
+        }
+      }
+    });
+    return new Response(readableStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (err) {
+    return c.json(
+      { success: false, error: err?.message || "Unknown error" },
+      500
+    );
+  }
+});
+
 // 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 +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",
@@ -1180,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");
@@ -1219,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 = [
@@ -1251,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) {