@mcpjam/inspector 0.9.9 → 0.9.11

package/dist/server/index.js

@@ -0,0 +1,1994 @@
+// index.ts
+import { serve } from "@hono/node-server";
+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";
+
+// routes/mcp/index.ts
+import { Hono as Hono9 } from "hono";
+
+// routes/mcp/connect.ts
+import { Hono } from "hono";
+var connect = new Hono();
+connect.post("/", async (c) => {
+  try {
+    const { serverConfig, serverId } = await c.req.json();
+    if (!serverConfig) {
+      return c.json(
+        {
+          success: false,
+          error: "serverConfig is required"
+        },
+        400
+      );
+    }
+    if (!serverId) {
+      return c.json(
+        {
+          success: false,
+          error: "serverId is required"
+        },
+        400
+      );
+    }
+    const mcpClientManager = c.mcpJamClientManager;
+    try {
+      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(
+        {
+          success: false,
+          error: `MCP configuration is invalid. Please double check your server configuration: ${JSON.stringify(serverConfig)}`,
+          details: error instanceof Error ? error.message : "Unknown error"
+        },
+        500
+      );
+    }
+  } catch (error) {
+    return c.json(
+      {
+        success: false,
+        error: "Failed to parse request body",
+        details: error instanceof Error ? error.message : "Unknown error"
+      },
+      400
+    );
+  }
+});
+var connect_default = connect;
+
+// 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 as TextEncoder2 } from "util";
+var tools = new Hono3();
+var pendingElicitations = /* @__PURE__ */ new Map();
+tools.post("/", async (c) => {
+  let action;
+  let toolName;
+  try {
+    const requestData = await c.req.json();
+    action = requestData.action;
+    toolName = requestData.toolName;
+    const { serverConfig, parameters, requestId, response } = requestData;
+    if (!action || !["list", "execute", "respond"].includes(action)) {
+      return c.json(
+        {
+          success: false,
+          error: "Action must be 'list', 'execute', or 'respond'"
+        },
+        400
+      );
+    }
+    if (action === "respond") {
+      if (!requestId) {
+        return c.json(
+          {
+            success: false,
+            error: "requestId is required for respond action"
+          },
+          400
+        );
+      }
+      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,
+            error: "No pending elicitation found for this requestId"
+          },
+          404
+        );
+      }
+      return c.json({ success: true });
+    }
+    const encoder = new TextEncoder2();
+    const readableStream = new ReadableStream({
+      async start(controller) {
+        try {
+          if (!serverConfig) {
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({ type: "tool_error", error: "serverConfig is required" })}
+
+`
+              )
+            );
+            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: "elicitation_request",
+                  requestId: requestId2,
+                  message,
+                  schema,
+                  toolName: toolName || "unknown",
+                  timestamp: /* @__PURE__ */ new Date()
+                })}
+
+`
+              )
+            );
+            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: "tools_list", tools: toolsWithJsonSchema })}
+
+`
+                )
+              );
+              controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+              controller.close();
+              return;
+            } catch (err) {
+              controller.enqueue(
+                encoder.encode(
+                  `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
+
+`
+                )
+              );
+              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 name is required for execution" })}
+
+`
+                )
+              );
+              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..." })}
+
+`
+              )
+            );
+            const exec = await mcpJamClientManager2.executeToolDirect(
+              toolName,
+              parameters || {}
+            );
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({ type: "tool_result", toolName, result: exec.result })}
+
+`
+              )
+            );
+            controller.enqueue(
+              encoder.encode(
+                `data: ${JSON.stringify({ type: "elicitation_complete", toolName })}
+
+`
+              )
+            );
+            controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+            controller.close();
+            return;
+          }
+        } catch (err) {
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({ type: "tool_error", error: err instanceof Error ? err.message : String(err) })}
+
+`
+            )
+          );
+          controller.enqueue(encoder.encode(`data: [DONE]
+
+`));
+          controller.close();
+        } finally {
+          const mcpJamClientManager2 = c.mcpJamClientManager;
+          if (mcpJamClientManager2) {
+            mcpJamClientManager2.clearElicitationCallback();
+          }
+        }
+      }
+    });
+    return new Response(readableStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    return c.json(
+      {
+        success: false,
+        error: errorMsg
+      },
+      500
+    );
+  }
+});
+var tools_default = tools;
+
+// routes/mcp/resources.ts
+import { Hono as Hono4 } from "hono";
+var resources = new Hono4();
+resources.post("/list", async (c) => {
+  try {
+    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(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+resources.post("/read", async (c) => {
+  try {
+    const { serverId, uri } = await c.req.json();
+    if (!serverId) {
+      return c.json({ success: false, error: "serverId is required" }, 400);
+    }
+    if (!uri) {
+      return c.json(
+        {
+          success: false,
+          error: "Resource URI is required"
+        },
+        400
+      );
+    }
+    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(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var resources_default = resources;
+
+// routes/mcp/prompts.ts
+import { Hono as Hono5 } from "hono";
+var prompts = new Hono5();
+prompts.post("/list", async (c) => {
+  try {
+    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(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+prompts.post("/get", async (c) => {
+  try {
+    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: "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";
+import { Agent } from "@mastra/core/agent";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOllama } from "ollama-ai-provider";
+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;
+    case "google":
+      return 0.9;
+    // Google's recommended default
+    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);
+};
+try {
+  process.setMaxListeners?.(50);
+} 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 "google":
+      return createGoogleGenerativeAI({ apiKey })(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 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, temperature) => {
+  try {
+    const result = await agent.generate(messages, {
+      temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature
+    });
+    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 createStreamingResponse = async (agent, messages, toolsets, streamingContext, provider, temperature) => {
+  const stream = await agent.stream(messages, {
+    maxSteps: MAX_AGENT_STEPS,
+    temperature: temperature == null || void 0 ? getDefaultTemperatureByProvider(provider) : temperature,
+    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,
+      temperature
+    );
+  }
+  streamingContext.controller.enqueue(
+    streamingContext.encoder.encode(
+      `data: ${JSON.stringify({
+        type: "elicitation_complete"
+      })}
+
+`
+    )
+  );
+  streamingContext.controller.enqueue(
+    streamingContext.encoder.encode(`data: [DONE]
+
+`)
+  );
+};
+chat.post("/", async (c) => {
+  const mcpClientManager = c.mcpJamClientManager;
+  try {
+    const requestData = await c.req.json();
+    const {
+      serverConfigs,
+      model,
+      provider,
+      apiKey,
+      systemPrompt,
+      temperature,
+      messages,
+      ollamaBaseUrl,
+      action,
+      requestId,
+      response
+    } = requestData;
+    if (action === "elicitation_response") {
+      if (!requestId) {
+        return c.json(
+          {
+            success: false,
+            error: "requestId is required for elicitation_response action"
+          },
+          400
+        );
+      }
+      const pending = pendingElicitations2.get(requestId);
+      if (!pending) {
+        return c.json(
+          {
+            success: false,
+            error: "No pending elicitation found for this requestId"
+          },
+          404
+        );
+      }
+      pending.resolve(response);
+      pendingElicitations2.delete(requestId);
+      return c.json({ success: true });
+    }
+    if (!model?.id || !apiKey || !messages) {
+      return c.json(
+        {
+          success: false,
+          error: "model (with id), apiKey, and messages are required"
+        },
+        400
+      );
+    }
+    if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+      return c.json(
+        {
+          success: false,
+          error: "No server configs provided"
+        },
+        400
+      );
+    }
+    const serverErrors = {};
+    const connectedServers = [];
+    for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
+      try {
+        await mcpClientManager.connectToServer(serverName, serverConfig);
+        connectedServers.push(serverName);
+        dbg("Connected to server", { serverName });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        serverErrors[serverName] = errorMessage;
+        dbg("Failed to connect to server", { serverName, error: errorMessage });
+      }
+    }
+    if (connectedServers.length === 0) {
+      return c.json(
+        {
+          success: false,
+          error: "Failed to connect to any servers",
+          details: serverErrors
+        },
+        400
+      );
+    }
+    if (Object.keys(serverErrors).length > 0) {
+      dbg("Some servers failed to connect", {
+        connectedServers,
+        failedServers: Object.keys(serverErrors),
+        errors: serverErrors
+      });
+    }
+    const llmModel = createLlmModel(model, apiKey, ollamaBaseUrl);
+    const agent = new Agent({
+      name: "MCP Chat Agent",
+      instructions: systemPrompt || "You are a helpful assistant with access to MCP tools.",
+      model: llmModel,
+      tools: void 0
+      // Start without tools, add them in streaming context
+    });
+    const formattedMessages = messages.map((msg) => ({
+      role: msg.role,
+      content: msg.content
+    }));
+    const allTools = mcpClientManager.getAvailableTools();
+    const toolsByServer = {};
+    for (const tool of allTools) {
+      if (!toolsByServer[tool.serverId]) {
+        toolsByServer[tool.serverId] = {};
+      }
+      toolsByServer[tool.serverId][tool.name] = {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        execute: async (params) => {
+          return await mcpClientManager.executeToolDirect(
+            `${tool.serverId}:${tool.name}`,
+            params
+          );
+        }
+      };
+    }
+    dbg("Streaming start", {
+      connectedServers,
+      toolCount: allTools.length,
+      messageCount: formattedMessages.length
+    });
+    const encoder = new TextEncoder3();
+    const readableStream = new ReadableStream({
+      async start(controller) {
+        const streamingContext = {
+          controller,
+          encoder,
+          toolCallId: 0,
+          lastEmittedToolCallId: null,
+          stepIndex: 0
+        };
+        const flattenedTools = {};
+        Object.values(toolsByServer).forEach((serverTools) => {
+          Object.assign(flattenedTools, serverTools);
+        });
+        const streamingWrappedTools = wrapToolsWithStreaming(
+          flattenedTools,
+          streamingContext
+        );
+        const streamingAgent = new Agent({
+          name: agent.name,
+          instructions: agent.instructions,
+          model: agent.model,
+          tools: Object.keys(streamingWrappedTools).length > 0 ? streamingWrappedTools : void 0
+        });
+        mcpClientManager.setElicitationCallback(async (request) => {
+          const elicitationRequest = {
+            message: request.message,
+            requestedSchema: request.schema
+          };
+          if (streamingContext.controller && streamingContext.encoder) {
+            streamingContext.controller.enqueue(
+              streamingContext.encoder.encode(
+                `data: ${JSON.stringify({
+                  type: "elicitation_request",
+                  requestId: request.requestId,
+                  message: elicitationRequest.message,
+                  schema: elicitationRequest.requestedSchema,
+                  timestamp: /* @__PURE__ */ new Date()
+                })}
+
+`
+              )
+            );
+          }
+          return new Promise((resolve, reject) => {
+            pendingElicitations2.set(request.requestId, { resolve, reject });
+            setTimeout(() => {
+              if (pendingElicitations2.has(request.requestId)) {
+                pendingElicitations2.delete(request.requestId);
+                reject(new Error("Elicitation timeout"));
+              }
+            }, ELICITATION_TIMEOUT);
+          });
+        });
+        try {
+          await createStreamingResponse(
+            streamingAgent,
+            formattedMessages,
+            toolsByServer,
+            streamingContext,
+            provider,
+            temperature
+          );
+        } catch (error) {
+          controller.enqueue(
+            encoder.encode(
+              `data: ${JSON.stringify({
+                type: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              })}
+
+`
+            )
+          );
+        } finally {
+          mcpClientManager.clearElicitationCallback();
+          controller.close();
+        }
+      }
+    });
+    return new Response(readableStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  } catch (error) {
+    console.error("[mcp/chat] Error in chat API:", error);
+    mcpClientManager.clearElicitationCallback();
+    return c.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      500
+    );
+  }
+});
+var chat_default = chat;
+
+// routes/mcp/tests.ts
+import { Hono as Hono7 } from "hono";
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { createOllama as createOllama2 } from "ollama-ai-provider";
+import { Agent as Agent2 } from "@mastra/core/agent";
+
+// utils/mcp-utils.ts
+import { MCPClient } from "@mastra/mcp";
+function validateServerConfig(serverConfig) {
+  if (!serverConfig) {
+    return {
+      success: false,
+      error: {
+        message: "Server configuration is required",
+        status: 400
+      }
+    };
+  }
+  const config = { ...serverConfig };
+  if (config.url) {
+    try {
+      if (typeof config.url === "string") {
+        const parsed = new URL(config.url);
+        parsed.search = "";
+        parsed.hash = "";
+        config.url = parsed;
+      } else if (typeof config.url === "object" && !config.url.href) {
+        return {
+          success: false,
+          error: {
+            message: "Invalid URL configuration",
+            status: 400
+          }
+        };
+      }
+      if (config.oauth?.access_token) {
+        const authHeaders = {
+          Authorization: `Bearer ${config.oauth.access_token}`,
+          ...config.requestInit?.headers || {}
+        };
+        config.requestInit = {
+          ...config.requestInit,
+          headers: authHeaders
+        };
+        config.eventSourceInit = {
+          fetch(input, init) {
+            const headers = new Headers(init?.headers || {});
+            headers.set(
+              "Authorization",
+              `Bearer ${config.oauth.access_token}`
+            );
+            if (config.requestInit?.headers) {
+              const requestHeaders = new Headers(config.requestInit.headers);
+              requestHeaders.forEach((value, key) => {
+                if (key.toLowerCase() !== "authorization") {
+                  headers.set(key, value);
+                }
+              });
+            }
+            return fetch(input, {
+              ...init,
+              headers
+            });
+          }
+        };
+      } else if (config.requestInit?.headers) {
+        config.eventSourceInit = {
+          fetch(input, init) {
+            const headers = new Headers(init?.headers || {});
+            const requestHeaders = new Headers(config.requestInit.headers);
+            requestHeaders.forEach((value, key) => {
+              headers.set(key, value);
+            });
+            return fetch(input, {
+              ...init,
+              headers
+            });
+          }
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          message: `Invalid URL format: ${error}`,
+          status: 400
+        }
+      };
+    }
+  }
+  return {
+    success: true,
+    config
+  };
+}
+function generateUniqueServerID(serverName) {
+  const normalizedBase = normalizeServerConfigName(serverName);
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${normalizedBase}_${timestamp}_${random}`;
+}
+var validateMultipleServerConfigs = (serverConfigs) => {
+  if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
+    return {
+      success: false,
+      error: {
+        message: "At least one server configuration is required",
+        status: 400
+      }
+    };
+  }
+  const validConfigs = {};
+  const serverNameMapping = {};
+  const errors = {};
+  let hasErrors = false;
+  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
+    const validationResult = validateServerConfig(serverConfig);
+    if (validationResult.success && validationResult.config) {
+      const serverID = generateUniqueServerID(serverName);
+      validConfigs[serverID] = validationResult.config;
+      serverNameMapping[serverID] = serverName;
+    } else {
+      hasErrors = true;
+      let errorMessage = "Configuration validation failed";
+      if (validationResult.error) {
+        errorMessage = validationResult.error.message;
+      }
+      errors[serverName] = errorMessage;
+    }
+  }
+  if (!hasErrors) {
+    return {
+      success: true,
+      validConfigs,
+      serverNameMapping
+    };
+  }
+  if (Object.keys(validConfigs).length > 0) {
+    return {
+      success: false,
+      validConfigs,
+      serverNameMapping,
+      errors
+    };
+  }
+  return {
+    success: false,
+    errors,
+    error: {
+      message: "All server configurations failed validation",
+      status: 400
+    }
+  };
+};
+function createMCPClientWithMultipleConnections(serverConfigs) {
+  const originalMCPClient = new MCPClient({
+    id: `chat-${Date.now()}`,
+    servers: serverConfigs
+  });
+  const originalGetTools = originalMCPClient.getTools.bind(originalMCPClient);
+  originalMCPClient.getTools = async () => {
+    const tools2 = await originalGetTools();
+    const fixedTools = {};
+    for (const [toolName, toolConfig] of Object.entries(tools2)) {
+      const parts = toolName.split("_");
+      if (parts.length >= 3 && parts[0] === parts[1]) {
+        const fixedName = parts.slice(1).join("_");
+        fixedTools[fixedName] = toolConfig;
+      } else {
+        fixedTools[toolName] = toolConfig;
+      }
+    }
+    return fixedTools;
+  };
+  return originalMCPClient;
+}
+function normalizeServerConfigName(serverName) {
+  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+}
+
+// routes/mcp/tests.ts
+var tests = new Hono7();
+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 Hono8 } from "hono";
+var oauth = new Hono8();
+oauth.get("/metadata", async (c) => {
+  try {
+    const url = c.req.query("url");
+    if (!url) {
+      return c.json({ error: "Missing url parameter" }, 400);
+    }
+    let metadataUrl;
+    try {
+      metadataUrl = new URL(url);
+      if (metadataUrl.protocol !== "https:") {
+        return c.json({ error: "Only HTTPS URLs are allowed" }, 400);
+      }
+    } catch (error) {
+      return c.json({ error: "Invalid URL format" }, 400);
+    }
+    const response = await fetch(metadataUrl.toString(), {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "MCP-Inspector/1.0"
+      }
+    });
+    if (!response.ok) {
+      return c.json(
+        {
+          error: `Failed to fetch OAuth metadata: ${response.status} ${response.statusText}`
+        },
+        response.status
+      );
+    }
+    const metadata = await response.json();
+    return c.json(metadata);
+  } catch (error) {
+    console.error("OAuth metadata proxy error:", error);
+    return c.json(
+      {
+        error: error instanceof Error ? error.message : "Unknown error occurred"
+      },
+      500
+    );
+  }
+});
+var oauth_default = oauth;
+
+// routes/mcp/index.ts
+var mcp = new Hono9();
+mcp.get("/health", (c) => {
+  return c.json({
+    service: "MCP API",
+    status: "ready",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+mcp.route("/chat", chat_default);
+mcp.route("/connect", connect_default);
+mcp.route("/servers", servers_default);
+mcp.route("/tools", tools_default);
+mcp.route("/tests", tests_default);
+mcp.route("/resources", resources_default);
+mcp.route("/prompts", prompts_default);
+mcp.route("/oauth", oauth_default);
+var mcp_default = mcp;
+
+// services/mcpjam-client-manager.ts
+import { MCPClient as MCPClient2 } from "@mastra/mcp";
+function generateUniqueServerId(serverId) {
+  const normalizedBase = serverId.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${normalizedBase}_${timestamp}_${random}`;
+}
+var MCPJamClientManager = class {
+  mcpClients = /* @__PURE__ */ new Map();
+  statuses = /* @__PURE__ */ new Map();
+  configs = /* @__PURE__ */ new Map();
+  // Map original server names to unique IDs
+  serverIdMapping = /* @__PURE__ */ new Map();
+  // Track in-flight connections to avoid duplicate concurrent connects
+  pendingConnections = /* @__PURE__ */ new Map();
+  toolRegistry = /* @__PURE__ */ new Map();
+  resourceRegistry = /* @__PURE__ */ new Map();
+  promptRegistry = /* @__PURE__ */ new Map();
+  // Store for pending elicitation requests with Promise resolvers
+  pendingElicitations = /* @__PURE__ */ new Map();
+  // Optional callback for handling elicitation requests
+  elicitationCallback;
+  // Helper method to get unique ID for a server name
+  getServerUniqueId(serverName) {
+    return this.serverIdMapping.get(serverName);
+  }
+  // Public method to get server ID for external use (like frontend)
+  getServerIdForName(serverName) {
+    return this.serverIdMapping.get(serverName);
+  }
+  // Public method to get original server name from a unique server ID
+  getOriginalNameForId(uniqueServerId) {
+    for (const [originalName, uid] of this.serverIdMapping.entries()) {
+      if (uid === uniqueServerId) return originalName;
+    }
+    return void 0;
+  }
+  // Convenience: map an array of unique IDs to their original names (fallback to ID if not found)
+  mapIdsToOriginalNames(uniqueIds) {
+    return uniqueIds.map((id) => this.getOriginalNameForId(id) || id);
+  }
+  async connectToServer(serverId, serverConfig) {
+    const pending = this.pendingConnections.get(serverId);
+    if (pending) {
+      await pending;
+      return;
+    }
+    const connectPromise = (async () => {
+      let id = this.serverIdMapping.get(serverId);
+      if (!id) {
+        id = generateUniqueServerId(serverId);
+        this.serverIdMapping.set(serverId, id);
+      }
+      if (this.mcpClients.has(id)) return;
+      const validation = validateServerConfig(serverConfig);
+      if (!validation.success) {
+        this.statuses.set(id, "error");
+        throw new Error(validation.error.message);
+      }
+      this.configs.set(id, validation.config);
+      this.statuses.set(id, "connecting");
+      const client = new MCPClient2({
+        id: `mcpjam-${id}`,
+        servers: { [id]: validation.config }
+      });
+      try {
+        await client.getTools();
+        this.mcpClients.set(id, client);
+        this.statuses.set(id, "connected");
+        if (client.elicitation?.onRequest) {
+          client.elicitation.onRequest(
+            id,
+            async (elicitationRequest) => {
+              return await this.handleElicitationRequest(elicitationRequest);
+            }
+          );
+        }
+        await this.discoverServerResources(id);
+      } catch (err) {
+        this.statuses.set(id, "error");
+        try {
+          await client.disconnect();
+        } catch {
+        }
+        this.mcpClients.delete(id);
+        throw err;
+      }
+    })().finally(() => {
+      this.pendingConnections.delete(serverId);
+    });
+    this.pendingConnections.set(serverId, connectPromise);
+    await connectPromise;
+  }
+  async disconnectFromServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return;
+    const client = this.mcpClients.get(id);
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+    }
+    this.mcpClients.delete(id);
+    this.statuses.set(id, "disconnected");
+    this.serverIdMapping.delete(serverId);
+    for (const key of Array.from(this.toolRegistry.keys())) {
+      const item = this.toolRegistry.get(key);
+      if (item.serverId === id) this.toolRegistry.delete(key);
+    }
+    for (const key of Array.from(this.resourceRegistry.keys())) {
+      const item = this.resourceRegistry.get(key);
+      if (item.serverId === id) this.resourceRegistry.delete(key);
+    }
+    for (const key of Array.from(this.promptRegistry.keys())) {
+      const item = this.promptRegistry.get(key);
+      if (item.serverId === id) this.promptRegistry.delete(key);
+    }
+  }
+  getConnectionStatus(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    return id ? this.statuses.get(id) || "disconnected" : "disconnected";
+  }
+  getConnectedServers() {
+    const servers2 = {};
+    for (const [originalName, uniqueId] of this.serverIdMapping.entries()) {
+      servers2[originalName] = {
+        status: this.statuses.get(uniqueId) || "disconnected",
+        config: this.configs.get(uniqueId)
+      };
+    }
+    return servers2;
+  }
+  async discoverAllResources() {
+    const serverIds = Array.from(this.mcpClients.keys());
+    await Promise.all(serverIds.map((id) => this.discoverServerResources(id)));
+  }
+  async discoverServerResources(serverId) {
+    const client = this.mcpClients.get(serverId);
+    if (!client) return;
+    const toolsets = await client.getToolsets();
+    const flattenedTools = {};
+    Object.values(toolsets).forEach((serverTools) => {
+      Object.assign(flattenedTools, serverTools);
+    });
+    for (const [name, tool] of Object.entries(flattenedTools)) {
+      this.toolRegistry.set(`${serverId}:${name}`, {
+        name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        serverId
+      });
+    }
+    try {
+      const res = await client.resources.list();
+      for (const [, list] of Object.entries(res)) {
+        for (const r of list) {
+          this.resourceRegistry.set(`${serverId}:${r.uri}`, {
+            uri: r.uri,
+            name: r.name,
+            description: r.description,
+            mimeType: r.mimeType,
+            serverId
+          });
+        }
+      }
+    } catch {
+    }
+    try {
+      const prompts2 = await client.prompts.list();
+      for (const [, list] of Object.entries(prompts2)) {
+        for (const p of list) {
+          this.promptRegistry.set(`${serverId}:${p.name}`, {
+            name: p.name,
+            description: p.description,
+            arguments: p.arguments,
+            serverId
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  getAvailableTools() {
+    return Array.from(this.toolRegistry.values());
+  }
+  async getToolsetsForServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const client = this.mcpClients.get(id);
+    if (!client) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const toolsets = await client.getToolsets();
+    const flattenedTools = {};
+    Object.values(toolsets).forEach((serverTools) => {
+      Object.assign(flattenedTools, serverTools);
+    });
+    return flattenedTools;
+  }
+  getAvailableResources() {
+    return Array.from(this.resourceRegistry.values());
+  }
+  getResourcesForServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return [];
+    return Array.from(this.resourceRegistry.values()).filter(
+      (r) => r.serverId === id
+    );
+  }
+  getAvailablePrompts() {
+    return Array.from(this.promptRegistry.values());
+  }
+  getPromptsForServer(serverId) {
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return [];
+    return Array.from(this.promptRegistry.values()).filter(
+      (p) => p.serverId === id
+    );
+  }
+  async executeToolDirect(toolName, parameters = {}) {
+    let serverId = "";
+    let name = toolName;
+    if (toolName.includes(":")) {
+      const [sid, n] = toolName.split(":", 2);
+      const mappedId = this.getServerUniqueId(sid);
+      serverId = mappedId || (this.mcpClients.has(sid) ? sid : "");
+      name = n;
+    } else {
+      for (const tool2 of this.toolRegistry.values()) {
+        if (tool2.name === toolName) {
+          serverId = tool2.serverId;
+          name = toolName;
+          break;
+        }
+      }
+    }
+    if (!serverId) {
+      for (const [clientServerId, client2] of this.mcpClients.entries()) {
+        try {
+          const toolsets2 = await client2.getToolsets();
+          const flattenedTools2 = {};
+          Object.values(toolsets2).forEach((serverTools) => {
+            Object.assign(flattenedTools2, serverTools);
+          });
+          if (flattenedTools2[toolName]) {
+            serverId = clientServerId;
+            name = toolName;
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!serverId) {
+      throw new Error(`Tool not found in any connected server: ${toolName}`);
+    }
+    const client = this.mcpClients.get(serverId);
+    if (!client)
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    const toolsets = await client.getToolsets();
+    const flattenedTools = {};
+    Object.values(toolsets).forEach((serverTools) => {
+      Object.assign(flattenedTools, serverTools);
+    });
+    const tool = flattenedTools[name];
+    if (!tool)
+      throw new Error(`Tool '${name}' not found in server '${serverId}'`);
+    const schema = tool.inputSchema;
+    const hasContextProperty = schema && typeof schema === "object" && schema.properties && Object.prototype.hasOwnProperty.call(
+      schema.properties,
+      "context"
+    );
+    const requiresContext = hasContextProperty || schema && Array.isArray(schema.required) && schema.required.includes("context");
+    const contextWrapped = { context: parameters || {} };
+    const direct = parameters || {};
+    const attempts = requiresContext ? [contextWrapped, direct] : [direct, contextWrapped];
+    let lastError = void 0;
+    for (const args of attempts) {
+      try {
+        const result = await tool.execute(args);
+        if (result && result.isError) {
+          const errorText = result.content && result.content[0] && result.content[0].text ? result.content[0].text : "Unknown error";
+          throw new Error(errorText);
+        }
+        return { result };
+      } catch (err) {
+        lastError = err;
+      }
+    }
+    throw lastError;
+  }
+  async getResource(resourceUri, serverId) {
+    let uri = resourceUri;
+    const mappedId = this.getServerUniqueId(serverId);
+    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
+    if (!resolvedServerId) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const client = this.mcpClients.get(resolvedServerId);
+    if (!client) throw new Error("No MCP client available");
+    const content = await client.resources.read(resolvedServerId, uri);
+    return { contents: content?.contents || [] };
+  }
+  async getPrompt(promptName, serverId, args) {
+    const mappedId = this.getServerUniqueId(serverId);
+    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
+    if (!resolvedServerId) {
+      throw new Error(`No MCP client available for server: ${serverId}`);
+    }
+    const client = this.mcpClients.get(resolvedServerId);
+    if (!client) throw new Error("No MCP client available");
+    const content = await client.prompts.get({
+      serverName: resolvedServerId,
+      name: promptName,
+      args: args || {}
+    });
+    return { content };
+  }
+  /**
+   * Handles elicitation requests from MCP servers during direct tool execution
+   */
+  async handleElicitationRequest(elicitationRequest) {
+    const requestId = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    return new Promise((resolve, reject) => {
+      this.pendingElicitations.set(requestId, { resolve, reject });
+      if (this.elicitationCallback) {
+        this.elicitationCallback({
+          requestId,
+          message: elicitationRequest.message,
+          schema: elicitationRequest.requestedSchema
+        }).then(resolve).catch(reject);
+      } else {
+        const error = new Error("ELICITATION_REQUIRED");
+        error.elicitationRequest = {
+          requestId,
+          message: elicitationRequest.message,
+          schema: elicitationRequest.requestedSchema
+        };
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Responds to a pending elicitation request
+   */
+  respondToElicitation(requestId, response) {
+    const pending = this.pendingElicitations.get(requestId);
+    if (!pending) {
+      return false;
+    }
+    pending.resolve(response);
+    this.pendingElicitations.delete(requestId);
+    return true;
+  }
+  /**
+   * Gets the pending elicitations map for external access
+   */
+  getPendingElicitations() {
+    return this.pendingElicitations;
+  }
+  /**
+   * Sets a callback to handle elicitation requests
+   */
+  setElicitationCallback(callback) {
+    this.elicitationCallback = callback;
+  }
+  /**
+   * Clears the elicitation callback
+   */
+  clearElicitationCallback() {
+    this.elicitationCallback = void 0;
+  }
+};
+
+// index.ts
+function logBox(content, title) {
+  const lines = content.split("\n");
+  const maxLength = Math.max(...lines.map((line) => line.length));
+  const width = maxLength + 4;
+  console.log("\u250C" + "\u2500".repeat(width) + "\u2510");
+  if (title) {
+    const titlePadding = Math.floor((width - title.length - 2) / 2);
+    console.log(
+      "\u2502" + " ".repeat(titlePadding) + title + " ".repeat(width - title.length - titlePadding) + "\u2502"
+    );
+    console.log("\u251C" + "\u2500".repeat(width) + "\u2524");
+  }
+  lines.forEach((line) => {
+    const padding = width - line.length - 2;
+    console.log("\u2502 " + line + " ".repeat(padding) + " \u2502");
+  });
+  console.log("\u2514" + "\u2500".repeat(width) + "\u2518");
+}
+function getMCPConfigFromEnv() {
+  const command = process.env.MCP_SERVER_COMMAND;
+  if (!command) {
+    return null;
+  }
+  const argsString = process.env.MCP_SERVER_ARGS;
+  const args = argsString ? JSON.parse(argsString) : [];
+  return {
+    command,
+    args,
+    name: "CLI Server"
+    // Default name for CLI-provided servers
+  };
+}
+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 = [
+  `http://localhost:${serverPort}`,
+  "http://localhost:3000",
+  // Keep for development
+  "http://localhost:3001"
+  // Keep for development
+];
+app.use(
+  "*",
+  cors({
+    origin: corsOrigins,
+    credentials: true
+  })
+);
+app.route("/api/mcp", mcp_default);
+app.get("/health", (c) => {
+  return c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+});
+app.get("/api/mcp-cli-config", (c) => {
+  const mcpConfig = getMCPConfigFromEnv();
+  return c.json({ config: mcpConfig });
+});
+if (process.env.NODE_ENV === "production") {
+  app.use("/*", serveStatic({ root: "./dist/client" }));
+  app.get("*", async (c) => {
+    const path = c.req.path;
+    if (path.startsWith("/api/")) {
+      return c.notFound();
+    }
+    const indexPath = join(process.cwd(), "dist", "client", "index.html");
+    let htmlContent = readFileSync(indexPath, "utf-8");
+    const mcpConfig = getMCPConfigFromEnv();
+    if (mcpConfig) {
+      const configScript = `<script>window.MCP_CLI_CONFIG = ${JSON.stringify(mcpConfig)};</script>`;
+      htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
+    }
+    return c.html(htmlContent);
+  });
+} else {
+  app.get("/", (c) => {
+    return c.json({
+      message: "MCPJam API Server",
+      environment: "development",
+      frontend: `http://localhost:${serverPort}`
+    });
+  });
+}
+var port = parseInt(process.env.PORT || "3001");
+logBox(`http://localhost:${port}`, "\u{1F680} Inspector Launched");
+var server = serve({
+  fetch: app.fetch,
+  port,
+  hostname: "0.0.0.0"
+  // Bind to all interfaces for Docker
+});
+process.on("SIGINT", () => {
+  console.log("\n\u{1F6D1} Shutting down gracefully...");
+  server.close();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.log("\n\u{1F6D1} Shutting down gracefully...");
+  server.close();
+  process.exit(0);
+});
+var index_default = app;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map