@mcpjam/inspector 0.9.8 → 0.9.9

package/dist/server/index.js

@@ -1,2022 +0,0 @@
-// 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 as join2 } 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 { 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;
-    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 "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) => {
-  try {
-    const result = await agent.generate(messages, {
-      temperature: getDefaultTemperatureByProvider(provider)
-    });
-    if (result.text && result.text.trim()) {
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({
-            type: "text",
-            content: result.text
-          })}
-
-`
-        )
-      );
-    }
-  } catch (fallbackErr) {
-    streamingContext.controller.enqueue(
-      streamingContext.encoder.encode(
-        `data: ${JSON.stringify({
-          type: "text",
-          content: "Failed to generate response. Please try again. ",
-          error: fallbackErr instanceof Error ? fallbackErr.message : "Unknown error"
-        })}
-
-`
-      )
-    );
-  }
-};
-var createStreamingResponse = async (agent, messages, toolsets, streamingContext, provider) => {
-  const stream = await agent.stream(messages, {
-    maxSteps: MAX_AGENT_STEPS,
-    temperature: getDefaultTemperatureByProvider(provider),
-    toolsets,
-    onStepFinish: ({ text, toolCalls, toolResults }) => {
-      handleAgentStepFinish(streamingContext, text, toolCalls, toolResults);
-    }
-  });
-  const { hasContent } = await streamAgentResponse(streamingContext, stream);
-  if (!hasContent) {
-    dbg("No content from textStream; falling back to completion");
-    await fallbackToCompletion(agent, messages, streamingContext, provider);
-  }
-  streamingContext.controller.enqueue(
-    streamingContext.encoder.encode(
-      `data: ${JSON.stringify({
-        type: "elicitation_complete"
-      })}
-
-`
-    )
-  );
-  streamingContext.controller.enqueue(
-    streamingContext.encoder.encode(`data: [DONE]
-
-`)
-  );
-};
-chat.post("/", async (c) => {
-  const mcpClientManager = c.mcpJamClientManager;
-  try {
-    const requestData = await c.req.json();
-    const {
-      serverConfigs,
-      model,
-      provider,
-      apiKey,
-      systemPrompt,
-      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
-          );
-        } catch (error) {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({
-                type: "error",
-                error: error instanceof Error ? error.message : "Unknown error"
-              })}
-
-`
-            )
-          );
-        } finally {
-          mcpClientManager.clearElicitationCallback();
-          controller.close();
-        }
-      }
-    });
-    return new Response(readableStream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      }
-    });
-  } catch (error) {
-    console.error("[mcp/chat] Error in chat API:", error);
-    mcpClientManager.clearElicitationCallback();
-    return c.json(
-      {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      },
-      500
-    );
-  }
-});
-var chat_default = chat;
-
-// routes/mcp/tests.ts
-import { Hono as Hono7 } from "hono";
-import { writeFile, mkdir } from "fs/promises";
-import { join, dirname } from "path";
-import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
-import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
-import { createOllama as createOllama2 } from "ollama-ai-provider";
-import { Agent as Agent2 } from "@mastra/core/agent";
-
-// utils/mcp-utils.ts
-import { MCPClient } from "@mastra/mcp";
-function validateServerConfig(serverConfig) {
-  if (!serverConfig) {
-    return {
-      success: false,
-      error: {
-        message: "Server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const config = { ...serverConfig };
-  if (config.url) {
-    try {
-      if (typeof config.url === "string") {
-        const parsed = new URL(config.url);
-        parsed.search = "";
-        parsed.hash = "";
-        config.url = parsed;
-      } else if (typeof config.url === "object" && !config.url.href) {
-        return {
-          success: false,
-          error: {
-            message: "Invalid URL configuration",
-            status: 400
-          }
-        };
-      }
-      if (config.oauth?.access_token) {
-        const authHeaders = {
-          Authorization: `Bearer ${config.oauth.access_token}`,
-          ...config.requestInit?.headers || {}
-        };
-        config.requestInit = {
-          ...config.requestInit,
-          headers: authHeaders
-        };
-        config.eventSourceInit = {
-          fetch(input, init) {
-            const headers = new Headers(init?.headers || {});
-            headers.set(
-              "Authorization",
-              `Bearer ${config.oauth.access_token}`
-            );
-            if (config.requestInit?.headers) {
-              const requestHeaders = new Headers(config.requestInit.headers);
-              requestHeaders.forEach((value, key) => {
-                if (key.toLowerCase() !== "authorization") {
-                  headers.set(key, value);
-                }
-              });
-            }
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      } else if (config.requestInit?.headers) {
-        config.eventSourceInit = {
-          fetch(input, init) {
-            const headers = new Headers(init?.headers || {});
-            const requestHeaders = new Headers(config.requestInit.headers);
-            requestHeaders.forEach((value, key) => {
-              headers.set(key, value);
-            });
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          message: `Invalid URL format: ${error}`,
-          status: 400
-        }
-      };
-    }
-  }
-  return {
-    success: true,
-    config
-  };
-}
-function generateUniqueServerID(serverName) {
-  const normalizedBase = normalizeServerConfigName(serverName);
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `${normalizedBase}_${timestamp}_${random}`;
-}
-var validateMultipleServerConfigs = (serverConfigs) => {
-  if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
-    return {
-      success: false,
-      error: {
-        message: "At least one server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const validConfigs = {};
-  const serverNameMapping = {};
-  const errors = {};
-  let hasErrors = false;
-  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
-    const validationResult = validateServerConfig(serverConfig);
-    if (validationResult.success && validationResult.config) {
-      const serverID = generateUniqueServerID(serverName);
-      validConfigs[serverID] = validationResult.config;
-      serverNameMapping[serverID] = serverName;
-    } else {
-      hasErrors = true;
-      let errorMessage = "Configuration validation failed";
-      if (validationResult.error) {
-        errorMessage = validationResult.error.message;
-      }
-      errors[serverName] = errorMessage;
-    }
-  }
-  if (!hasErrors) {
-    return {
-      success: true,
-      validConfigs,
-      serverNameMapping
-    };
-  }
-  if (Object.keys(validConfigs).length > 0) {
-    return {
-      success: false,
-      validConfigs,
-      serverNameMapping,
-      errors
-    };
-  }
-  return {
-    success: false,
-    errors,
-    error: {
-      message: "All server configurations failed validation",
-      status: 400
-    }
-  };
-};
-function createMCPClientWithMultipleConnections(serverConfigs) {
-  const originalMCPClient = new MCPClient({
-    id: `chat-${Date.now()}`,
-    servers: serverConfigs
-  });
-  const originalGetTools = originalMCPClient.getTools.bind(originalMCPClient);
-  originalMCPClient.getTools = async () => {
-    const tools2 = await originalGetTools();
-    const fixedTools = {};
-    for (const [toolName, toolConfig] of Object.entries(tools2)) {
-      const parts = toolName.split("_");
-      if (parts.length >= 3 && parts[0] === parts[1]) {
-        const fixedName = parts.slice(1).join("_");
-        fixedTools[fixedName] = toolConfig;
-      } else {
-        fixedTools[toolName] = toolConfig;
-      }
-    }
-    return fixedTools;
-  };
-  return originalMCPClient;
-}
-function normalizeServerConfigName(serverName) {
-  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-}
-
-// routes/mcp/tests.ts
-var tests = new Hono7();
-tests.post("/generate", async (c) => {
-  try {
-    const body = await c.req.json();
-    const test = body?.test;
-    const servers2 = body?.servers;
-    const model = body?.model;
-    if (!test?.id || !test?.prompt || !servers2 || Object.keys(servers2).length === 0) {
-      return c.json(
-        { success: false, error: "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 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);
-  }
-  async connectToServer(serverId, serverConfig) {
-    const pending = this.pendingConnections.get(serverId);
-    if (pending) {
-      await pending;
-      return;
-    }
-    const connectPromise = (async () => {
-      let id = this.serverIdMapping.get(serverId);
-      if (!id) {
-        id = generateUniqueServerId(serverId);
-        this.serverIdMapping.set(serverId, id);
-      }
-      if (this.mcpClients.has(id)) return;
-      const validation = validateServerConfig(serverConfig);
-      if (!validation.success) {
-        this.statuses.set(id, "error");
-        throw new Error(validation.error.message);
-      }
-      this.configs.set(id, validation.config);
-      this.statuses.set(id, "connecting");
-      const client = new MCPClient2({
-        id: `mcpjam-${id}`,
-        servers: { [id]: validation.config }
-      });
-      try {
-        await client.getTools();
-        this.mcpClients.set(id, client);
-        this.statuses.set(id, "connected");
-        if (client.elicitation?.onRequest) {
-          client.elicitation.onRequest(
-            id,
-            async (elicitationRequest) => {
-              return await this.handleElicitationRequest(elicitationRequest);
-            }
-          );
-        }
-        await this.discoverServerResources(id);
-      } catch (err) {
-        this.statuses.set(id, "error");
-        try {
-          await client.disconnect();
-        } catch {
-        }
-        this.mcpClients.delete(id);
-        throw err;
-      }
-    })().finally(() => {
-      this.pendingConnections.delete(serverId);
-    });
-    this.pendingConnections.set(serverId, connectPromise);
-    await connectPromise;
-  }
-  async disconnectFromServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
-    if (!id) return;
-    const client = this.mcpClients.get(id);
-    if (client) {
-      try {
-        await client.disconnect();
-      } catch {
-      }
-    }
-    this.mcpClients.delete(id);
-    this.statuses.set(id, "disconnected");
-    this.serverIdMapping.delete(serverId);
-    for (const key of Array.from(this.toolRegistry.keys())) {
-      const item = this.toolRegistry.get(key);
-      if (item.serverId === id) this.toolRegistry.delete(key);
-    }
-    for (const key of Array.from(this.resourceRegistry.keys())) {
-      const item = this.resourceRegistry.get(key);
-      if (item.serverId === id) this.resourceRegistry.delete(key);
-    }
-    for (const key of Array.from(this.promptRegistry.keys())) {
-      const item = this.promptRegistry.get(key);
-      if (item.serverId === id) this.promptRegistry.delete(key);
-    }
-  }
-  getConnectionStatus(serverId) {
-    const id = this.getServerUniqueId(serverId);
-    return id ? this.statuses.get(id) || "disconnected" : "disconnected";
-  }
-  getConnectedServers() {
-    const servers2 = {};
-    for (const [originalName, uniqueId] of this.serverIdMapping.entries()) {
-      servers2[originalName] = {
-        status: this.statuses.get(uniqueId) || "disconnected",
-        config: this.configs.get(uniqueId)
-      };
-    }
-    return servers2;
-  }
-  async discoverAllResources() {
-    const serverIds = Array.from(this.mcpClients.keys());
-    await Promise.all(serverIds.map((id) => this.discoverServerResources(id)));
-  }
-  async discoverServerResources(serverId) {
-    const client = this.mcpClients.get(serverId);
-    if (!client) return;
-    const toolsets = await client.getToolsets();
-    const flattenedTools = {};
-    Object.values(toolsets).forEach((serverTools) => {
-      Object.assign(flattenedTools, serverTools);
-    });
-    for (const [name, tool] of Object.entries(flattenedTools)) {
-      this.toolRegistry.set(`${serverId}:${name}`, {
-        name,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        outputSchema: tool.outputSchema,
-        serverId
-      });
-    }
-    try {
-      const res = await client.resources.list();
-      for (const [, list] of Object.entries(res)) {
-        for (const r of list) {
-          this.resourceRegistry.set(`${serverId}:${r.uri}`, {
-            uri: r.uri,
-            name: r.name,
-            description: r.description,
-            mimeType: r.mimeType,
-            serverId
-          });
-        }
-      }
-    } catch {
-    }
-    try {
-      const prompts2 = await client.prompts.list();
-      for (const [, list] of Object.entries(prompts2)) {
-        for (const p of list) {
-          this.promptRegistry.set(`${serverId}:${p.name}`, {
-            name: p.name,
-            description: p.description,
-            arguments: p.arguments,
-            serverId
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  getAvailableTools() {
-    return Array.from(this.toolRegistry.values());
-  }
-  async getToolsetsForServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
-    if (!id) {
-      throw new Error(`No MCP client available for server: ${serverId}`);
-    }
-    const client = this.mcpClients.get(id);
-    if (!client) {
-      throw new Error(`No MCP client available for server: ${serverId}`);
-    }
-    const toolsets = await client.getToolsets();
-    const flattenedTools = {};
-    Object.values(toolsets).forEach((serverTools) => {
-      Object.assign(flattenedTools, serverTools);
-    });
-    return flattenedTools;
-  }
-  getAvailableResources() {
-    return Array.from(this.resourceRegistry.values());
-  }
-  getResourcesForServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
-    if (!id) return [];
-    return Array.from(this.resourceRegistry.values()).filter(
-      (r) => r.serverId === id
-    );
-  }
-  getAvailablePrompts() {
-    return Array.from(this.promptRegistry.values());
-  }
-  getPromptsForServer(serverId) {
-    const id = this.getServerUniqueId(serverId);
-    if (!id) return [];
-    return Array.from(this.promptRegistry.values()).filter(
-      (p) => p.serverId === id
-    );
-  }
-  async executeToolDirect(toolName, parameters = {}) {
-    let serverId = "";
-    let name = toolName;
-    if (toolName.includes(":")) {
-      const [sid, n] = toolName.split(":", 2);
-      const mappedId = this.getServerUniqueId(sid);
-      serverId = mappedId || (this.mcpClients.has(sid) ? sid : "");
-      name = n;
-    } else {
-      for (const tool2 of this.toolRegistry.values()) {
-        if (tool2.name === toolName) {
-          serverId = tool2.serverId;
-          name = toolName;
-          break;
-        }
-      }
-    }
-    if (!serverId) {
-      for (const [clientServerId, client2] of this.mcpClients.entries()) {
-        try {
-          const toolsets2 = await client2.getToolsets();
-          const flattenedTools2 = {};
-          Object.values(toolsets2).forEach((serverTools) => {
-            Object.assign(flattenedTools2, serverTools);
-          });
-          if (flattenedTools2[toolName]) {
-            serverId = clientServerId;
-            name = toolName;
-            break;
-          }
-        } catch {
-        }
-      }
-    }
-    if (!serverId) {
-      throw new Error(`Tool not found in any connected server: ${toolName}`);
-    }
-    const client = this.mcpClients.get(serverId);
-    if (!client)
-      throw new Error(`No MCP client available for server: ${serverId}`);
-    const toolsets = await client.getToolsets();
-    const flattenedTools = {};
-    Object.values(toolsets).forEach((serverTools) => {
-      Object.assign(flattenedTools, serverTools);
-    });
-    const tool = flattenedTools[name];
-    if (!tool)
-      throw new Error(`Tool '${name}' not found in server '${serverId}'`);
-    const schema = tool.inputSchema;
-    const hasContextProperty = schema && typeof schema === "object" && schema.properties && Object.prototype.hasOwnProperty.call(
-      schema.properties,
-      "context"
-    );
-    const requiresContext = hasContextProperty || schema && Array.isArray(schema.required) && schema.required.includes("context");
-    const contextWrapped = { context: parameters || {} };
-    const direct = parameters || {};
-    const attempts = requiresContext ? [contextWrapped, direct] : [direct, contextWrapped];
-    let lastError = void 0;
-    for (const args of attempts) {
-      try {
-        const result = await tool.execute(args);
-        return { result };
-      } catch (err) {
-        lastError = err;
-      }
-    }
-    throw lastError;
-  }
-  async getResource(resourceUri, serverId) {
-    let uri = resourceUri;
-    const mappedId = this.getServerUniqueId(serverId);
-    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
-    if (!resolvedServerId) {
-      throw new Error(`No MCP client available for server: ${serverId}`);
-    }
-    const client = this.mcpClients.get(resolvedServerId);
-    if (!client) throw new Error("No MCP client available");
-    const content = await client.resources.read(resolvedServerId, uri);
-    return { contents: content?.contents || [] };
-  }
-  async getPrompt(promptName, serverId, args) {
-    const mappedId = this.getServerUniqueId(serverId);
-    const resolvedServerId = mappedId || (this.mcpClients.has(serverId) ? serverId : void 0);
-    if (!resolvedServerId) {
-      throw new Error(`No MCP client available for server: ${serverId}`);
-    }
-    const client = this.mcpClients.get(resolvedServerId);
-    if (!client) throw new Error("No MCP client available");
-    const content = await client.prompts.get({
-      serverName: resolvedServerId,
-      name: promptName,
-      args: args || {}
-    });
-    return { content };
-  }
-  /**
-   * Handles elicitation requests from MCP servers during direct tool execution
-   */
-  async handleElicitationRequest(elicitationRequest) {
-    const requestId = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    return new Promise((resolve, reject) => {
-      this.pendingElicitations.set(requestId, { resolve, reject });
-      if (this.elicitationCallback) {
-        this.elicitationCallback({
-          requestId,
-          message: elicitationRequest.message,
-          schema: elicitationRequest.requestedSchema
-        }).then(resolve).catch(reject);
-      } else {
-        const error = new Error("ELICITATION_REQUIRED");
-        error.elicitationRequest = {
-          requestId,
-          message: elicitationRequest.message,
-          schema: elicitationRequest.requestedSchema
-        };
-        reject(error);
-      }
-    });
-  }
-  /**
-   * Responds to a pending elicitation request
-   */
-  respondToElicitation(requestId, response) {
-    const pending = this.pendingElicitations.get(requestId);
-    if (!pending) {
-      return false;
-    }
-    pending.resolve(response);
-    this.pendingElicitations.delete(requestId);
-    return true;
-  }
-  /**
-   * Gets the pending elicitations map for external access
-   */
-  getPendingElicitations() {
-    return this.pendingElicitations;
-  }
-  /**
-   * Sets a callback to handle elicitation requests
-   */
-  setElicitationCallback(callback) {
-    this.elicitationCallback = callback;
-  }
-  /**
-   * Clears the elicitation callback
-   */
-  clearElicitationCallback() {
-    this.elicitationCallback = void 0;
-  }
-};
-
-// index.ts
-function logBox(content, title) {
-  const lines = content.split("\n");
-  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 = join2(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