Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🫥 fix: Preserve Absent MCP Header Maps Across Database Saves (#16194)

lia-by-librechat[bot]453b35dc5784
diff --git a/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts b/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts
index 4d8917f406..37f1096e3d 100644
--- a/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts
+++ b/packages/api/src/mcp/registry/__tests__/ServerConfigsDB.test.ts
@@ -24,6 +24,7 @@ let MCPOAuthHandler: MCPOAuthHandlerType;
let createModels: CreateModelsType;
let createMethods: CreateMethodsType;
let RoleBits: RoleBitsType;
+let getMCPAppToolsPublicationGeneration: typeof import('~/mcp/toolsChanged').getMCPAppToolsPublicationGeneration;
// Test data helpers
const createSSEConfig = (
@@ -71,6 +72,7 @@ beforeAll(async () => {
ServerConfigsDB = serverConfigsModule.ServerConfigsDB;
const oauthModule = await import('~/mcp/oauth');
MCPOAuthHandler = oauthModule.MCPOAuthHandler;
+ ({ getMCPAppToolsPublicationGeneration } = await import('~/mcp/toolsChanged'));
mongoServer = await MongoMemoryServer.create();
const mongoUri = mongoServer.getUri();
@@ -1046,6 +1048,157 @@ describe('ServerConfigsDB', () => {
});
});
+ describe.each(['sse', 'streamable-http'] as const)('%s header persistence', (type) => {
+ const safeHeaders = { 'X-Safe': 'value', Authorization: 'Bearer {{MCP_API_KEY}}' };
+ const unsafeHeaders = {
+ ...safeHeaders,
+ 'X-Secret': '${SECRET}:{{LIBRECHAT_OPENID_ACCESS_TOKEN}}',
+ };
+ const sanitizedHeaders = { ...safeHeaders, 'X-Secret': ':' };
+
+ it.each([
+ { name: 'omitted', maps: {}, expected: {} },
+ {
+ name: 'explicit undefined',
+ maps: { headers: undefined, requestHeaders: undefined },
+ expected: {},
+ },
+ {
+ name: 'empty',
+ maps: { headers: {}, requestHeaders: {} },
+ expected: { headers: {}, requestHeaders: {} },
+ },
+ {
+ name: 'headers only',
+ maps: { headers: unsafeHeaders },
+ expected: { headers: sanitizedHeaders },
+ },
+ {
+ name: 'requestHeaders only',
+ maps: { requestHeaders: unsafeHeaders },
+ expected: { requestHeaders: sanitizedHeaders },
+ },
+ {
+ name: 'both populated',
+ maps: { headers: unsafeHeaders, requestHeaders: unsafeHeaders },
+ expected: { headers: sanitizedHeaders, requestHeaders: sanitizedHeaders },
+ },
+ ])('preserves $name maps through add, update and upsert', async ({ maps, expected }) => {
+ const config = {
+ type,
+ url: 'https://example.com/mcp',
+ title: 'Header Persistence',
+ requiresOAuth: true,
+ ...maps,
+ } satisfies ParsedServerConfig;
+ const original = structuredClone(config);
+ const created = await serverConfigsDB.add('temp-name', config, userId);
+ const assertRoundTrip = async (minimized = false) => {
+ const stored = await mongoose.models.MCPServer.collection.findOne({
+ serverName: created.serverName,
+ });
+ const result = await serverConfigsDB.get(created.serverName, userId);
+ const all = await serverConfigsDB.getAll(userId);
+ expect(result).toBeDefined();
+ for (const key of ['headers', 'requestHeaders'] as const) {
+ const value = expected[key];
+ if (value != null && (!minimized || Object.keys(value).length > 0)) {
+ expect(stored?.config[key]).toEqual(value);
+ expect(result).toHaveProperty(key, expected[key]);
+ } else {
+ expect(stored?.config).not.toHaveProperty(key);
+ expect(result).not.toHaveProperty(key);
+ }
+ }
+ expect(all[created.serverName]).toEqual(result);
+ expect(MCPOptionsSchema.safeParse(result).success).toBe(true);
+ expect(() => getMCPAppToolsPublicationGeneration(result!)).not.toThrow();
+ };
+
+ /** Mongoose minimizes empty objects on create, but preserves them on update. */
+ await assertRoundTrip(true);
+ for (const method of ['update', 'upsert'] as const) {
+ await serverConfigsDB.update(
+ created.serverName,
+ {
+ ...config,
+ headers: { 'X-Old': 'remove me' },
+ requestHeaders: { 'X-Old': 'remove me too' },
+ },
+ userId,
+ );
+ await serverConfigsDB[method](created.serverName, config, userId);
+ await assertRoundTrip();
+ }
+ expect(config).toEqual(original);
+ });
+
+ it.each([
+ { name: 'headers null', maps: { headers: null }, expected: {} },
+ { name: 'requestHeaders null', maps: { requestHeaders: null }, expected: {} },
+ { name: 'both null', maps: { headers: null, requestHeaders: null }, expected: {} },
+ {
+ name: 'headers null with request headers',
+ maps: { headers: null, requestHeaders: safeHeaders },
+ expected: { requestHeaders: safeHeaders },
+ },
+ {
+ name: 'requestHeaders null with headers',
+ maps: { headers: safeHeaders, requestHeaders: null },
+ expected: { headers: safeHeaders },
+ },
+ {
+ name: 'headers null with empty request headers',
+ maps: { headers: null, requestHeaders: {} },
+ expected: { requestHeaders: {} },
+ },
+ {
+ name: 'requestHeaders null with empty headers',
+ maps: { headers: {}, requestHeaders: null },
+ expected: { headers: {} },
+ },
+ ])('normalizes historical $name on single and bulk reads', async ({ maps, expected }) => {
+ const created = await serverConfigsDB.add(
+ 'temp-name',
+ {
+ type,
+ url: 'https://example.com/mcp',
+ title: 'Historical Headers',
+ requiresOAuth: true,
+ },
+ userId,
+ );
+ await mongoose.models.MCPServer.collection.updateOne(
+ { serverName: created.serverName },
+ {
+ $set: { config: { type, url: 'https://example.com/mcp', requiresOAuth: true, ...maps } },
+ },
+ );
+ const stored = await mongoose.models.MCPServer.collection.findOne({
+ serverName: created.serverName,
+ });
+ expect(MCPOptionsSchema.safeParse(stored?.config).success).toBe(false);
+
+ const result = await serverConfigsDB.get(created.serverName, userId);
+ const all = await serverConfigsDB.getAll(userId);
+ expect(result).toBeDefined();
+ for (const key of ['headers', 'requestHeaders'] as const) {
+ if (expected[key] != null) {
+ expect(result).toHaveProperty(key, expected[key]);
+ } else {
+ expect(result).not.toHaveProperty(key);
+ }
+ }
+ expect(all[created.serverName]).toEqual(result);
+ expect(MCPOptionsSchema.safeParse(result).success).toBe(true);
+ const generation = getMCPAppToolsPublicationGeneration(result!);
+ expect(getMCPAppToolsPublicationGeneration(all[created.serverName])).toBe(generation);
+ expect(
+ await mongoose.models.MCPServer.collection.findOne({ serverName: created.serverName }),
+ ).toEqual(stored);
+ });
+ });
+
describe('get()', () => {
it('normalizes null headers from historical stored configs before runtime use', async () => {
const server = await mongoose.models.MCPServer.create({
diff --git a/packages/api/src/mcp/registry/db/ServerConfigsDB.ts b/packages/api/src/mcp/registry/db/ServerConfigsDB.ts
index 383b6a654b..109d0572c1 100644
--- a/packages/api/src/mcp/registry/db/ServerConfigsDB.ts
+++ b/packages/api/src/mcp/registry/db/ServerConfigsDB.ts
@@ -62,20 +62,21 @@ function sanitizeCredentialPlaceholders(
* Sanitizes every header map a shared config carries. `requestHeaders` is
* included because it reaches the upstream server exactly like `headers` does:
* left unsanitized, a user-managed config could name a privileged placeholder
- * there and have the runtime resolve it at chat time.
+ * there and have the runtime resolve it at chat time. Absent maps stay omitted
+ * because BSON can serialize explicit undefined properties as null.
*/
-function sanitizeConfigHeaderMaps(config: ParsedServerConfig): {
- headers?: Record<string, string>;
- requestHeaders?: Record<string, string>;
-} {
- const carrier = config as ParsedServerConfig & {
+function sanitizeConfigHeaderMaps(config: ParsedServerConfig): ParsedServerConfig {
+ const { headers, requestHeaders, ...rest } = config as ParsedServerConfig & {
headers?: Record<string, string>;
requestHeaders?: Record<string, string>;
};
return {
- headers: sanitizeCredentialPlaceholders(carrier.headers),
- requestHeaders: sanitizeCredentialPlaceholders(carrier.requestHeaders),
- };
+ ...rest,
+ ...(headers != null && { headers: sanitizeCredentialPlaceholders(headers) }),
+ ...(requestHeaders != null && {
+ requestHeaders: sanitizeCredentialPlaceholders(requestHeaders),
+ }),
+ } as ParsedServerConfig;
}
function stripBlockedOAuthEndpointParams(url?: string): string | undefined {
@@ -121,13 +122,18 @@ function sanitizeUserManagedOAuthConfig(config: ParsedServerConfig): ParsedServe
function normalizePersistedConfig(config: ParsedServerConfig): ParsedServerConfig {
const persistedConfig = config as ParsedServerConfig & {
headers?: Record<string, string> | null;
+ requestHeaders?: Record<string, string> | null;
};
- if (persistedConfig.headers !== null) {
+ if (persistedConfig.headers !== null && persistedConfig.requestHeaders !== null) {
return config;
}
- const { headers: _legacyNullHeaders, ...normalizedConfig } = persistedConfig;
- return normalizedConfig as ParsedServerConfig;
+ const { headers, requestHeaders, ...rest } = persistedConfig;
+ return {
+ ...rest,
+ ...(headers != null && { headers }),
+ ...(requestHeaders != null && { requestHeaders }),
+ } as ParsedServerConfig;
}
function normalizeOAuthUrl(value?: string): string | undefined {
@@ -315,10 +321,7 @@ export class ServerConfigsDB implements IServerConfigsRepositoryInterface {
);
}
- const sanitizedConfig = sanitizeUserManagedOAuthConfig({
- ...config,
- ...sanitizeConfigHeaderMaps(config),
- } as ParsedServerConfig);
+ const sanitizedConfig = sanitizeUserManagedOAuthConfig(sanitizeConfigHeaderMaps(config));
/** Transformed user-provided API key config (adds customUserVars and headers) */
const transformedConfig = this.transformUserApiKeyConfig(sanitizedConfig);
@@ -366,10 +369,9 @@ export class ServerConfigsDB implements IServerConfigsRepositoryInterface {
requireApiKeyReentryForRebinding(existingServer.config, config);
}
- let configToSave: ParsedServerConfig = sanitizeUserManagedOAuthConfig({
- ...config,
- ...sanitizeConfigHeaderMaps(config),
- } as ParsedServerConfig);
+ let configToSave: ParsedServerConfig = sanitizeUserManagedOAuthConfig(
+ sanitizeConfigHeaderMaps(config),
+ );
/** Transformed user-provided API key config (adds customUserVars and headers) */
configToSave = this.transformUserApiKeyConfig(configToSave);