@samanhappy/mcphub 1.0.10 → 1.0.12

package/dist/services/mcpService.js

@@ -22,8 +22,10 @@ import { initializeAllOAuthClients } from './oauthService.js';
 import { createOAuthProvider } from './mcpOAuthProvider.js';
 import { initSmartRoutingService, getSmartRoutingTools, handleSearchToolsRequest, handleDescribeToolRequest, isSmartRoutingGroup, } from './smartRoutingService.js';
 import { getActivityLoggingService } from './activityLoggingService.js';
+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';
 const servers = {};
 import { setupClientKeepAlive } from './keepAliveService.js';
 /**
@@ -194,18 +196,26 @@ export const notifyToolChanged = async (name, options) => {
     await registerAllTools(false, name, options);
     broadcastToolListChanged();
 };
-export const broadcastToolListChanged = () => {
+const broadcastListChanged = (listType, sendNotification) => {
     Object.values(servers).forEach((server) => {
-        server
-            .sendToolListChanged()
-            .catch((error) => {
-            console.warn('Failed to send tool list changed notification:', error.message);
-        })
+        sendNotification(server)
             .then(() => {
-            console.log('Tool list changed notification sent successfully');
+            console.log(`${listType} list changed notification sent successfully`);
+        })
+            .catch((error) => {
+            console.warn(`Failed to send ${listType} list changed notification:`, error.message);
         });
     });
 };
+export const broadcastToolListChanged = () => {
+    broadcastListChanged('tool', (server) => server.sendToolListChanged());
+};
+export const broadcastResourceListChanged = () => {
+    broadcastListChanged('resource', (server) => server.sendResourceListChanged());
+};
+export const broadcastPromptListChanged = () => {
+    broadcastListChanged('prompt', (server) => server.sendPromptListChanged());
+};
 export const updateServerInfoVisibility = (serverName, visibility) => {
     const serverInfo = getServerByName(serverName);
     if (!serverInfo) {
@@ -230,8 +240,11 @@ export const syncToolEmbedding = async (serverName, toolName) => {
         console.warn(`Tool not found: ${toolName} on server: ${serverName}`);
         return;
     }
+    if (isAppOnlyTool(tool)) {
+        return;
+    }
     // Save tool as vector embedding for search
-    saveToolsAsVectorEmbeddings(serverName, [tool]).catch((error) => {
+    syncToolsAsVectorEmbeddings(serverName, [tool]).catch((error) => {
         console.warn(`[EMBED_SYNC_ERROR] Failed to sync embedding for tool "${toolName}" on server "${serverName}"`);
         console.error('Error syncing single tool embedding', { serverName, toolName, error });
     });
@@ -245,26 +258,122 @@ const cleanInputSchema = (schema) => {
     delete cleanedSchema.$schema;
     return cleanedSchema;
 };
+export const normalizeToolForCache = (serverName, tool) => {
+    return {
+        ...tool,
+        name: `${serverName}${getNameSeparator()}${tool.name}`,
+        description: tool.description || '',
+        inputSchema: cleanInputSchema(tool.inputSchema || {}),
+    };
+};
+const syncToolsAsVectorEmbeddings = async (serverName, tools, options) => {
+    const modelVisibleTools = filterModelVisibleTools(tools);
+    if (modelVisibleTools.length === 0) {
+        await removeServerToolEmbeddings(serverName);
+        return;
+    }
+    await saveToolsAsVectorEmbeddings(serverName, modelVisibleTools, options);
+};
 // Normalize prompt payload to satisfy MCP ListPrompts response schema
 const normalizePromptForList = (prompt) => {
     return {
+        ...prompt,
         name: prompt.name,
         title: prompt.title || prompt.name,
         description: prompt.description || '',
         arguments: Array.isArray(prompt.arguments) ? prompt.arguments : [],
     };
 };
+const normalizePromptForCache = (serverName, prompt) => {
+    return normalizePromptForList({
+        ...prompt,
+        name: `${serverName}${getNameSeparator()}${prompt.name}`,
+    });
+};
 // Normalize resource payload to avoid nullable DB fields violating MCP schema
 const normalizeResourceForList = (resource) => {
     return {
+        ...resource,
         uri: resource.uri,
         name: resource.name || '',
         description: resource.description || '',
         mimeType: resource.mimeType || '',
     };
 };
+const normalizeResourceForCache = (resource) => {
+    return normalizeResourceForList(resource);
+};
 // Store all server information
 let serverInfos = [];
+export const updateServerToolsCache = (serverInfo, tools, options) => {
+    serverInfo.tools = tools.map((tool) => normalizeToolForCache(serverInfo.name, tool));
+    syncToolsAsVectorEmbeddings(serverInfo.name, serverInfo.tools, {
+        reportProgress: options?.reportEmbeddingProgress === true,
+    }).catch(() => {
+        console.warn('[EMBED_SYNC_ERROR] Failed to sync tool embeddings');
+    });
+};
+const updateServerPromptsCache = (serverInfo, prompts) => {
+    serverInfo.prompts = prompts.map((prompt) => normalizePromptForCache(serverInfo.name, prompt));
+};
+const updateServerResourcesCache = (serverInfo, resources) => {
+    serverInfo.resources = resources.map(normalizeResourceForCache);
+};
+const logListChangedRefreshError = (listType) => {
+    console.warn(`Failed to refresh ${listType} list after upstream notification`);
+};
+const createUpstreamMcpClient = (name, getServerInfo) => {
+    return new Client({
+        name: `mcp-client-${name}`,
+        version: '1.0.0',
+    }, {
+        capabilities: MCP_APPS_CAPABILITIES,
+        listChanged: {
+            tools: {
+                onChanged: (error, tools) => {
+                    const serverInfo = getServerInfo();
+                    if (error) {
+                        logListChangedRefreshError('tool');
+                        return;
+                    }
+                    if (!serverInfo || !tools) {
+                        return;
+                    }
+                    updateServerToolsCache(serverInfo, tools);
+                    broadcastToolListChanged();
+                },
+            },
+            prompts: {
+                onChanged: (error, prompts) => {
+                    const serverInfo = getServerInfo();
+                    if (error) {
+                        logListChangedRefreshError('prompt');
+                        return;
+                    }
+                    if (!serverInfo || !prompts) {
+                        return;
+                    }
+                    updateServerPromptsCache(serverInfo, prompts);
+                    broadcastPromptListChanged();
+                },
+            },
+            resources: {
+                onChanged: (error, resources) => {
+                    const serverInfo = getServerInfo();
+                    if (error) {
+                        logListChangedRefreshError('resource');
+                        return;
+                    }
+                    if (!serverInfo || !resources) {
+                        return;
+                    }
+                    updateServerResourcesCache(serverInfo, resources);
+                    broadcastResourceListChanged();
+                },
+            },
+        },
+    });
+};
 // Normalize and infer server type for safe client display
 const normalizeServerType = (type) => {
     if (!type)
@@ -679,12 +788,7 @@ const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries
                     // Recreate transport using helper function
                     const newTransport = await createTransportFromConfig(serverInfo.name, server);
                     // Create new client
-                    const client = new Client({
-                        name: `mcp-client-${serverInfo.name}`,
-                        version: '1.0.0',
-                    }, {
-                        capabilities: {},
-                    });
+                    const client = createUpstreamMcpClient(serverInfo.name, () => serverInfo);
                     // Reconnect with new transport
                     await client.connect(newTransport, serverInfo.options || {});
                     // Update server info with new client and transport
@@ -694,19 +798,7 @@ const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries
                     // Reload tools list after reconnection
                     try {
                         const tools = await client.listTools({}, serverInfo.options || {});
-                        serverInfo.tools = tools.tools.map((tool) => ({
-                            name: `${serverInfo.name}${getNameSeparator()}${tool.name}`,
-                            description: tool.description || '',
-                            inputSchema: cleanInputSchema(tool.inputSchema || {}),
-                        }));
-                        // Save tools as vector embeddings for search
-                        saveToolsAsVectorEmbeddings(serverInfo.name, serverInfo.tools).catch((error) => {
-                            console.warn(`[EMBED_SYNC_ERROR] Failed to sync tool embeddings after reconnect for server "${serverInfo.name}"`);
-                            console.error('Error syncing tool embeddings after reconnect', {
-                                serverName: serverInfo.name,
-                                error: summarizeErrorForLogging(error),
-                            });
-                        });
+                        updateServerToolsCache(serverInfo, tools.tools);
                     }
                     catch (listToolsError) {
                         console.warn('Failed to reload tools after reconnection', {
@@ -850,7 +942,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                     serverInfo.openApiClient = openApiClient;
                     console.log(`Successfully initialized OpenAPI server: ${name} with ${mcpTools.length} tools`);
                     // Save tools as vector embeddings for search
-                    saveToolsAsVectorEmbeddings(name, mcpTools, {
+                    syncToolsAsVectorEmbeddings(name, mcpTools, {
                         reportProgress: options?.reportEmbeddingProgress === true && serverName === name,
                     }).catch((error) => {
                         console.warn(`[EMBED_SYNC_ERROR] Failed to sync OpenAPI embeddings for server "${name}"`);
@@ -875,12 +967,8 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
             else {
                 transport = await createTransportFromConfig(name, expandedConf);
             }
-            const client = new Client({
-                name: `mcp-client-${name}`,
-                version: '1.0.0',
-            }, {
-                capabilities: {},
-            });
+            const serverInfoRef = {};
+            const client = createUpstreamMcpClient(name, () => serverInfoRef.current);
             // Get request options from server configuration, with fallbacks
             const serverRequestOptions = expandedConf.options || {};
             const defaultRequestTimeout = Number(process.env.DEFAULT_REQUEST_TIMEOUT) || 60000;
@@ -911,6 +999,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                 createTime: Date.now(),
                 config: expandedConf, // Store reference to expanded config
             };
+            serverInfoRef.current = serverInfo;
             const pendingAuth = expandedConf.oauth?.pendingAuthorization;
             if (pendingAuth) {
                 serverInfo.status = 'oauth_required';
@@ -937,20 +1026,8 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                         .listTools({}, initRequestOptions || requestOptions)
                         .then((tools) => {
                         console.log(`Successfully listed ${tools.tools.length} tools for server: ${name}`);
-                        serverInfo.tools = tools.tools.map((tool) => ({
-                            name: `${name}${getNameSeparator()}${tool.name}`,
-                            description: tool.description || '',
-                            inputSchema: cleanInputSchema(tool.inputSchema || {}),
-                        }));
-                        // Save tools as vector embeddings for search
-                        saveToolsAsVectorEmbeddings(name, serverInfo.tools, {
-                            reportProgress: options?.reportEmbeddingProgress === true && serverName === name,
-                        }).catch((embeddingError) => {
-                            console.warn(`[EMBED_SYNC_ERROR] Failed to sync tool embeddings for connected server "${name}"`);
-                            console.error('Error syncing tool embeddings for connected server', {
-                                serverName: name,
-                                error: summarizeErrorForLogging(embeddingError),
-                            });
+                        updateServerToolsCache(serverInfo, tools.tools, {
+                            reportEmbeddingProgress: options?.reportEmbeddingProgress === true && serverName === name,
                         });
                     })
                         .catch((error) => {
@@ -966,12 +1043,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                         .listPrompts({}, initRequestOptions || requestOptions)
                         .then((prompts) => {
                         console.log(`Successfully listed ${prompts.prompts.length} prompts for server: ${name}`);
-                        serverInfo.prompts = prompts.prompts.map((prompt) => normalizePromptForList({
-                            name: `${name}${getNameSeparator()}${prompt.name}`,
-                            title: prompt.title,
-                            description: prompt.description,
-                            arguments: prompt.arguments,
-                        }));
+                        updateServerPromptsCache(serverInfo, prompts.prompts);
                     })
                         .catch((error) => {
                         console.error('Failed to list prompts for server', {
@@ -986,12 +1058,7 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
                         .listResources({}, initRequestOptions || requestOptions)
                         .then((resources) => {
                         console.log(`Successfully listed ${resources.resources.length} resources for server: ${name}`);
-                        serverInfo.resources = resources.resources.map((resource) => normalizeResourceForList({
-                            uri: resource.uri,
-                            name: resource.name,
-                            description: resource.description,
-                            mimeType: resource.mimeType,
-                        }));
+                        updateServerResourcesCache(serverInfo, resources.resources);
                     })
                         .catch((error) => {
                         console.error('Failed to list resources for server', {
@@ -1360,6 +1427,48 @@ export const toggleServerStatus = async (name, enabled) => {
         return { success: false, message: 'Failed to toggle server status' };
     }
 };
+const getMcpAppsRouteContext = async (sessionId, group) => {
+    if (!sessionId ||
+        isSmartRoutingGroup(group) ||
+        !hasMcpAppsCapability(servers[sessionId]?.getClientCapabilities())) {
+        return { enabled: false };
+    }
+    const { filteredServerInfos } = await getFilteredServerInfosForGroup(group);
+    if (filteredServerInfos.length !== 1 ||
+        filteredServerInfos[0].status !== 'connected' ||
+        !filteredServerInfos[0].client) {
+        return { enabled: false };
+    }
+    return {
+        enabled: true,
+        serverInfo: filteredServerInfos[0],
+    };
+};
+const normalizeToolNameForServer = (serverName, toolName) => {
+    const prefix = `${serverName}${getNameSeparator()}`;
+    return toolName.startsWith(prefix) ? toolName.substring(prefix.length) : toolName;
+};
+const findToolOnServer = (serverInfo, toolName, allowRawName) => {
+    return serverInfo.tools.find((tool) => tool.name === toolName ||
+        (allowRawName && normalizeToolNameForServer(serverInfo.name, tool.name) === toolName));
+};
+const assertToolAvailableForRoute = (tool, appsRouteContext) => {
+    if (isAppOnlyTool(tool) && !appsRouteContext.enabled) {
+        throw new Error(`Tool '${tool.name}' is only available to MCP Apps`);
+    }
+};
+const projectToolForDownstream = (serverName, tool, appsRouteContext) => {
+    if (!appsRouteContext.enabled && isAppOnlyTool(tool)) {
+        return undefined;
+    }
+    const projectedTool = appsRouteContext.enabled ? tool : stripMcpAppsMetadata(tool);
+    return {
+        ...projectedTool,
+        name: appsRouteContext.enabled
+            ? normalizeToolNameForServer(serverName, projectedTool.name)
+            : projectedTool.name,
+    };
+};
 export const handleListToolsRequest = async (_, extra) => {
     const sessionId = extra.sessionId || '';
     const group = getGroup(sessionId);
@@ -1370,6 +1479,7 @@ export const handleListToolsRequest = async (_, extra) => {
         return getSmartRoutingTools(group);
     }
     const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(group);
+    const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
     const allTools = [];
     for (const serverInfo of filteredServerInfos) {
         if (serverInfo.tools && serverInfo.tools.length > 0) {
@@ -1386,7 +1496,10 @@ export const handleListToolsRequest = async (_, extra) => {
                     description: toolConfig?.description || tool.description, // Use custom description if available
                 };
             });
-            allTools.push(...toolsWithCustomDescriptions);
+            allTools.push(...toolsWithCustomDescriptions.flatMap((tool) => {
+                const projectedTool = projectToolForDownstream(serverInfo.name, tool, appsRouteContext);
+                return projectedTool ? [projectedTool] : [];
+            }));
         }
     }
     return {
@@ -1405,6 +1518,7 @@ export const handleCallToolRequest = async (request, extra) => {
     // Fallback to extra for backward compatibility (e.g., direct API calls)
     const group = requestContextService.getGroupContext() || extra?.group || getGroup(sessionId) || undefined;
     const username = requestContextService.getUsernameContext() || extra?.username || undefined;
+    let appsRouteContext = { enabled: false };
     const keyId = bearerKeyContext.keyId || extra?.keyId || undefined;
     const keyName = bearerKeyContext.keyName || extra?.keyName || undefined;
     const sourceIp = requestContextService.getRequestContext()?.remoteAddress || undefined;
@@ -1425,6 +1539,7 @@ export const handleCallToolRequest = async (request, extra) => {
         });
     };
     try {
+        appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
         // Special handling for smart routing tools
         if (request.params.name === 'search_tools') {
             const { query, limit = 10 } = request.params.arguments || {};
@@ -1443,7 +1558,10 @@ export const handleCallToolRequest = async (request, extra) => {
             }
             const { arguments: toolArgs } = request.params.arguments || {};
             let targetServerInfo;
-            if (extra && extra.server) {
+            if (appsRouteContext.enabled) {
+                targetServerInfo = appsRouteContext.serverInfo;
+            }
+            else if (extra && extra.server) {
                 targetServerInfo = getServerByName(extra.server);
             }
             else {
@@ -1456,10 +1574,11 @@ 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 toolExists = targetServerInfo.tools.some((tool) => tool.name === toolName);
-            if (!toolExists) {
+            const tool = findToolOnServer(targetServerInfo, toolName, appsRouteContext.enabled);
+            if (!tool) {
                 throw new Error(`Tool '${toolName}' not found on server '${targetServerInfo.name}'`);
             }
+            assertToolAvailableForRoute(tool, appsRouteContext);
             // Handle OpenAPI servers differently
             if (targetServerInfo.openApiClient) {
                 // For OpenAPI servers, use the OpenAPI client
@@ -1472,11 +1591,7 @@ export const handleCallToolRequest = async (request, extra) => {
                     arguments: summarizeArgumentsForLogging(finalArgs),
                 });
                 // Remove server prefix from tool name if present
-                const separator = getNameSeparator();
-                const prefix = `${targetServerInfo.name}${separator}`;
-                const cleanToolName = toolName.startsWith(prefix)
-                    ? toolName.substring(prefix.length)
-                    : toolName;
+                const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, toolName);
                 // Extract passthrough headers from extra or request context
                 let passthroughHeaders;
                 let requestHeaders = null;
@@ -1528,14 +1643,18 @@ export const handleCallToolRequest = async (request, extra) => {
                     keyName,
                     sourceIp,
                 });
-                return {
+                return await maybeCompressToolResult({
                     content: [
                         {
                             type: 'text',
                             text: JSON.stringify(result),
                         },
                     ],
-                };
+                }, {
+                    serverName: targetServerInfo.name,
+                    toolName: cleanToolName,
+                    group,
+                });
             }
             // Call the tool on the target server (MCP servers)
             const client = targetServerInfo.client;
@@ -1549,11 +1668,7 @@ export const handleCallToolRequest = async (request, extra) => {
                 serverName: targetServerInfo.name,
                 arguments: summarizeArgumentsForLogging(finalArgs),
             });
-            const separator = getNameSeparator();
-            const prefix = `${targetServerInfo.name}${separator}`;
-            const cleanToolName = toolName.startsWith(prefix)
-                ? toolName.substring(prefix.length)
-                : toolName;
+            const cleanToolName = normalizeToolNameForServer(targetServerInfo.name, toolName);
             await reserveHostedIfNeeded(targetServerInfo.name, cleanToolName);
             const result = await callToolWithReconnect(targetServerInfo, {
                 name: cleanToolName,
@@ -1585,23 +1700,29 @@ export const handleCallToolRequest = async (request, extra) => {
                 sourceIp,
                 errorMessage: result.isError ? 'Tool returned error response' : undefined,
             });
-            return result;
+            return await maybeCompressToolResult(result, {
+                serverName: targetServerInfo.name,
+                toolName: cleanToolName,
+                group,
+            });
         }
         // Regular tool handling
-        const serverInfo = getServerByTool(request.params.name);
-        if (!serverInfo) {
+        const serverInfo = appsRouteContext.enabled
+            ? appsRouteContext.serverInfo
+            : getServerByTool(request.params.name);
+        const tool = serverInfo
+            ? findToolOnServer(serverInfo, request.params.name, appsRouteContext.enabled)
+            : undefined;
+        if (!serverInfo || !tool) {
             throw new Error(`Server not found: ${request.params.name}`);
         }
+        assertToolAvailableForRoute(tool, appsRouteContext);
         // Handle OpenAPI servers differently
         if (serverInfo.openApiClient) {
             // For OpenAPI servers, use the OpenAPI client
             const openApiClient = serverInfo.openApiClient;
             // Remove server prefix from tool name if present
-            const separator = getNameSeparator();
-            const prefix = `${serverInfo.name}${separator}`;
-            const cleanToolName = request.params.name.startsWith(prefix)
-                ? request.params.name.substring(prefix.length)
-                : request.params.name;
+            const cleanToolName = normalizeToolNameForServer(serverInfo.name, request.params.name);
             console.log('Invoking OpenAPI tool', {
                 toolName: cleanToolName,
                 serverName: serverInfo.name,
@@ -1659,25 +1780,25 @@ export const handleCallToolRequest = async (request, extra) => {
                 keyName,
                 sourceIp,
             });
-            return {
+            return await maybeCompressToolResult({
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify(result),
                     },
                 ],
-            };
+            }, {
+                serverName: serverInfo.name,
+                toolName: cleanToolName,
+                group,
+            });
         }
         // Handle MCP servers
         const client = serverInfo.client;
         if (!client) {
             throw new Error(`Client not found for server: ${serverInfo.name}`);
         }
-        const separator = getNameSeparator();
-        const prefix = `${serverInfo.name}${separator}`;
-        const cleanToolName = request.params.name.startsWith(prefix)
-            ? request.params.name.substring(prefix.length)
-            : request.params.name;
+        const cleanToolName = normalizeToolNameForServer(serverInfo.name, request.params.name);
         await reserveHostedIfNeeded(serverInfo.name, cleanToolName);
         const result = await callToolWithReconnect(serverInfo, { ...request.params, name: cleanToolName }, serverInfo.options || {});
         await settleHostedIfNeeded({
@@ -1706,7 +1827,11 @@ export const handleCallToolRequest = async (request, extra) => {
             sourceIp,
             errorMessage: result.isError ? 'Tool returned error response' : undefined,
         });
-        return result;
+        return await maybeCompressToolResult(result, {
+            serverName: serverInfo.name,
+            toolName: cleanToolName,
+            group,
+        });
     }
     catch (error) {
         console.error('Error handling CallToolRequest', summarizeErrorForLogging(error));
@@ -1860,6 +1985,7 @@ export const handleListResourcesRequest = async (_, extra) => {
     const sessionId = extra.sessionId || '';
     const group = getGroup(sessionId);
     console.log(`Handling ListResourcesRequest for group: ${group}`);
+    const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
     // Start with built-in resources (only enabled ones)
     const builtinResources = await getBuiltinResourceDao().findEnabled();
     const allResources = builtinResources.map((br) => normalizeResourceForList({
@@ -1884,10 +2010,13 @@ export const handleListResourcesRequest = async (_, extra) => {
             // Apply custom descriptions from server configuration
             const resourcesWithCustomDescriptions = enabledResources.map((resource) => {
                 const resourceConfig = serverConfig?.resources?.[resource.uri];
-                return normalizeResourceForList({
+                const normalizedResource = normalizeResourceForList({
                     ...resource,
                     description: resourceConfig?.description || resource.description,
                 });
+                return appsRouteContext.enabled
+                    ? normalizedResource
+                    : stripMcpAppsMetadata(normalizedResource);
             });
             allResources.push(...resourcesWithCustomDescriptions);
         }
@@ -1900,6 +2029,7 @@ export const handleListResourceTemplatesRequest = async (_, extra) => {
     const sessionId = extra.sessionId || '';
     const group = getGroup(sessionId);
     console.log(`Handling ListResourceTemplatesRequest for group: ${group}`);
+    const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
     const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(group, {
         requireClient: true,
     });
@@ -1908,15 +2038,21 @@ export const handleListResourceTemplatesRequest = async (_, extra) => {
             return [];
         }
         const templates = await serverInfo.client.listResourceTemplates({}, serverInfo.options || {});
-        return filterResourceTemplatesByGroup(group, serverInfo.name, templates.resourceTemplates || [], serverConfigsByName.get(serverInfo.name));
+        const filteredTemplates = await filterResourceTemplatesByGroup(group, serverInfo.name, templates.resourceTemplates || [], serverConfigsByName.get(serverInfo.name));
+        return appsRouteContext.enabled
+            ? filteredTemplates
+            : filteredTemplates.map((template) => stripMcpAppsMetadata(template));
     }));
     return {
         resourceTemplates: results.flatMap((result) => result.status === 'fulfilled' ? result.value : []),
     };
 };
-export const handleReadResourceRequest = async (request, _extra) => {
+export const handleReadResourceRequest = async (request, extra) => {
     try {
         const { uri } = request.params;
+        const sessionId = extra.sessionId || '';
+        const group = getGroup(sessionId);
+        const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
         // Check built-in resources first
         const builtinResource = await getBuiltinResourceDao().findByUri(uri);
         if (builtinResource && builtinResource.enabled !== false) {
@@ -1930,18 +2066,39 @@ export const handleReadResourceRequest = async (request, _extra) => {
                 ],
             };
         }
-        // Find the server that owns this resource
-        const server = serverInfos.find((serverInfo) => serverInfo.status === 'connected' &&
-            serverInfo.enabled !== false &&
-            serverInfo.resources?.find((resource) => resource.uri === uri));
-        if (!server) {
+        const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(group);
+        let server;
+        for (const serverInfo of filteredServerInfos) {
+            if (serverInfo.status !== 'connected') {
+                continue;
+            }
+            const serverConfig = await getServerDao().findById(serverInfo.name);
+            let enabledResources = serverInfo.resources;
+            if (serverConfig?.resources) {
+                enabledResources = enabledResources.filter((resource) => serverConfig.resources?.[resource.uri]?.enabled !== false);
+            }
+            enabledResources = await filterResourcesByGroup(group, serverInfo.name, enabledResources, serverConfigsByName.get(serverInfo.name));
+            if (enabledResources.some((resource) => resource.uri === uri)) {
+                server = serverInfo;
+                break;
+            }
+        }
+        if (!server && appsRouteContext.enabled && uri.startsWith('ui://')) {
+            server = appsRouteContext.serverInfo;
+        }
+        if (!server?.client) {
             throw new Error(`Resource not found: ${uri}`);
         }
-        const result = await server.client?.readResource({ uri });
-        if (!result) {
+        const result = await server.client.readResource({ uri });
+        if (!result || !Array.isArray(result.contents)) {
             throw new Error(`Failed to read resource: ${uri}`);
         }
-        return result;
+        return appsRouteContext.enabled
+            ? result
+            : {
+                ...result,
+                contents: result.contents.map((content) => stripMcpAppsMetadata(content)),
+            };
     }
     catch (error) {
         console.error('Error handling ReadResourceRequest', summarizeErrorForLogging(error));
@@ -1968,7 +2125,12 @@ export const createMcpServer = (name, version, options) => {
     }
     // If no group, use default name (global routing)
     const server = new Server({ name: serverName, version }, {
-        capabilities: { tools: {}, prompts: {}, resources: {} },
+        capabilities: {
+            tools: { listChanged: true },
+            prompts: { listChanged: true },
+            resources: { listChanged: true },
+            ...MCP_APPS_CAPABILITIES,
+        },
         ...(normalizedOptions.instructions !== undefined
             ? { instructions: normalizedOptions.instructions }
             : {}),