Merge branch 'fix/oauth-server-instructions'

Signed-off-by: Mohammed Naser <[email protected]>

# Conflicts:
#	client/src/components/Chat/Messages/Content/ToolCall.tsx

Author: mnaser

packages/api/src/mcp/MCPManager.ts

@@ -1,5 +1,6 @@
 import pick from 'lodash/pick';
 import { logger } from '@librechat/data-schemas';
+import { isEnabled } from '~/utils';
 import { CallToolResultSchema, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 import type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { TokenMethods, IUser } from '@librechat/data-schemas';
@@ -118,6 +119,15 @@ export class MCPManager extends UserConnectionManager {
     const configs = await MCPServersRegistry.getInstance().getAllServerConfigs();
     for (const [serverName, config] of Object.entries(configs)) {
       if (config.serverInstructions != null) {
+        // Skip if serverInstructions is true/boolean or "true" string - this means
+        // instructions should be fetched from server but weren't (e.g., OAuth server
+        // that couldn't be connected to at startup)
+        if (isEnabled(config.serverInstructions) && typeof config.serverInstructions !== 'string') {
+          continue;
+        }
+        if (typeof config.serverInstructions === 'string' && config.serverInstructions.toLowerCase().trim() === 'true') {
+          continue;
+        }
         instructions[serverName] = config.serverInstructions as string;
       }
     }

packages/api/src/mcp/UserConnectionManager.ts

@@ -6,6 +6,7 @@ import { MCPConnection } from './connection';
 import type * as t from './types';
 import { ConnectionsRepository } from '~/mcp/ConnectionsRepository';
 import { mcpConfig } from './mcpConfig';
+import { isEnabled } from '~/utils';
 
 /**
  * Abstract base class for managing user-specific MCP connections with lifecycle management.
@@ -143,6 +144,25 @@ export abstract class UserConnectionManager {
       this.userConnections.get(userId)?.set(serverName, connection);
 
       logger.info(`[MCP][User: ${userId}][${serverName}] Connection successfully established`);
+
+      // For OAuth servers, fetch and update serverInstructions if enabled but not yet fetched
+      if (config.requiresOAuth && isEnabled(config.serverInstructions)) {
+        try {
+          const instructions = connection.client.getInstructions();
+          if (instructions && typeof instructions === 'string') {
+            await MCPServersRegistry.getInstance().updateServerInstructions(serverName, instructions);
+            logger.debug(
+              `[MCP][User: ${userId}][${serverName}] Fetched and updated server instructions`,
+            );
+          }
+        } catch (instructionsError) {
+          logger.warn(
+            `[MCP][User: ${userId}][${serverName}] Failed to fetch server instructions:`,
+            instructionsError,
+          );
+        }
+      }
+
       // Update timestamp on creation
       this.updateUserLastActivity(userId);
       return connection;

packages/api/src/mcp/registry/MCPServersRegistry.ts

@@ -182,6 +182,25 @@ export class MCPServersRegistry {
     return parsedConfig;
   }
 
+  /**
+   * Updates the serverInstructions field for a server config.
+   * Used to set instructions fetched from OAuth servers after successful connection.
+   * @param serverName - The name of the server
+   * @param instructions - The instructions string fetched from the server
+   */
+  public async updateServerInstructions(serverName: string, instructions: string): Promise<void> {
+    // Update in cache repository (YAML-defined servers)
+    const configFromCache = await this.cacheConfigsRepo.get(serverName);
+    if (configFromCache) {
+      configFromCache.serverInstructions = instructions;
+      await this.cacheConfigsRepo.update(serverName, configFromCache);
+      // Clear read-through caches to ensure fresh data on next read
+      await this.readThroughCache.clear();
+      await this.readThroughCacheAll.clear();
+      logger.debug(`[MCPServersRegistry] Updated serverInstructions for "${serverName}"`);
+    }
+  }
+
   // TODO: This is currently used to determine if a server requires OAuth. However, this info can
   // can be determined through config.requiresOAuth. Refactor usages and remove this method.
   public async getOAuthServers(userId?: string): Promise<Set<string>> {