@samanhappy/mcphub 1.0.17 → 1.0.18

package/dist/services/mcpService.js

@@ -27,7 +27,7 @@ import { maybeCompressToolResult } from './toolResultCompressionService.js';
 import { assertHostedToolAllowed, filterHostedTools, reserveHostedToolCall, settleHostedToolCall, } from './hostedAuthService.js';
 import { formatErrorForLogging, sanitizeStringForLogging, summarizeErrorForLogging, } from '../utils/serialization.js';
 import { MCP_APPS_CAPABILITIES, filterModelVisibleTools, hasMcpAppsCapability, isAppOnlyTool, stripMcpAppsMetadata, } from '../utils/mcpApps.js';
-import { supportsCacheRefresh, injectRefreshFlag, clearRunnerCache, } from '../utils/cacheUtils.js';
+import { supportsCacheRefresh, injectRefreshFlag, clearRunnerCache } from '../utils/cacheUtils.js';
 const servers = {};
 import { setupClientKeepAlive } from './keepAliveService.js';
 /**
@@ -654,7 +654,9 @@ const summarizePromptForLogging = (prompt) => {
     return summary;
 };
 export const collectPassthroughHeaders = (requestHeaders, passthroughHeaderNames) => {
-    if (!requestHeaders || !Array.isArray(passthroughHeaderNames) || passthroughHeaderNames.length === 0) {
+    if (!requestHeaders ||
+        !Array.isArray(passthroughHeaderNames) ||
+        passthroughHeaderNames.length === 0) {
         return {};
     }
     const passthroughHeaders = {};
@@ -908,8 +910,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
             const existingServer = existingServerInfos.find((s) => s.name === name);
             const isDifferentServer = Boolean(serverName) && serverName !== name;
             if (existingServer &&
-                (isDifferentServer ||
-                    (!serverName && existingServer.status === 'connected'))) {
+                (isDifferentServer || (!serverName && existingServer.status === 'connected'))) {
                 nextServerInfos.push({
                     ...existingServer,
                     enabled: expandedConf.enabled === undefined ? true : expandedConf.enabled,
@@ -1605,6 +1606,31 @@ const normalizeToolNameForServer = (serverName, toolName) => {
     const prefix = `${serverName}${getNameSeparator()}`;
     return toolName.startsWith(prefix) ? toolName.substring(prefix.length) : toolName;
 };
+const getGroupLookupName = (group) => {
+    if (group?.startsWith('$smart/')) {
+        return group.substring(7) || undefined;
+    }
+    return group;
+};
+const getExposedServerName = (serverName, serverConfig) => {
+    return serverConfig?.alias?.trim() || serverName;
+};
+const replacePrefixedServerName = (name, fromServerName, toServerName) => {
+    if (fromServerName === toServerName) {
+        return name;
+    }
+    const separator = getNameSeparator();
+    const prefix = `${fromServerName}${separator}`;
+    return name.startsWith(prefix)
+        ? `${toServerName}${separator}${name.substring(prefix.length)}`
+        : name;
+};
+const projectNameForGroup = (name, serverName, serverConfig) => {
+    return replacePrefixedServerName(name, serverName, getExposedServerName(serverName, serverConfig));
+};
+const resolveNameFromGroup = (name, serverName, serverConfig) => {
+    return replacePrefixedServerName(name, getExposedServerName(serverName, serverConfig), serverName);
+};
 const findToolOnServer = (serverInfo, toolName, allowRawName) => {
     return serverInfo.tools.find((tool) => tool.name === toolName ||
         (allowRawName && normalizeToolNameForServer(serverInfo.name, tool.name) === toolName));
@@ -1614,7 +1640,55 @@ const assertToolAvailableForRoute = (tool, appsRouteContext) => {
         throw new Error(`Tool '${tool.name}' is only available to MCP Apps`);
     }
 };
-const projectToolForDownstream = (serverName, tool, appsRouteContext) => {
+const resolveToolInGroup = async (group, toolName, allowRawName) => {
+    const lookupGroup = getGroupLookupName(group);
+    if (!lookupGroup) {
+        return undefined;
+    }
+    const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(lookupGroup);
+    for (const serverInfo of filteredServerInfos) {
+        if (serverInfo.status !== 'connected' || serverInfo.enabled === false) {
+            continue;
+        }
+        const serverConfig = serverConfigsByName.get(serverInfo.name);
+        const internalToolName = resolveNameFromGroup(toolName, serverInfo.name, serverConfig);
+        const tool = findToolOnServer(serverInfo, internalToolName, allowRawName);
+        if (!tool) {
+            continue;
+        }
+        const filteredTools = await filterToolsByGroup(lookupGroup, serverInfo.name, [tool], serverConfig);
+        if (filteredTools.length === 0) {
+            continue;
+        }
+        return { serverInfo, toolName: internalToolName, tool };
+    }
+    return undefined;
+};
+async function resolvePromptInGroup(group, promptName) {
+    const lookupGroup = getGroupLookupName(group);
+    if (!lookupGroup) {
+        return undefined;
+    }
+    const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(lookupGroup);
+    for (const serverInfo of filteredServerInfos) {
+        if (serverInfo.status !== 'connected' || serverInfo.enabled === false) {
+            continue;
+        }
+        const serverConfig = serverConfigsByName.get(serverInfo.name);
+        const internalPromptName = resolveNameFromGroup(promptName, serverInfo.name, serverConfig);
+        const prompt = serverInfo.prompts.find((item) => item.name === internalPromptName);
+        if (!prompt) {
+            continue;
+        }
+        const filteredPrompts = await filterPromptsByGroup(lookupGroup, serverInfo.name, [prompt], serverConfig);
+        if (filteredPrompts.length === 0) {
+            continue;
+        }
+        return { serverInfo, promptName: internalPromptName };
+    }
+    return undefined;
+}
+const projectToolForDownstream = (serverName, tool, appsRouteContext, serverConfig) => {
     if (!appsRouteContext.enabled && isAppOnlyTool(tool)) {
         return undefined;
     }
@@ -1623,7 +1697,7 @@ const projectToolForDownstream = (serverName, tool, appsRouteContext) => {
         ...projectedTool,
         name: appsRouteContext.enabled
             ? normalizeToolNameForServer(serverName, projectedTool.name)
-            : projectedTool.name,
+            : projectNameForGroup(projectedTool.name, serverName, serverConfig),
     };
 };
 export const handleListToolsRequest = async (_, extra) => {
@@ -1640,10 +1714,11 @@ export const handleListToolsRequest = async (_, extra) => {
     const allTools = [];
     for (const serverInfo of filteredServerInfos) {
         if (serverInfo.tools && serverInfo.tools.length > 0) {
+            const groupServerConfig = serverConfigsByName.get(serverInfo.name);
             // Filter tools based on server configuration
             let tools = await filterToolsByConfig(serverInfo.name, serverInfo.tools);
             // If this is a group request, apply group-level tool filtering
-            tools = await filterToolsByGroup(group, serverInfo.name, tools, serverConfigsByName.get(serverInfo.name));
+            tools = await filterToolsByGroup(group, serverInfo.name, tools, groupServerConfig);
             // Apply custom descriptions from server configuration
             const serverConfig = await getServerDao().findById(serverInfo.name);
             const toolsWithCustomDescriptions = tools.map((tool) => {
@@ -1654,7 +1729,7 @@ export const handleListToolsRequest = async (_, extra) => {
                 };
             });
             allTools.push(...toolsWithCustomDescriptions.flatMap((tool) => {
-                const projectedTool = projectToolForDownstream(serverInfo.name, tool, appsRouteContext);
+                const projectedTool = projectToolForDownstream(serverInfo.name, tool, appsRouteContext, groupServerConfig);
                 return projectedTool ? [projectedTool] : [];
             }));
         }
@@ -1715,12 +1790,22 @@ export const handleCallToolRequest = async (request, extra) => {
             }
             const { arguments: toolArgs } = request.params.arguments || {};
             let targetServerInfo;
+            let targetToolName = toolName;
+            let targetTool;
             if (appsRouteContext.enabled) {
                 targetServerInfo = appsRouteContext.serverInfo;
             }
             else if (extra && extra.server) {
                 targetServerInfo = getServerByName(extra.server);
             }
+            else if (group) {
+                const groupTool = await resolveToolInGroup(group, toolName, appsRouteContext.enabled);
+                if (groupTool) {
+                    targetServerInfo = groupTool.serverInfo;
+                    targetToolName = groupTool.toolName;
+                    targetTool = groupTool.tool;
+                }
+            }
             else {
                 // Find the first server that has this tool
                 targetServerInfo = serverInfos.find((serverInfo) => serverInfo.status === 'connected' &&
@@ -1731,7 +1816,7 @@ export const handleCallToolRequest = async (request, extra) => {
                 throw new Error(`No available servers found with tool: ${toolName}`);
             }
             // Check if the tool exists on the server
-            const tool = findToolOnServer(targetServerInfo, toolName, appsRouteContext.enabled);
+            const tool = targetTool ?? findToolOnServer(targetServerInfo, targetToolName, appsRouteContext.enabled);
             if (!tool) {
                 throw new Error(`Tool '${toolName}' not found on server '${targetServerInfo.name}'`);
             }
@@ -1743,12 +1828,12 @@ export const handleCallToolRequest = async (request, extra) => {
                 // Use toolArgs if it has properties, otherwise fallback to request.params.arguments
                 const finalArgs = toolArgs && typeof toolArgs === 'object' ? toolArgs : {};
                 console.log('Invoking OpenAPI tool', {
-                    toolName,
+                    toolName: targetToolName,
                     serverName: targetServerInfo.name,
                     arguments: summarizeArgumentsForLogging(finalArgs),
                 });
                 // Remove server prefix from tool name if present
-                const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, toolName);
+                const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, targetToolName);
                 // Extract passthrough headers from extra or request context
                 let passthroughHeaders;
                 let requestHeaders = null;
@@ -1821,11 +1906,11 @@ export const handleCallToolRequest = async (request, extra) => {
             // Use toolArgs if it has properties, otherwise fallback to request.params.arguments
             const finalArgs = toolArgs && typeof toolArgs === 'object' ? toolArgs : {};
             console.log('Invoking tool', {
-                toolName,
+                toolName: targetToolName,
                 serverName: targetServerInfo.name,
                 arguments: summarizeArgumentsForLogging(finalArgs),
             });
-            const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, toolName);
+            const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, targetToolName);
             await reserveHostedIfNeeded(targetServerInfo.name, cleanToolName);
             const result = await callToolWithReconnect(targetServerInfo, {
                 name: cleanToolName,
@@ -1864,12 +1949,17 @@ export const handleCallToolRequest = async (request, extra) => {
             });
         }
         // Regular tool handling
+        const groupTool = !appsRouteContext.enabled && group
+            ? await resolveToolInGroup(group, request.params.name, appsRouteContext.enabled)
+            : undefined;
         const serverInfo = appsRouteContext.enabled
             ? appsRouteContext.serverInfo
-            : getServerByTool(request.params.name);
-        const tool = serverInfo
-            ? findToolOnServer(serverInfo, request.params.name, appsRouteContext.enabled)
-            : undefined;
+            : (groupTool?.serverInfo ?? (group ? undefined : getServerByTool(request.params.name)));
+        const routeToolName = groupTool?.toolName ?? request.params.name;
+        const tool = groupTool?.tool ??
+            (serverInfo
+                ? findToolOnServer(serverInfo, routeToolName, appsRouteContext.enabled)
+                : undefined);
         if (!serverInfo || !tool) {
             throw new Error(`Server not found: ${request.params.name}`);
         }
@@ -1879,7 +1969,7 @@ export const handleCallToolRequest = async (request, extra) => {
             // For OpenAPI servers, use the OpenAPI client
             const openApiClient = serverInfo.openApiClient;
             // Remove server prefix from tool name if present
-            const cleanToolName = normalizeToolNameForServer(serverInfo.name, request.params.name);
+            const cleanToolName = normalizeToolNameForServer(serverInfo.name, routeToolName);
             console.log('Invoking OpenAPI tool', {
                 toolName: cleanToolName,
                 serverName: serverInfo.name,
@@ -1955,7 +2045,7 @@ export const handleCallToolRequest = async (request, extra) => {
         if (!client) {
             throw new Error(`Client not found for server: ${serverInfo.name}`);
         }
-        const cleanToolName = normalizeToolNameForServer(serverInfo.name, request.params.name);
+        const cleanToolName = normalizeToolNameForServer(serverInfo.name, routeToolName);
         await reserveHostedIfNeeded(serverInfo.name, cleanToolName);
         const result = await callToolWithReconnect(serverInfo, { ...request.params, name: cleanToolName }, serverInfo.options || {});
         await settleHostedIfNeeded({
@@ -2031,6 +2121,8 @@ export const handleCallToolRequest = async (request, extra) => {
 export const handleGetPromptRequest = async (request, extra) => {
     try {
         const { name, arguments: promptArgs } = request.params;
+        const sessionId = extra?.sessionId || '';
+        const group = extra?.group || getGroup(sessionId) || undefined;
         // Check built-in prompts first
         const builtinPrompt = await getBuiltinPromptDao().findByName(name);
         if (builtinPrompt && builtinPrompt.enabled !== false) {
@@ -2051,9 +2143,17 @@ export const handleGetPromptRequest = async (request, extra) => {
             };
         }
         let server;
+        let promptNameForServer = name;
         if (extra && extra.server) {
             server = getServerByName(extra.server);
         }
+        else if (group) {
+            const groupPrompt = await resolvePromptInGroup(group, name);
+            if (groupPrompt) {
+                server = groupPrompt.serverInfo;
+                promptNameForServer = groupPrompt.promptName;
+            }
+        }
         else {
             // Find the first server that has this prompt
             server = serverInfos.find((serverInfo) => serverInfo.status === 'connected' &&
@@ -2066,7 +2166,9 @@ export const handleGetPromptRequest = async (request, extra) => {
         // Remove server prefix from prompt name if present
         const separator = getNameSeparator();
         const prefix = `${server.name}${separator}`;
-        const cleanPromptName = name.startsWith(prefix) ? name.substring(prefix.length) : name;
+        const cleanPromptName = promptNameForServer.startsWith(prefix)
+            ? promptNameForServer.substring(prefix.length)
+            : promptNameForServer;
         const promptParams = {
             name: cleanPromptName || '',
             arguments: promptArgs,
@@ -2112,6 +2214,7 @@ export const handleListPromptsRequest = async (_, extra) => {
     const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(group);
     for (const serverInfo of filteredServerInfos) {
         if (serverInfo.prompts && serverInfo.prompts.length > 0) {
+            const groupServerConfig = serverConfigsByName.get(serverInfo.name);
             // Filter prompts based on server configuration
             const serverConfig = await getServerDao().findById(serverInfo.name);
             let enabledPrompts = serverInfo.prompts;
@@ -2122,12 +2225,13 @@ export const handleListPromptsRequest = async (_, extra) => {
                     return promptConfig?.enabled !== false;
                 });
             }
-            enabledPrompts = await filterPromptsByGroup(group, serverInfo.name, enabledPrompts, serverConfigsByName.get(serverInfo.name));
+            enabledPrompts = await filterPromptsByGroup(group, serverInfo.name, enabledPrompts, groupServerConfig);
             // Apply custom descriptions from server configuration
             const promptsWithCustomDescriptions = enabledPrompts.map((prompt) => {
                 const promptConfig = serverConfig?.prompts?.[prompt.name];
                 return normalizePromptForList({
                     ...prompt,
+                    name: projectNameForGroup(prompt.name, serverInfo.name, groupServerConfig),
                     description: promptConfig?.description || prompt.description, // Use custom description if available
                 });
             });