@mcpjam/inspector 0.9.5 → 0.9.6

package/dist/server/index.js

@@ -537,171 +537,6 @@ var prompts_default = prompts;
 
 // routes/mcp/chat.ts
 import { Hono as Hono6 } from "hono";
-
-// utils/mcp-utils.ts
-import { MCPClient } from "@mastra/mcp";
-function validateServerConfig(serverConfig) {
-  if (!serverConfig) {
-    return {
-      success: false,
-      error: {
-        message: "Server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const config = { ...serverConfig };
-  if (config.url) {
-    try {
-      if (typeof config.url === "string") {
-        const parsed = new URL(config.url);
-        parsed.search = "";
-        parsed.hash = "";
-        config.url = parsed;
-      } else if (typeof config.url === "object" && !config.url.href) {
-        return {
-          success: false,
-          error: {
-            message: "Invalid URL configuration",
-            status: 400
-          }
-        };
-      }
-      if (config.oauth?.access_token) {
-        const authHeaders = {
-          Authorization: `Bearer ${config.oauth.access_token}`,
-          ...config.requestInit?.headers || {}
-        };
-        config.requestInit = {
-          ...config.requestInit,
-          headers: authHeaders
-        };
-        config.eventSourceInit = {
-          fetch(input, init) {
-            const headers = new Headers(init?.headers || {});
-            headers.set(
-              "Authorization",
-              `Bearer ${config.oauth.access_token}`
-            );
-            if (config.requestInit?.headers) {
-              const requestHeaders = new Headers(config.requestInit.headers);
-              requestHeaders.forEach((value, key) => {
-                if (key.toLowerCase() !== "authorization") {
-                  headers.set(key, value);
-                }
-              });
-            }
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      } else if (config.requestInit?.headers) {
-        config.eventSourceInit = {
-          fetch(input, init) {
-            const headers = new Headers(init?.headers || {});
-            const requestHeaders = new Headers(config.requestInit.headers);
-            requestHeaders.forEach((value, key) => {
-              headers.set(key, value);
-            });
-            return fetch(input, {
-              ...init,
-              headers
-            });
-          }
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          message: `Invalid URL format: ${error}`,
-          status: 400
-        }
-      };
-    }
-  }
-  return {
-    success: true,
-    config
-  };
-}
-var validateMultipleServerConfigs = (serverConfigs) => {
-  if (!serverConfigs || Object.keys(serverConfigs).length === 0) {
-    return {
-      success: false,
-      error: {
-        message: "At least one server configuration is required",
-        status: 400
-      }
-    };
-  }
-  const validConfigs = {};
-  const errors = {};
-  let hasErrors = false;
-  for (const [serverName, serverConfig] of Object.entries(serverConfigs)) {
-    const validationResult = validateServerConfig(serverConfig);
-    if (validationResult.success && validationResult.config) {
-      validConfigs[serverName] = validationResult.config;
-    } else {
-      hasErrors = true;
-      let errorMessage = "Configuration validation failed";
-      if (validationResult.error) {
-        errorMessage = validationResult.error.message;
-      }
-      errors[serverName] = errorMessage;
-    }
-  }
-  if (!hasErrors) {
-    return {
-      success: true,
-      validConfigs
-    };
-  }
-  if (Object.keys(validConfigs).length > 0) {
-    return {
-      success: false,
-      validConfigs,
-      errors
-    };
-  }
-  return {
-    success: false,
-    errors,
-    error: {
-      message: "All server configurations failed validation",
-      status: 400
-    }
-  };
-};
-function createMCPClientWithMultipleConnections(serverConfigs) {
-  const originalMCPClient = new MCPClient({
-    id: `chat-${Date.now()}`,
-    servers: serverConfigs
-  });
-  const originalGetTools = originalMCPClient.getTools.bind(originalMCPClient);
-  originalMCPClient.getTools = async () => {
-    const tools2 = await originalGetTools();
-    const fixedTools = {};
-    for (const [toolName, toolConfig] of Object.entries(tools2)) {
-      const parts = toolName.split("_");
-      if (parts.length >= 3 && parts[0] === parts[1]) {
-        const fixedName = parts.slice(1).join("_");
-        fixedTools[fixedName] = toolConfig;
-      } else {
-        fixedTools[toolName] = toolConfig;
-      }
-    }
-    return fixedTools;
-  };
-  return originalMCPClient;
-}
-function normalizeServerConfigName(serverName) {
-  return serverName.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
-}
-
-// routes/mcp/chat.ts
 import { Agent } from "@mastra/core/agent";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
@@ -763,35 +598,6 @@ var createLlmModel = (modelDefinition, apiKey, ollamaBaseUrl) => {
       );
   }
 };
-var createElicitationHandler = (streamingContext) => {
-  return async (elicitationRequest) => {
-    const requestId = `elicit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    if (streamingContext.controller && streamingContext.encoder) {
-      streamingContext.controller.enqueue(
-        streamingContext.encoder.encode(
-          `data: ${JSON.stringify({
-            type: "elicitation_request",
-            requestId,
-            message: elicitationRequest.message,
-            schema: elicitationRequest.requestedSchema,
-            timestamp: /* @__PURE__ */ new Date()
-          })}
-
-`
-        )
-      );
-    }
-    return new Promise((resolve, reject) => {
-      pendingElicitations2.set(requestId, { resolve, reject });
-      setTimeout(() => {
-        if (pendingElicitations2.has(requestId)) {
-          pendingElicitations2.delete(requestId);
-          reject(new Error("Elicitation timeout"));
-        }
-      }, ELICITATION_TIMEOUT);
-    });
-  };
-};
 var wrapToolsWithStreaming = (tools2, streamingContext) => {
   const wrappedTools = {};
   for (const [name, tool] of Object.entries(tools2)) {
@@ -1000,15 +806,6 @@ var fallbackToCompletion = async (agent, messages, streamingContext, provider) =
     );
   }
 };
-var safeDisconnect = async (client) => {
-  if (client) {
-    try {
-      await client.disconnect();
-    } catch (cleanupError) {
-      console.warn("[mcp/chat] Error cleaning up MCP client:", cleanupError);
-    }
-  }
-};
 var createStreamingResponse = async (agent, messages, toolsets, streamingContext, provider) => {
   const stream = await agent.stream(messages, {
     maxSteps: MAX_AGENT_STEPS,
@@ -1039,7 +836,7 @@ var createStreamingResponse = async (agent, messages, toolsets, streamingContext
   );
 };
 chat.post("/", async (c) => {
-  let client = null;
+  const mcpClientManager = c.mcpJamClientManager;
   try {
     const requestData = await c.req.json();
     const {
@@ -1096,22 +893,36 @@ chat.post("/", async (c) => {
         400
       );
     }
-    const validation = validateMultipleServerConfigs(serverConfigs);
-    if (!validation.success) {
-      dbg(
-        "Server config validation failed",
-        validation.errors || validation.error
-      );
+    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: validation.error.message,
-          details: validation.errors
+          error: "Failed to connect to any servers",
+          details: serverErrors
         },
-        validation.error.status
+        400
       );
     }
-    client = createMCPClientWithMultipleConnections(validation.validConfigs);
+    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",
@@ -1124,9 +935,26 @@ chat.post("/", async (c) => {
       role: msg.role,
       content: msg.content
     }));
-    const toolsets = await client.getToolsets();
+    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", {
-      toolsetServers: Object.keys(toolsets),
+      connectedServers,
+      toolCount: allTools.length,
       messageCount: formattedMessages.length
     });
     const encoder = new TextEncoder3();
@@ -1140,7 +968,7 @@ chat.post("/", async (c) => {
           stepIndex: 0
         };
         const flattenedTools = {};
-        Object.values(toolsets).forEach((serverTools) => {
+        Object.values(toolsByServer).forEach((serverTools) => {
           Object.assign(flattenedTools, serverTools);
         });
         const streamingWrappedTools = wrapToolsWithStreaming(
@@ -1153,25 +981,44 @@ chat.post("/", async (c) => {
           model: agent.model,
           tools: Object.keys(streamingWrappedTools).length > 0 ? streamingWrappedTools : void 0
         });
-        if (client?.elicitation?.onRequest) {
-          for (const serverName of Object.keys(serverConfigs)) {
-            const normalizedName = normalizeServerConfigName(serverName);
-            const elicitationHandler = createElicitationHandler(streamingContext);
-            client.elicitation.onRequest(normalizedName, elicitationHandler);
-          }
-        }
-        try {
-          if (client) {
-            await createStreamingResponse(
-              streamingAgent,
-              formattedMessages,
-              toolsets,
-              streamingContext,
-              provider
+        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()
+                })}
+
+`
+              )
             );
-          } else {
-            throw new Error("MCP client is null");
           }
+          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(
@@ -1184,7 +1031,7 @@ chat.post("/", async (c) => {
             )
           );
         } finally {
-          await safeDisconnect(client);
+          mcpClientManager.clearElicitationCallback();
           controller.close();
         }
       }
@@ -1198,7 +1045,7 @@ chat.post("/", async (c) => {
     });
   } catch (error) {
     console.error("[mcp/chat] Error in chat API:", error);
-    await safeDisconnect(client);
+    mcpClientManager.clearElicitationCallback();
     return c.json(
       {
         success: false,
@@ -1218,6 +1065,182 @@ 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 {
@@ -1524,13 +1547,20 @@ var mcp_default = mcp;
 
 // services/mcpjam-client-manager.ts
 import { MCPClient as MCPClient2 } from "@mastra/mcp";
-function normalizeServerId(serverId) {
-  return serverId.toLowerCase().replace(/[\s\-]+/g, "_").replace(/[^a-z0-9_]/g, "");
+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();
@@ -1538,46 +1568,69 @@ var MCPJamClientManager = class {
   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 id = normalizeServerId(serverId);
-    if (this.mcpClients.has(id)) return;
-    const validation = validateServerConfig(serverConfig);
-    if (!validation.success) {
-      this.statuses.set(id, "error");
-      throw new Error(validation.error.message);
+    const pending = this.pendingConnections.get(serverId);
+    if (pending) {
+      await pending;
+      return;
     }
-    this.configs.set(id, validation.config);
-    this.statuses.set(id, "connecting");
-    const client = new MCPClient2({
-      id: `mcpjam-${id}`,
-      servers: { [id]: validation.config }
-    });
-    try {
-      await client.getTools();
-      this.mcpClients.set(id, client);
-      this.statuses.set(id, "connected");
-      if (client.elicitation?.onRequest) {
-        const normalizedName = normalizeServerConfigName(serverId);
-        client.elicitation.onRequest(
-          normalizedName,
-          async (elicitationRequest) => {
-            return await this.handleElicitationRequest(elicitationRequest);
-          }
-        );
+    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);
       }
-      await this.discoverServerResources(id);
-    } catch (err) {
-      this.statuses.set(id, "error");
+      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.disconnect();
-      } catch {
+        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;
       }
-      this.mcpClients.delete(id);
-      throw err;
-    }
+    })().finally(() => {
+      this.pendingConnections.delete(serverId);
+    });
+    this.pendingConnections.set(serverId, connectPromise);
+    await connectPromise;
   }
   async disconnectFromServer(serverId) {
-    const id = normalizeServerId(serverId);
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return;
     const client = this.mcpClients.get(id);
     if (client) {
       try {
@@ -1587,6 +1640,7 @@ var MCPJamClientManager = class {
     }
     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);
@@ -1601,15 +1655,15 @@ var MCPJamClientManager = class {
     }
   }
   getConnectionStatus(serverId) {
-    const id = normalizeServerId(serverId);
-    return this.statuses.get(id) || "disconnected";
+    const id = this.getServerUniqueId(serverId);
+    return id ? this.statuses.get(id) || "disconnected" : "disconnected";
   }
   getConnectedServers() {
     const servers2 = {};
-    for (const [serverId, status] of this.statuses.entries()) {
-      servers2[serverId] = {
-        status,
-        config: this.configs.get(serverId)
+    for (const [originalName, uniqueId] of this.serverIdMapping.entries()) {
+      servers2[originalName] = {
+        status: this.statuses.get(uniqueId) || "disconnected",
+        config: this.configs.get(uniqueId)
       };
     }
     return servers2;
@@ -1619,29 +1673,32 @@ var MCPJamClientManager = class {
     await Promise.all(serverIds.map((id) => this.discoverServerResources(id)));
   }
   async discoverServerResources(serverId) {
-    const id = normalizeServerId(serverId);
-    const client = this.mcpClients.get(id);
+    const client = this.mcpClients.get(serverId);
     if (!client) return;
-    const tools2 = await client.getTools();
-    for (const [name, tool] of Object.entries(tools2)) {
-      this.toolRegistry.set(`${id}:${name}`, {
+    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: id
+        serverId
       });
     }
     try {
       const res = await client.resources.list();
-      for (const [group, list] of Object.entries(res)) {
+      for (const [, list] of Object.entries(res)) {
         for (const r of list) {
-          this.resourceRegistry.set(`${id}:${r.uri}`, {
+          this.resourceRegistry.set(`${serverId}:${r.uri}`, {
             uri: r.uri,
             name: r.name,
             description: r.description,
             mimeType: r.mimeType,
-            serverId: id
+            serverId
           });
         }
       }
@@ -1649,13 +1706,13 @@ var MCPJamClientManager = class {
     }
     try {
       const prompts2 = await client.prompts.list();
-      for (const [group, list] of Object.entries(prompts2)) {
+      for (const [, list] of Object.entries(prompts2)) {
         for (const p of list) {
-          this.promptRegistry.set(`${id}:${p.name}`, {
+          this.promptRegistry.set(`${serverId}:${p.name}`, {
             name: p.name,
             description: p.description,
             arguments: p.arguments,
-            serverId: id
+            serverId
           });
         }
       }
@@ -1666,7 +1723,10 @@ var MCPJamClientManager = class {
     return Array.from(this.toolRegistry.values());
   }
   async getToolsetsForServer(serverId) {
-    const id = normalizeServerId(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}`);
@@ -1682,7 +1742,8 @@ var MCPJamClientManager = class {
     return Array.from(this.resourceRegistry.values());
   }
   getResourcesForServer(serverId) {
-    const id = normalizeServerId(serverId);
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return [];
     return Array.from(this.resourceRegistry.values()).filter(
       (r) => r.serverId === id
     );
@@ -1691,20 +1752,22 @@ var MCPJamClientManager = class {
     return Array.from(this.promptRegistry.values());
   }
   getPromptsForServer(serverId) {
-    const id = normalizeServerId(serverId);
+    const id = this.getServerUniqueId(serverId);
+    if (!id) return [];
     return Array.from(this.promptRegistry.values()).filter(
       (p) => p.serverId === id
     );
   }
-  async executeToolDirect(toolName, parameters) {
+  async executeToolDirect(toolName, parameters = {}) {
     let serverId = "";
     let name = toolName;
     if (toolName.includes(":")) {
       const [sid, n] = toolName.split(":", 2);
-      serverId = normalizeServerId(sid);
+      const mappedId = this.getServerUniqueId(sid);
+      serverId = mappedId || (this.mcpClients.has(sid) ? sid : "");
       name = n;
     } else {
-      for (const [key, tool2] of this.toolRegistry.entries()) {
+      for (const tool2 of this.toolRegistry.values()) {
         if (tool2.name === toolName) {
           serverId = tool2.serverId;
           name = toolName;
@@ -1743,21 +1806,48 @@ var MCPJamClientManager = class {
     const tool = flattenedTools[name];
     if (!tool)
       throw new Error(`Tool '${name}' not found in server '${serverId}'`);
-    const result = await tool.execute({ context: parameters || {} });
-    return { result };
+    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 client = this.mcpClients.get(serverId);
+    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(serverId, uri);
+    const content = await client.resources.read(resolvedServerId, uri);
     return { contents: content?.contents || [] };
   }
   async getPrompt(promptName, serverId, args) {
-    const client = this.mcpClients.get(serverId);
+    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: serverId,
+      serverName: resolvedServerId,
       name: promptName,
       args: args || {}
     });