🔄 refactor: MCP Registry System with Distributed Caching (#10191)

* refactor: Restructure MCP registry system with caching

- Split MCPServersRegistry into modular components:
  - MCPServerInspector: handles server inspection and health checks
  - MCPServersInitializer: manages server initialization logic
  - MCPServersRegistry: simplified registry coordination
- Add distributed caching layer:
  - ServerConfigsCacheRedis: Redis-backed configuration cache
  - ServerConfigsCacheInMemory: in-memory fallback cache
  - RegistryStatusCache: distributed leader election state
- Add promise utilities (withTimeout) replacing Promise.race patterns
- Add comprehensive cache integration tests for all cache implementations
- Remove unused MCPManager.getAllToolFunctions method

* fix: Update OAuth flow to include user-specific headers

* chore: Update Jest configuration to ignore additional test files

- Added patterns to ignore files ending with .helper.ts and .helper.d.ts in testPathIgnorePatterns for cleaner test runs.

* fix: oauth headers in callback

* chore: Update Jest testPathIgnorePatterns to exclude helper files

- Modified testPathIgnorePatterns in package.json to ignore files ending with .helper.ts and .helper.d.ts for cleaner test execution.

* ci: update test mocks

---------

Co-authored-by: Danny Avila <danny@librechat.ai>

packages/api/src/mcp/registry/cache/ServerConfigsCacheInMemory.ts

@@ -0,0 +1,46 @@
+import { ParsedServerConfig } from '~/mcp/types';
+
+/**
+ * In-memory implementation of MCP server configurations cache for single-instance deployments.
+ * Uses a native JavaScript Map for fast, local storage without Redis dependencies.
+ * Suitable for development environments or single-server production deployments.
+ * Does not require leader checks or distributed coordination since data is instance-local.
+ * Data is lost on server restart and not shared across multiple server instances.
+ */
+export class ServerConfigsCacheInMemory {
+  private readonly cache: Map<string, ParsedServerConfig> = new Map();
+
+  public async add(serverName: string, config: ParsedServerConfig): Promise<void> {
+    if (this.cache.has(serverName))
+      throw new Error(
+        `Server "${serverName}" already exists in cache. Use update() to modify existing configs.`,
+      );
+    this.cache.set(serverName, config);
+  }
+
+  public async update(serverName: string, config: ParsedServerConfig): Promise<void> {
+    if (!this.cache.has(serverName))
+      throw new Error(
+        `Server "${serverName}" does not exist in cache. Use add() to create new configs.`,
+      );
+    this.cache.set(serverName, config);
+  }
+
+  public async remove(serverName: string): Promise<void> {
+    if (!this.cache.delete(serverName)) {
+      throw new Error(`Failed to remove server "${serverName}" in cache.`);
+    }
+  }
+
+  public async get(serverName: string): Promise<ParsedServerConfig | undefined> {
+    return this.cache.get(serverName);
+  }
+
+  public async getAll(): Promise<Record<string, ParsedServerConfig>> {
+    return Object.fromEntries(this.cache);
+  }
+
+  public async reset(): Promise<void> {
+    this.cache.clear();
+  }
+}