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

Co-authored-by: Lia <lia@librechat.ai>
This commit is contained in:
lia-by-librechat[bot] 2026-09-22 06:32:17 -04:00 • committed by GitHub
parent fb0a03f382
commit 453b35dc57
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 175 additions and 20 deletions

View file

@ -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({

View file

@ -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);