@samanhappy/mcphub 1.0.41 → 1.0.43

package/dist/services/mcpService.js

@@ -1,21 +1,20 @@
+import { getMcpRequestGroup } from '../utils/mcpRequestGroup.js';
+import { LegacyMcpClient } from '../clients/legacyMcpClient.js';
+import { LEGACY_PROTOCOL_VERSIONS } from '../utils/mcpProtocol.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { canAccessGroupRoute } from '../utils/groupAccess.js';
 import { PrincipalRuntimeService } from './principalRuntimeService.js';
 import { UserContextService } from './userContextService.js';
 import { deleteCredentialBindings, missingCredentialError } from './credentialBindingService.js';
-import { CredentialBindingError, hasCredentialTemplate, validateCredentialTemplate } from '../utils/credentialTemplate.js';
+import { CredentialBindingError, hasCredentialTemplate, validateCredentialTemplate, } from '../utils/credentialTemplate.js';
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
 import treeKill from 'tree-kill';
 import { isProcessTreeKillAvailable } from '../utils/processTree.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { StreamableHTTPClientTransport, } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { normalizeHeaders } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
+import { SSEClientTransport, StreamableHTTPClientTransport, } from '@modelcontextprotocol/client';
+import { Server } from '@modelcontextprotocol/server';
 import { createFetchWithProxy, getProxyConfigFromEnv } from './proxy.js';
 import { assertSafeUrl, createRedirectValidatingFetch } from '../utils/ssrf.js';
 import { createAbortIsolatingFetch } from '../utils/abortIsolatingFetch.js';
@@ -26,7 +25,7 @@ import config from '../config/index.js';
 import { validateServerName } from '../utils/serverNameValidation.js';
 import { getGroup } from './sseService.js';
 import { getServerConfigInGroup, normalizeGroupServers } from './groupService.js';
-import { removeServerToolEmbeddings, saveToolsAsVectorEmbeddings } from './vectorSearchService.js';
+import { removeServerToolEmbeddings, removeToolEmbeddings, saveToolsAsVectorEmbeddings, } from './vectorSearchService.js';
 import { OpenAPIClient } from '../clients/openapi.js';
 import { RequestContextService } from './requestContextService.js';
 import { getDataService } from './services.js';
@@ -40,7 +39,7 @@ import { assertHostedToolAllowed, filterHostedTools, reserveHostedToolCall, sett
 import { formatErrorForLogging, sanitizeStringForLogging, summarizeErrorForLogging, } from '../utils/serialization.js';
 import { addStdioErrorContext, observeStdioStderr } from '../utils/stdioDiagnostics.js';
 import { MCP_APPS_CAPABILITIES, filterModelVisibleTools, hasMcpAppsCapability, isAppOnlyTool, stripMcpAppsMetadata, } from '../utils/mcpApps.js';
-import { supportsCacheRefresh, injectRefreshFlag, clearRunnerCache, resolveRunnerPackageVersion } from '../utils/cacheUtils.js';
+import { supportsCacheRefresh, injectRefreshFlag, clearRunnerCache, resolveRunnerPackageVersion, } from '../utils/cacheUtils.js';
 import { checkPackageUpdate } from '../utils/packageUpdate.js';
 const servers = {};
 import { setupClientKeepAlive } from './keepAliveService.js';
@@ -519,7 +518,24 @@ const applyDescriptionOverridesForEmbedding = async (serverName, tools) => {
             : tool;
     });
 };
-const syncToolsAsVectorEmbeddings = async (serverName, tools, options) => {
+// Tail of the embedding tasks queued per server. A per-user connect and a
+// reindex, or two users connecting at once, often race on the same tool set;
+// queued behind the first run, the second one hits the skip check in
+// saveToolsAsVectorEmbeddings instead of embedding every tool a second time.
+const embeddingSyncTails = new Map();
+// Run `task` after every embedding task already queued for the server. A task
+// must not wait for another queued task of the same server, or both stall.
+const enqueueEmbeddingTask = (serverName, task) => {
+    const run = (embeddingSyncTails.get(serverName) ?? Promise.resolve()).then(task);
+    const tail = run.catch(() => undefined);
+    embeddingSyncTails.set(serverName, tail);
+    void tail.then(() => {
+        if (embeddingSyncTails.get(serverName) === tail)
+            embeddingSyncTails.delete(serverName);
+    });
+    return run;
+};
+export const syncToolsAsVectorEmbeddings = (serverName, tools, options) => enqueueEmbeddingTask(serverName, async () => {
     const toolsWithOverrides = await applyDescriptionOverridesForEmbedding(serverName, tools);
     const modelVisibleTools = filterModelVisibleTools(toolsWithOverrides);
     if (modelVisibleTools.length === 0) {
@@ -529,6 +545,38 @@ const syncToolsAsVectorEmbeddings = async (serverName, tools, options) => {
         return;
     }
     await saveToolsAsVectorEmbeddings(serverName, modelVisibleTools, options);
+});
+/**
+ * Embed the tools of a credential server, which never connects globally.
+ * Tools disabled in the server's tools config are never embedded: search
+ * filters them out of the hits anyway, but only after they have taken result
+ * slots. A toggle reaches the index without extra wiring: the tools config is
+ * part of the runtime revision, so the next acquire reconnects and re-syncs.
+ *
+ * Two callers, two scopes:
+ * - `partial: true` (every per-user connect): the list is what one user's
+ *   credentials show, and users may see different tools. The rows of the
+ *   listed, enabled tools are added or refreshed and nothing else is pruned,
+ *   so tools only other users see stay indexed. The listed tools that are
+ *   disabled are removed by name, queued before the sync.
+ * - otherwise (the reindex endpoint, which passes the union of every binding's
+ *   tools): the list is complete, so rows of tools outside it are pruned.
+ *
+ * Resolves to the number of tools handed to the vector store.
+ */
+export const syncCredentialServerToolEmbeddings = async (serverName, tools, options) => {
+    const enabledTools = await filterToolsByConfig(serverName, tools);
+    if (options?.partial) {
+        const enabledNames = new Set(enabledTools.map((tool) => tool.name));
+        const disabledNames = tools
+            .map((tool) => tool.name)
+            .filter((toolName) => !enabledNames.has(toolName));
+        if (disabledNames.length > 0) {
+            void enqueueEmbeddingTask(serverName, () => removeToolEmbeddings(serverName, disabledNames)).catch(() => undefined);
+        }
+    }
+    await syncToolsAsVectorEmbeddings(serverName, enabledTools, options);
+    return enabledTools.length;
 };
 // Normalize prompt payload to satisfy MCP ListPrompts response schema
 const normalizePromptForList = (prompt) => {
@@ -691,7 +739,7 @@ const logListChangedRefreshError = (listType) => {
     logger.warn(`Failed to refresh ${listType} list after upstream notification`);
 };
 const createUpstreamMcpClient = (name, getServerInfo) => {
-    return new Client({
+    return new LegacyMcpClient({
         name: `mcp-client-${name}`,
         version: '1.0.0',
     }, {
@@ -1029,10 +1077,17 @@ export const createRequestContextAwareFetch = (baseFetch, passthroughHeaderNames
         if (Object.keys(passthroughHeaders).length === 0) {
             return baseFetch(url, init);
         }
+        const headers = init?.headers;
+        const entries = headers instanceof Headers
+            ? [...headers.entries()]
+            : Array.isArray(headers)
+                ? headers
+                : Object.entries(headers ?? {});
+        const replacedNames = new Set(Object.keys(passthroughHeaders).map((name) => name.toLowerCase()));
         return baseFetch(url, {
             ...init,
             headers: {
-                ...normalizeHeaders(init?.headers),
+                ...Object.fromEntries(entries.filter(([name]) => !replacedNames.has(name.toLowerCase()))),
                 ...passthroughHeaders,
             },
         });
@@ -1070,11 +1125,17 @@ export const createTransportFromConfig = async (name, conf) => {
     }
     if (conf.type === 'streamable-http') {
         const options = {};
-        let headers = conf.headers ? (hasCredentialTemplate(conf) ? conf.headers : replaceEnvVars(conf.headers, env)) : {};
+        let headers = conf.headers
+            ? hasCredentialTemplate(conf)
+                ? conf.headers
+                : replaceEnvVars(conf.headers, env)
+            : {};
         const baseFetch = createAbortIsolatingFetch(createFetchWithProxy(getProxyConfigFromEnv(env)));
         const requestAwareFetch = createRedirectValidatingFetch(createRequestContextAwareFetch(baseFetch, conf.passthroughHeaders), allowInternal);
         // Create OAuth provider if configured - SDK will handle authentication automatically
-        const authProvider = hasCredentialTemplate(conf) ? undefined : await createOAuthProvider(name, conf);
+        const authProvider = hasCredentialTemplate(conf)
+            ? undefined
+            : await createOAuthProvider(name, conf);
         if (authProvider) {
             options.authProvider = authProvider;
             // When the OAuth provider is active, strip any static Authorization
@@ -1097,11 +1158,17 @@ export const createTransportFromConfig = async (name, conf) => {
     else if (conf.url) {
         // SSE transport
         const options = {};
-        let headers = conf.headers ? (hasCredentialTemplate(conf) ? conf.headers : replaceEnvVars(conf.headers, env)) : {};
+        let headers = conf.headers
+            ? hasCredentialTemplate(conf)
+                ? conf.headers
+                : replaceEnvVars(conf.headers, env)
+            : {};
         const baseFetch = createAbortIsolatingFetch(createFetchWithProxy(getProxyConfigFromEnv(env)));
         const requestAwareFetch = createRedirectValidatingFetch(createRequestContextAwareFetch(baseFetch, conf.passthroughHeaders), allowInternal);
         // Create OAuth provider if configured - SDK will handle authentication automatically
-        const authProvider = hasCredentialTemplate(conf) ? undefined : await createOAuthProvider(name, conf);
+        const authProvider = hasCredentialTemplate(conf)
+            ? undefined
+            : await createOAuthProvider(name, conf);
         if (authProvider) {
             options.authProvider = authProvider;
             // Drop static Authorization header when OAuth manages auth (see above).
@@ -1189,11 +1256,11 @@ const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries
         throw new Error(`Client not found for server: ${serverInfo.name}`);
     }
     if (hasCredentialTemplate(serverInfo.config)) {
-        return client.callTool(toolParams, undefined, options || {});
+        return client.callTool(toolParams, options || {});
     }
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
-            const result = await client.callTool(toolParams, undefined, options || {});
+            const result = await client.callTool(toolParams, options || {});
             // Check auth error
             checkAuthError(result);
             return result;
@@ -1206,10 +1273,12 @@ const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries
             if (attempt < maxRetries && transport && ((isStreamableHttp && isHttp40xError) || isSSE)) {
                 logger.warn(`${isHttp40xError ? 'HTTP 40x error' : 'error'} detected for ${isStreamableHttp ? 'StreamableHTTP' : 'SSE'} server ${serverInfo.name}${isolated ? ` (isolated session ${isolated.sessionId})` : ''}, attempting reconnection (attempt ${attempt + 1}/${maxRetries + 1})`);
                 try {
-                    const server = await getServerDao().findById(serverInfo.name);
-                    if (!server) {
+                    const rawConfig = await getServerDao().findById(serverInfo.name);
+                    if (!rawConfig) {
                         throw new Error(`Server configuration not found for: ${serverInfo.name}`);
                     }
+                    // Match initial connection expansion before URL validation and transport creation.
+                    const server = replaceEnvVars(rawConfig);
                     const newTransport = await createTransportFromConfig(serverInfo.name, server);
                     const newClient = createUpstreamMcpClient(serverInfo.name, () => serverInfo);
                     // Reconnect with new transport
@@ -1363,10 +1432,18 @@ export const initializeClientsFromSettings = async (isInit, serverName, options)
             if (hasCredentialTemplate(expandedConf)) {
                 validateCredentialTemplate(expandedConf);
                 nextServerInfos.push({
-                    name, owner: expandedConf.owner, visibility: expandedConf.visibility,
-                    sharedWithUsers: expandedConf.sharedWithUsers, enabled: true,
-                    status: 'disconnected', error: null, tools: [], prompts: [], resources: [],
-                    createTime: Date.now(), config: expandedConf,
+                    name,
+                    owner: expandedConf.owner,
+                    visibility: expandedConf.visibility,
+                    sharedWithUsers: expandedConf.sharedWithUsers,
+                    enabled: true,
+                    status: 'disconnected',
+                    error: null,
+                    tools: [],
+                    prompts: [],
+                    resources: [],
+                    createTime: Date.now(),
+                    config: expandedConf,
                 });
                 continue;
             }
@@ -1952,7 +2029,9 @@ export const getServersInfo = async (page, limit, user) => {
             config: resolvedType || serverConfig?.description || serverConfig?.command
                 ? {
                     ...(resolvedType ? { type: resolvedType } : {}),
-                    ...(hasCredentialTemplate(serverConfig) ? { credentialTemplate: validateCredentialTemplate(serverConfig) } : {}),
+                    ...(hasCredentialTemplate(serverConfig)
+                        ? { credentialTemplate: validateCredentialTemplate(serverConfig) }
+                        : {}),
                     ...(serverConfig?.description ? { description: serverConfig.description } : {}),
                     // Expose command so the frontend can determine if reinstall is
                     // supported (npx/uvx only). This is not a secret — it's the
@@ -2851,17 +2930,7 @@ const projectToolForDownstream = (serverName, tool, appsRouteContext, serverConf
         name: projectNameForGroup(projectedTool.name, serverName, serverConfig),
     };
 };
-const handleListToolsRequestImpl = async (_, extra) => {
-    const sessionId = extra.sessionId || '';
-    const group = getGroup(sessionId);
-    logger.log(`Handling ListToolsRequest for group: ${group}`);
-    // Special handling for $smart group to return smart routing tools
-    // Support both $smart and $smart/{group} patterns
-    if (isSmartRoutingGroup(group)) {
-        return getSmartRoutingTools(group);
-    }
-    const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(group);
-    const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
+const listGroupTools = async (group, filteredServerInfos, serverConfigsByName, appsRouteContext) => {
     // If the startup prime of an on-demand server is still in flight, wait for it
     // so this list reflects the freshly cached tools instead of returning empty.
     // No wake is triggered from list itself; the prime handles that. See #1029.
@@ -2891,8 +2960,60 @@ const handleListToolsRequestImpl = async (_, extra) => {
             }));
         }
     }
+    return allTools;
+};
+// Names the call handler always routes to a meta-tool on a Smart Routing session,
+// whichever of them the current mode lists (see handleCallToolRequestImpl)
+const SMART_ROUTING_META_TOOL_NAMES = new Set(['search_tools', 'describe_tool', 'call_tool']);
+// Tools a $smart/<group> lists next to its meta-tools: each member's pinnedTools,
+// narrowed to its tools selection and then run through the same filtering and
+// projection as a direct group listing.
+const getPinnedSmartRoutingTools = async (group) => {
+    const lookupGroup = getGroupLookupName(group);
+    if (!lookupGroup) {
+        return [];
+    }
+    const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(lookupGroup);
+    const pinnedConfigsByName = new Map();
+    for (const [serverName, serverConfig] of serverConfigsByName) {
+        const selection = serverConfig.tools;
+        const pinnedTools = (serverConfig.pinnedTools ?? []).filter((toolName) => !Array.isArray(selection) || selection.includes(toolName));
+        if (pinnedTools.length > 0) {
+            pinnedConfigsByName.set(serverName, { ...serverConfig, tools: pinnedTools });
+        }
+    }
+    if (pinnedConfigsByName.size === 0) {
+        return [];
+    }
+    return listGroupTools(lookupGroup, filteredServerInfos.filter((serverInfo) => pinnedConfigsByName.has(serverInfo.name)), pinnedConfigsByName, { enabled: false });
+};
+const handleListToolsRequestImpl = async (_, extra) => {
+    const sessionId = extra.sessionId || '';
+    const group = getMcpRequestGroup(extra);
+    logger.log(`Handling ListToolsRequest for group: ${group}`);
+    // Special handling for $smart group to return smart routing tools
+    // Support both $smart and $smart/{group} patterns
+    if (isSmartRoutingGroup(group)) {
+        const smartRoutingTools = await getSmartRoutingTools(group);
+        let pinnedTools = [];
+        try {
+            // A pin named like a meta-tool (e.g. alias "describe" + separator "_" +
+            // tool "tool") would be intercepted by it on call, even in a mode that
+            // does not list that meta-tool, so it is not listed at all
+            pinnedTools = (await getPinnedSmartRoutingTools(group)).filter((tool) => !SMART_ROUTING_META_TOOL_NAMES.has(tool.name));
+        }
+        catch (error) {
+            // Pins are an optimisation: failing to resolve them must not cost the meta-tools
+            logger.warn(`Failed to list pinned tools for ${group}; returning meta-tools only`, error);
+        }
+        return pinnedTools.length > 0
+            ? { tools: [...smartRoutingTools.tools, ...pinnedTools] }
+            : smartRoutingTools;
+    }
+    const { filteredServerInfos, serverConfigsByName } = await getFilteredServerInfosForGroup(group);
+    const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
     return {
-        tools: allTools,
+        tools: await listGroupTools(group, filteredServerInfos, serverConfigsByName, appsRouteContext),
     };
 };
 const handleCallToolRequestImpl = async (request, extra) => {
@@ -2917,7 +3038,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
     ].find((id) => typeof id === 'string' && id.length > 0 && !isSyntheticSessionFallback(id));
     // Extract group and key info from request context (set by SSE/HTTP handlers)
     // Fallback to extra for backward compatibility (e.g., direct API calls)
-    const group = requestContextService.getGroupContext() || extra?.group || getGroup(sessionId) || undefined;
+    const group = getMcpRequestGroup(extra);
     const username = requestContextService.getUsernameContext() ||
         extra?.username ||
         (requestContextService.getKeyKindContext() === 'system' ? 'system' : undefined) ||
@@ -2948,12 +3069,12 @@ const handleCallToolRequestImpl = async (request, extra) => {
         // Special handling for smart routing tools
         if (request.params.name === 'search_tools') {
             const { query, limit = 10 } = request.params.arguments || {};
-            return await handleSearchToolsRequest(query, limit, sessionId);
+            return await handleSearchToolsRequest(query, limit, sessionId, group);
         }
         // Special handling for describe_tool (progressive disclosure mode)
         if (request.params.name === 'describe_tool') {
             const { toolName } = request.params.arguments || {};
-            return await handleDescribeToolRequest(toolName, sessionId);
+            return await handleDescribeToolRequest(toolName, sessionId, group);
         }
         // Special handling for call_tool
         if (request.params.name === 'call_tool') {
@@ -3051,6 +3172,9 @@ const handleCallToolRequestImpl = async (request, extra) => {
                         }
                     }
                 }
+                if (targetServerInfo.config?.openapi?.cookieSession && !cookieSessionId) {
+                    throw new Error(`OpenAPI server '${targetServerInfo.name}' requires cookie-session state and is not yet available on stateless MCP requests`);
+                }
                 await reserveHostedIfNeeded(targetServerInfo.name, cleanToolName);
                 const result = await openApiClient.callTool(cleanToolName, finalArgs, passthroughHeaders, false, cookieSessionId);
                 await settleHostedIfNeeded({
@@ -3095,7 +3219,11 @@ const handleCallToolRequestImpl = async (request, extra) => {
             // Call the tool on the target server (MCP servers)
             // For servers with perSessionClient: true, use a per-session dedicated client
             let isolatedCtx;
-            if (targetServerInfo.config?.perSessionClient && !hasCredentialTemplate(targetServerInfo.config) && sessionId) {
+            if (targetServerInfo.config?.perSessionClient &&
+                !hasCredentialTemplate(targetServerInfo.config)) {
+                if (!sessionId) {
+                    throw new Error(`Server '${targetServerInfo.name}' requires per-session client isolation and is not yet available on stateless MCP requests`);
+                }
                 const isolated = await getOrCreateIsolatedClient(sessionId, targetServerInfo);
                 isolatedCtx = { sessionId, client: isolated.client, transport: isolated.transport };
             }
@@ -3215,6 +3343,9 @@ const handleCallToolRequestImpl = async (request, extra) => {
                 }
             }
             const finalArgs = request.params.arguments || {};
+            if (serverInfo.config?.openapi?.cookieSession && !cookieSessionId) {
+                throw new Error(`OpenAPI server '${serverInfo.name}' requires cookie-session state and is not yet available on stateless MCP requests`);
+            }
             await reserveHostedIfNeeded(serverInfo.name, cleanToolName);
             const result = await openApiClient.callTool(cleanToolName, finalArgs, passthroughHeaders, false, cookieSessionId);
             await settleHostedIfNeeded({
@@ -3259,7 +3390,10 @@ const handleCallToolRequestImpl = async (request, extra) => {
         // Handle MCP servers
         // For servers with perSessionClient: true, use a per-session dedicated client
         let isolatedCtx;
-        if (serverInfo.config?.perSessionClient && !hasCredentialTemplate(serverInfo.config) && sessionId) {
+        if (serverInfo.config?.perSessionClient && !hasCredentialTemplate(serverInfo.config)) {
+            if (!sessionId) {
+                throw new Error(`Server '${serverInfo.name}' requires per-session client isolation and is not yet available on stateless MCP requests`);
+            }
             const isolated = await getOrCreateIsolatedClient(sessionId, serverInfo);
             isolatedCtx = { sessionId, client: isolated.client, transport: isolated.transport };
         }
@@ -3359,8 +3493,7 @@ const handleCallToolRequestImpl = async (request, extra) => {
 const handleGetPromptRequestImpl = async (request, extra) => {
     try {
         const { name, arguments: promptArgs } = request.params;
-        const sessionId = extra?.sessionId || '';
-        const group = extra?.group || getGroup(sessionId) || undefined;
+        const group = getMcpRequestGroup(extra);
         // Check built-in prompts first
         const builtinPrompt = await getBuiltinPromptDao().findByName(name);
         if (builtinPrompt && builtinPrompt.enabled !== false) {
@@ -3446,8 +3579,7 @@ const handleGetPromptRequestImpl = async (request, extra) => {
     }
 };
 const handleListPromptsRequestImpl = async (_, extra) => {
-    const sessionId = extra.sessionId || '';
-    const group = getGroup(sessionId);
+    const group = getMcpRequestGroup(extra);
     const lookupGroup = getGroupLookupName(group);
     logger.log(`Handling ListPromptsRequest for group: ${group}`);
     // Start with built-in prompts (only enabled ones)
@@ -3491,7 +3623,7 @@ const handleListPromptsRequestImpl = async (_, extra) => {
 };
 const handleListResourcesRequestImpl = async (_, extra) => {
     const sessionId = extra.sessionId || '';
-    const group = getGroup(sessionId);
+    const group = getMcpRequestGroup(extra);
     const lookupGroup = getGroupLookupName(group);
     logger.log(`Handling ListResourcesRequest for group: ${group}`);
     const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
@@ -3536,7 +3668,7 @@ const handleListResourcesRequestImpl = async (_, extra) => {
 };
 const handleListResourceTemplatesRequestImpl = async (_, extra) => {
     const sessionId = extra.sessionId || '';
-    const group = getGroup(sessionId);
+    const group = getMcpRequestGroup(extra);
     const lookupGroup = getGroupLookupName(group);
     logger.log(`Handling ListResourceTemplatesRequest for group: ${group}`);
     const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
@@ -3561,7 +3693,7 @@ const handleReadResourceRequestImpl = async (request, extra) => {
     try {
         const { uri } = request.params;
         const sessionId = extra.sessionId || '';
-        const group = getGroup(sessionId);
+        const group = getMcpRequestGroup(extra);
         const lookupGroup = getGroupLookupName(group);
         const appsRouteContext = await getMcpAppsRouteContext(sessionId, group);
         // Check built-in resources first
@@ -3654,7 +3786,9 @@ const handleReadResourceRequestImpl = async (request, extra) => {
         };
     }
 };
-// Personal runtimes never enter serverInfos, config exports, or shared embedding caches.
+// Personal runtimes never enter serverInfos or config exports. Their tool list
+// is added to the rows under the server name, the index the reindex endpoint
+// rebuilds from every binding.
 const createPrincipalRuntime = async (name, resolvedConfig) => {
     const info = {
         name,
@@ -3706,9 +3840,7 @@ const createPrincipalRuntime = async (name, resolvedConfig) => {
             const client = new OpenAPIClient(resolvedConfig);
             await client.initialize();
             info.openApiClient = protectClient(client);
-            info.tools = client
-                .getTools()
-                .map((tool) => ({
+            info.tools = client.getTools().map((tool) => ({
                 ...tool,
                 name: `${name}${getNameSeparator()}${tool.name}`,
                 inputSchema: cleanInputSchema(tool.inputSchema),
@@ -3716,7 +3848,7 @@ const createPrincipalRuntime = async (name, resolvedConfig) => {
         }
         else {
             const transport = await createTransportFromConfig(name, resolvedConfig);
-            const client = new Client({ name: `mcp-client-${name}`, version: '1.0.0' }, {
+            const client = new LegacyMcpClient({ name: `mcp-client-${name}`, version: '1.0.0' }, {
                 capabilities: MCP_APPS_CAPABILITIES,
                 jsonSchemaValidator: new ResilientJsonSchemaValidator(),
             });
@@ -3738,6 +3870,12 @@ const createPrincipalRuntime = async (name, resolvedConfig) => {
             };
         }
         info.status = 'connected';
+        // A credential server never connects globally, so this is the only place
+        // its tools are seen outside a reindex. One user's list is not the whole
+        // server's, so this only adds and refreshes rows; unchanged ones are skipped.
+        syncCredentialServerToolEmbeddings(name, info.tools, { partial: true }).catch(() => {
+            logger.warn(`[EMBED_SYNC_ERROR] Failed to sync tool embeddings for "${name}"`);
+        });
         return info;
     }
     catch (error) {
@@ -3784,19 +3922,14 @@ const withPrincipalServers = (handler, operation) => async (request, extra) => {
         if (builtin && builtin.enabled !== false)
             return handler(request, extra);
     }
-    const group = RequestContextService.getInstance().getGroupContext() ||
-        extra?.group ||
-        getGroup(extra?.sessionId || '') ||
-        undefined;
+    const group = getMcpRequestGroup(extra);
     const { filteredServerInfos: candidates, serverConfigsByName } = await getFilteredServerInfosForGroup(getGroupLookupName(group));
     const requestedName = ['call_tool', 'describe_tool'].includes(request?.params?.name)
         ? request.params.arguments?.toolName
         : request?.params?.name;
     // An explicit REST target takes precedence over every qualified-name prefix.
     // Otherwise prefer the longest exposed prefix, including group aliases.
-    let target = extra?.server
-        ? candidates.find((info) => info.name === extra.server)
-        : undefined;
+    let target = extra?.server ? candidates.find((info) => info.name === extra.server) : undefined;
     if (extra?.server && !target && (operation === 'tool' || operation === 'prompt')) {
         throw new ToolUnavailableError(`Tool not available: ${requestedName}`, 'server-or-name-not-found');
     }
@@ -3898,6 +4031,7 @@ export const createMcpServer = (name, version, options) => {
     }
     // If no group, use default name (global routing)
     const server = new Server({ name: serverName, version }, {
+        supportedProtocolVersions: LEGACY_PROTOCOL_VERSIONS,
         capabilities: {
             tools: { listChanged: true },
             prompts: { listChanged: true },
@@ -3908,13 +4042,13 @@ export const createMcpServer = (name, version, options) => {
             ? { instructions: normalizedOptions.instructions }
             : {}),
     });
-    server.setRequestHandler(ListToolsRequestSchema, handleListToolsRequest);
-    server.setRequestHandler(CallToolRequestSchema, handleCallToolRequest);
-    server.setRequestHandler(GetPromptRequestSchema, handleGetPromptRequest);
-    server.setRequestHandler(ListPromptsRequestSchema, handleListPromptsRequest);
-    server.setRequestHandler(ListResourcesRequestSchema, handleListResourcesRequest);
-    server.setRequestHandler(ListResourceTemplatesRequestSchema, handleListResourceTemplatesRequest);
-    server.setRequestHandler(ReadResourceRequestSchema, handleReadResourceRequest);
+    server.setRequestHandler('tools/list', handleListToolsRequest);
+    server.setRequestHandler('tools/call', handleCallToolRequest);
+    server.setRequestHandler('prompts/get', handleGetPromptRequest);
+    server.setRequestHandler('prompts/list', handleListPromptsRequest);
+    server.setRequestHandler('resources/list', handleListResourcesRequest);
+    server.setRequestHandler('resources/templates/list', handleListResourceTemplatesRequest);
+    server.setRequestHandler('resources/read', handleReadResourceRequest);
     return server;
 };
 export const getFilteredServerInfosForGroup = async (group, options) => {