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

🚫 refactor: Remove Interface Config from Override Processing (#12473)

Danny Avilac0ce7fee919d
diff --git a/packages/api/src/admin/config.handler.spec.ts b/packages/api/src/admin/config.handler.spec.ts
index 708d114e72..bd1664fc90 100644
--- a/packages/api/src/admin/config.handler.spec.ts
+++ b/packages/api/src/admin/config.handler.spec.ts
@@ -48,7 +48,7 @@ function createHandlers(overrides = {}) {
}),
patchConfigFields: jest
.fn()
- .mockResolvedValue({ _id: 'c1', overrides: { interface: { endpointsMenu: false } } }),
+ .mockResolvedValue({ _id: 'c1', overrides: { registration: { enabled: false } } }),
unsetConfigField: jest.fn().mockResolvedValue({ _id: 'c1', overrides: {} }),
deleteConfig: jest.fn().mockResolvedValue({ _id: 'c1' }),
toggleConfigActive: jest.fn().mockResolvedValue({ _id: 'c1', isActive: false }),
@@ -169,6 +169,93 @@ describe('createAdminConfigHandlers', () => {
expect(res.statusCode).toBe(400);
});
+
+ it('strips permission fields from interface overrides but keeps UI fields', async () => {
+ const { handlers, deps } = createHandlers({
+ upsertConfig: jest.fn().mockResolvedValue({ _id: 'c1', configVersion: 1 }),
+ });
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: {
+ overrides: {
+ interface: { endpointsMenu: false, prompts: false, agents: { use: false } },
+ },
+ },
+ });
+ const res = mockRes();
+
+ await handlers.upsertConfigOverrides(req, res);
+
+ expect(res.statusCode).toBe(201);
+ const savedOverrides = deps.upsertConfig.mock.calls[0][3];
+ expect(savedOverrides.interface).toEqual({ endpointsMenu: false });
+ });
+
+ it('preserves UI sub-keys in composite permission fields like mcpServers', async () => {
+ const { handlers, deps } = createHandlers({
+ upsertConfig: jest.fn().mockResolvedValue({ _id: 'c1', configVersion: 1 }),
+ });
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: {
+ overrides: {
+ interface: {
+ mcpServers: {
+ use: true,
+ create: false,
+ placeholder: 'Search MCP...',
+ trustCheckbox: { label: 'Trust' },
+ },
+ },
+ },
+ },
+ });
+ const res = mockRes();
+
+ await handlers.upsertConfigOverrides(req, res);
+
+ expect(res.statusCode).toBe(201);
+ const savedOverrides = deps.upsertConfig.mock.calls[0][3];
+ const mcp = (savedOverrides as Record<string, unknown>).interface as Record<string, unknown>;
+ expect((mcp.mcpServers as Record<string, unknown>).placeholder).toBe('Search MCP...');
+ expect((mcp.mcpServers as Record<string, unknown>).trustCheckbox).toEqual({ label: 'Trust' });
+ expect((mcp.mcpServers as Record<string, unknown>).use).toBeUndefined();
+ expect((mcp.mcpServers as Record<string, unknown>).create).toBeUndefined();
+ });
+
+ it('strips peoplePicker permission sub-keys in upsert', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: {
+ overrides: {
+ interface: { peoplePicker: { users: false, groups: true, roles: true } },
+ },
+ },
+ });
+ const res = mockRes();
+
+ await handlers.upsertConfigOverrides(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(res.body!.message).toBeDefined();
+ expect(deps.upsertConfig).not.toHaveBeenCalled();
+ });
+
+ it('returns 200 with message when only permission fields in interface', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: { overrides: { interface: { prompts: false, agents: false } } },
+ });
+ const res = mockRes();
+
+ await handlers.upsertConfigOverrides(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(res.body!.message).toBeDefined();
+ expect(deps.upsertConfig).not.toHaveBeenCalled();
+ });
});
describe('deleteConfigField', () => {
@@ -189,6 +276,87 @@ describe('createAdminConfigHandlers', () => {
);
});
+ it('allows deleting mcpServers UI sub-key paths', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ query: { fieldPath: 'interface.mcpServers.placeholder' },
+ });
+ const res = mockRes();
+
+ await handlers.deleteConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(deps.unsetConfigField).toHaveBeenCalledWith(
+ 'role',
+ 'admin',
+ 'interface.mcpServers.placeholder',
+ );
+ });
+
+ it('blocks deleting mcpServers permission sub-key paths', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ query: { fieldPath: 'interface.mcpServers.use' },
+ });
+ const res = mockRes();
+
+ await handlers.deleteConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(res.body!.message).toBeDefined();
+ expect(deps.unsetConfigField).not.toHaveBeenCalled();
+ });
+
+ it('blocks deleting peoplePicker permission sub-key paths', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ query: { fieldPath: 'interface.peoplePicker.users' },
+ });
+ const res = mockRes();
+
+ await handlers.deleteConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(res.body!.message).toBeDefined();
+ expect(deps.unsetConfigField).not.toHaveBeenCalled();
+ });
+
+ it('returns 200 no-op for interface permission field path', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ query: { fieldPath: 'interface.prompts' },
+ });
+ const res = mockRes();
+
+ await handlers.deleteConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(res.body!.message).toBeDefined();
+ expect(deps.unsetConfigField).not.toHaveBeenCalled();
+ });
+
+ it('allows deleting interface UI field paths', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ query: { fieldPath: 'interface.endpointsMenu' },
+ });
+ const res = mockRes();
+
+ await handlers.deleteConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(deps.unsetConfigField).toHaveBeenCalledWith(
+ 'role',
+ 'admin',
+ 'interface.endpointsMenu',
+ );
+ });
+
it('returns 400 when fieldPath query param is missing', async () => {
const { handlers } = createHandlers();
const req = mockReq({
@@ -224,7 +392,110 @@ describe('createAdminConfigHandlers', () => {
});
const req = mockReq({
params: { principalType: 'role', principalId: 'admin' },
- body: { entries: [{ fieldPath: 'interface.endpointsMenu', value: false }] },
+ body: { entries: [{ fieldPath: 'registration.enabled', value: false }] },
+ });
+ const res = mockRes();
+
+ await handlers.patchConfigField(req, res);
+
+ expect(res.statusCode).toBe(403);
+ });
+
+ it('strips interface permission field entries but keeps UI field entries', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: {
+ entries: [
+ { fieldPath: 'interface.endpointsMenu', value: false },
+ { fieldPath: 'interface.prompts', value: false },
+ ],
+ },
+ });
+ const res = mockRes();
+
+ await handlers.patchConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ const patchedFields = deps.patchConfigFields.mock.calls[0][3];
+ expect(patchedFields['interface.endpointsMenu']).toBe(false);
+ expect(patchedFields['interface.prompts']).toBeUndefined();
+ });
+
+ it('blocks peoplePicker permission sub-key paths', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: {
+ entries: [{ fieldPath: 'interface.peoplePicker.users', value: false }],
+ },
+ });
+ const res = mockRes();
+
+ await handlers.patchConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(res.body!.message).toBeDefined();
+ expect(deps.patchConfigFields).not.toHaveBeenCalled();
+ });
+
+ it('allows mcpServers UI sub-key paths but blocks permission sub-key paths', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: {
+ entries: [
+ { fieldPath: 'interface.mcpServers.placeholder', value: 'Search...' },
+ { fieldPath: 'interface.mcpServers.use', value: true },
+ ],
+ },
+ });
+ const res = mockRes();
+
+ await handlers.patchConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ const patchedFields = deps.patchConfigFields.mock.calls[0][3];
+ expect(patchedFields['interface.mcpServers.placeholder']).toBe('Search...');
+ expect(patchedFields['interface.mcpServers.use']).toBeUndefined();
+ });
+
+ it('returns 200 with message when all entries are permission fields', async () => {
+ const { handlers, deps } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: { entries: [{ fieldPath: 'interface.prompts', value: false }] },
+ });
+ const res = mockRes();
+
+ await handlers.patchConfigField(req, res);
+
+ expect(res.statusCode).toBe(200);
+ expect(res.body!.message).toBeDefined();
+ expect(deps.patchConfigFields).not.toHaveBeenCalled();
+ });
+
+ it('returns 401 when unauthenticated even if all entries are permission fields', async () => {
+ const { handlers } = createHandlers();
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: { entries: [{ fieldPath: 'interface.prompts', value: false }] },
+ user: undefined,
+ });
+ const res = mockRes();
+
+ await handlers.patchConfigField(req, res);
+
+ expect(res.statusCode).toBe(401);
+ });
+
+ it('returns 403 when unauthorized even if all entries are permission fields', async () => {
+ const { handlers } = createHandlers({
+ hasConfigCapability: jest.fn().mockResolvedValue(false),
+ });
+ const req = mockReq({
+ params: { principalType: 'role', principalId: 'admin' },
+ body: { entries: [{ fieldPath: 'interface.prompts', value: false }] },
});
const res = mockRes();
diff --git a/packages/api/src/admin/config.ts b/packages/api/src/admin/config.ts
index b2afd9c69b..cca2d9901c 100644
--- a/packages/api/src/admin/config.ts
+++ b/packages/api/src/admin/config.ts
@@ -1,5 +1,10 @@
import { logger } from '@librechat/data-schemas';
-import { PrincipalType, PrincipalModel } from 'librechat-data-provider';
+import {
+ PrincipalType,
+ PrincipalModel,
+ INTERFACE_PERMISSION_FIELDS,
+ PERMISSION_SUB_KEYS,
+} from 'librechat-data-provider';
import type { TCustomConfig } from 'librechat-data-provider';
import type { AppConfig, ConfigSection, IConfig } from '@librechat/data-schemas';
import type { Types, ClientSession } from 'mongoose';
@@ -26,6 +31,33 @@ export function getTopLevelSection(fieldPath: string): string {
return fieldPath.split('.')[0];
}
+/**
+ * Returns true if `fieldPath` targets an interface permission field or permission sub-key.
+ *
+ * - `"interface.prompts"` → true (boolean permission field)
+ * - `"interface.agents.use"` → true (permission sub-key)
+ * - `"interface.mcpServers"` → true (entire composite field)
+ * - `"interface.mcpServers.use"` → true (permission sub-key)
+ * - `"interface.mcpServers.placeholder"` → false (UI-only sub-key)
+ * - `"interface.peoplePicker.users"` → true (all peoplePicker sub-keys are permissions)
+ * - `"interface.endpointsMenu"` → false (UI-only field)
+ */
+function isInterfacePermissionPath(fieldPath: string): boolean {
+ const parts = fieldPath.split('.');
+ if (parts[0] !== 'interface' || parts.length < 2) {
+ return false;
+ }
+ if (!INTERFACE_PERMISSION_FIELDS.has(parts[1])) {
+ return false;
+ }
+ // "interface.<permField>" with no sub-key → permission (blocks the whole field)
+ if (parts.length === 2) {
+ return true;
+ }
+ // "interface.<permField>.<subKey>" → only block if sub-key is a permission bit
+ return PERMISSION_SUB_KEYS.has(parts[2]);
+}
+
export interface AdminConfigDeps {
listAllConfigs: (filter?: { isActive?: boolean }, session?: ClientSession) => Promise<IConfig[]>;
findConfigByPrincipal: (
@@ -262,24 +294,64 @@ export function createAdminConfigHandlers(deps: AdminConfigDeps) {
return res.status(403).json({ error: 'Insufficient permissions' });
}
- const overrideSections = Object.keys(overrides);
- if (overrideSections.length > 0) {
- const allowed = await Promise.all(
- overrideSections.map((s) => hasConfigCapability(user, s as ConfigSection, 'manage')),
- );
- const denied = overrideSections.find((_, i) => !allowed[i]);
- if (denied) {
- return res.status(403).json({
- error: `Insufficient permissions for config section: ${denied}`,
- });
+ let filteredOverrides = overrides;
+ const iface = (overrides as Record<string, unknown>).interface;
+ if (iface != null && typeof iface === 'object' && !Array.isArray(iface)) {
+ const filteredIface: Record<string, unknown> = {};
+ for (const [field, val] of Object.entries(iface as Record<string, unknown>)) {
+ if (!INTERFACE_PERMISSION_FIELDS.has(field)) {
+ filteredIface[field] = val;
+ } else if (val != null && typeof val === 'object' && !Array.isArray(val)) {
+ // Composite permission field (e.g. mcpServers): strip permission
+ // sub-keys but preserve UI-only sub-keys like placeholder/trustCheckbox.
+ const uiOnly: Record<string, unknown> = {};
+ for (const [sub, subVal] of Object.entries(val as Record<string, unknown>)) {
+ if (!PERMISSION_SUB_KEYS.has(sub)) {
+ uiOnly[sub] = subVal;
+ } else {
+ logger.warn(
+ `[adminConfig] Stripping interface permission sub-field "${field}.${sub}" — use role permissions instead`,
+ );
+ }
+ }
+ if (Object.keys(uiOnly).length > 0) {
+ filteredIface[field] = uiOnly;
+ }
+ } else {
+ logger.warn(
+ `[adminConfig] Stripping interface permission field "${field}" — use role permissions instead`,
+ );
+ }
+ }
+ filteredOverrides = { ...(overrides as Record<string, unknown>) } as Partial<TCustomConfig>;
+ if (Object.keys(filteredIface).length > 0) {
+ (filteredOverrides as Record<string, unknown>).interface = filteredIface;
+ } else {
+ delete (filteredOverrides as Record<string, unknown>).interface;
}
}
+ const overrideSections = Object.keys(filteredOverrides);
+
+ if (overrideSections.length === 0) {
+ return res.status(200).json({ message: 'No actionable override sections provided' });
+ }
+
+ const allowed = await Promise.all(
+ overrideSections.map((s) => hasConfigCapability(user, s as ConfigSection, 'manage')),
+ );
+ const denied = overrideSections.find((_, i) => !allowed[i]);
+ if (denied) {
+ return res.status(403).json({
+ error: `Insufficient permissions for config section: ${denied}`,
+ });
+ }
+
const config = await upsertConfig(
principalType,
principalId,
principalModel(principalType),
- overrides,
+ filteredOverrides,
priority ?? DEFAULT_PRIORITY,
);
@@ -339,8 +411,25 @@ export function createAdminConfigHandlers(deps: AdminConfigDeps) {
return res.status(401).json({ error: 'Authentication required' });
}
+ const validEntries = entries.filter((entry) => {
+ if (isInterfacePermissionPath(entry.fieldPath)) {
+ logger.warn(
+ `[adminConfig] Stripping interface permission field "${entry.fieldPath}" — use role permissions instead`,
+ );
+ return false;
+ }
+ return true;
+ });
+
+ if (validEntries.length === 0) {
+ if (!(await hasConfigCapability(user, null, 'manage'))) {
+ return res.status(403).json({ error: 'Insufficient permissions' });
+ }
+ return res.status(200).json({ message: 'No actionable field entries provided' });
+ }
+
if (!(await hasConfigCapability(user, null, 'manage'))) {
- const sections = [...new Set(entries.map((e) => getTopLevelSection(e.fieldPath)))];
+ const sections = [...new Set(validEntries.map((e) => getTopLevelSection(e.fieldPath)))];
const allowed = await Promise.all(
sections.map((s) => hasConfigCapability(user, s as ConfigSection, 'manage')),
);
@@ -354,7 +443,7 @@ export function createAdminConfigHandlers(deps: AdminConfigDeps) {
const seen = new Set<string>();
const fields: Record<string, unknown> = {};
- for (const entry of entries) {
+ for (const entry of validEntries) {
if (seen.has(entry.fieldPath)) {
return res.status(400).json({ error: `Duplicate fieldPath: ${entry.fieldPath}` });
}
@@ -414,12 +503,20 @@ export function createAdminConfigHandlers(deps: AdminConfigDeps) {
}
const section = getTopLevelSection(fieldPath);
+
if (!(await hasConfigCapability(user, section as ConfigSection, 'manage'))) {
return res.status(403).json({
error: `Insufficient permissions for config section: ${section}`,
});
}
+ if (isInterfacePermissionPath(fieldPath)) {
+ logger.warn(
+ `[adminConfig] Ignoring delete for interface permission field "${fieldPath}" — use role permissions instead`,
+ );
+ return res.status(200).json({ message: 'No actionable field path provided' });
+ }
+
const config = await unsetConfigField(principalType, principalId, fieldPath);
if (!config) {
return res.status(404).json({ error: 'Config not found' });
diff --git a/packages/data-provider/package.json b/packages/data-provider/package.json
index 0cbe9258f2..4a62f898c8 100644
--- a/packages/data-provider/package.json
+++ b/packages/data-provider/package.json
@@ -1,6 +1,6 @@
{
"name": "librechat-data-provider",
- "version": "0.8.405",
+ "version": "0.8.406",
"description": "data services for librechat apps",
"main": "dist/index.js",
"module": "dist/index.es.js",
diff --git a/packages/data-provider/src/permissions.ts b/packages/data-provider/src/permissions.ts
index 7a3144c82d..58cf0df15d 100644
--- a/packages/data-provider/src/permissions.ts
+++ b/packages/data-provider/src/permissions.ts
@@ -62,6 +62,55 @@ export enum PermissionTypes {
REMOTE_AGENTS = 'REMOTE_AGENTS',
}
+/**
+ * Maps PermissionTypes to their corresponding `interface` config field names.
+ * Used to identify which interface fields seed role permissions at startup
+ * and must NOT be overridden via DB config (use the role permissions editor instead).
+ */
+export const PERMISSION_TYPE_INTERFACE_FIELDS: Record<PermissionTypes, string> = {
+ [PermissionTypes.PROMPTS]: 'prompts',
+ [PermissionTypes.AGENTS]: 'agents',
+ [PermissionTypes.BOOKMARKS]: 'bookmarks',
+ [PermissionTypes.MEMORIES]: 'memories',
+ [PermissionTypes.MULTI_CONVO]: 'multiConvo',
+ [PermissionTypes.TEMPORARY_CHAT]: 'temporaryChat',
+ [PermissionTypes.RUN_CODE]: 'runCode',
+ [PermissionTypes.WEB_SEARCH]: 'webSearch',
+ [PermissionTypes.FILE_SEARCH]: 'fileSearch',
+ [PermissionTypes.FILE_CITATIONS]: 'fileCitations',
+ [PermissionTypes.PEOPLE_PICKER]: 'peoplePicker',
+ [PermissionTypes.MARKETPLACE]: 'marketplace',
+ [PermissionTypes.MCP_SERVERS]: 'mcpServers',
+ [PermissionTypes.REMOTE_AGENTS]: 'remoteAgents',
+};
+
+/** Set of interface config field names that correspond to role permissions. */
+export const INTERFACE_PERMISSION_FIELDS = new Set(Object.values(PERMISSION_TYPE_INTERFACE_FIELDS));
+
+/**
+ * YAML sub-keys within composite interface permission fields that map to permission bits.
+ * When an interface permission field is an object, only these sub-keys are stripped from
+ * DB overrides — other sub-keys (like `placeholder`, `trustCheckbox`) are UI-only and pass through.
+ *
+ * Mapping to Permissions enum:
+ * 'use' → Permissions.USE (agents, prompts, mcpServers, remoteAgents, marketplace)
+ * 'create' → Permissions.CREATE (agents, prompts, mcpServers, remoteAgents)
+ * 'share' → Permissions.SHARE (agents, prompts, mcpServers, remoteAgents)
+ * 'public' → Permissions.SHARE_PUBLIC (agents, prompts, mcpServers, remoteAgents)
+ * 'users' → Permissions.VIEW_USERS (peoplePicker only)
+ * 'groups' → Permissions.VIEW_GROUPS (peoplePicker only)
+ * 'roles' → Permissions.VIEW_ROLES (peoplePicker only)
+ */
+export const PERMISSION_SUB_KEYS = new Set([
+ 'use',
+ 'create',
+ 'share',
+ 'public',
+ 'users',
+ 'groups',
+ 'roles',
+]);
+
/**
* Enum for Role-Based Access Control Constants
*/
diff --git a/packages/data-schemas/package.json b/packages/data-schemas/package.json
index 145b8925d1..652c4e0867 100644
--- a/packages/data-schemas/package.json
+++ b/packages/data-schemas/package.json
@@ -1,6 +1,6 @@
{
"name": "@librechat/data-schemas",
- "version": "0.0.47",
+ "version": "0.0.48",
"description": "Mongoose schemas and models for LibreChat",
"type": "module",
"main": "dist/index.cjs",
diff --git a/packages/data-schemas/src/app/resolution.spec.ts b/packages/data-schemas/src/app/resolution.spec.ts
index b37ff25e3a..991f6afb40 100644
--- a/packages/data-schemas/src/app/resolution.spec.ts
+++ b/packages/data-schemas/src/app/resolution.spec.ts
@@ -1,3 +1,4 @@
+import { INTERFACE_PERMISSION_FIELDS, PermissionTypes } from 'librechat-data-provider';
import { mergeConfigOverrides } from './resolution';
import type { AppConfig, IConfig } from '~/types';
@@ -30,7 +31,7 @@ describe('mergeConfigOverrides', () => {
expect(mergeConfigOverrides(baseConfig, undefined as unknown as IConfig[])).toBe(baseConfig);
});
- it('deep merges a single override into base', () => {
+ it('deep merges interface UI fields into interfaceConfig', () => {
const configs = [fakeConfig({ interface: { endpointsMenu: false } }, 10)];
const result = mergeConfigOverrides(baseConfig, configs) as unknown as Record<string, unknown>;
const iface = result.interfaceConfig as Record<string, unknown>;
@@ -134,6 +135,104 @@ describe('mergeConfigOverrides', () => {
expect(result.turnstile).toBeUndefined();
});
+ it('strips interface permission fields from overrides', () => {
+ const base = {
+ interfaceConfig: { endpointsMenu: true, sidePanel: true },
+ } as unknown as AppConfig;
+
+ const configs = [
+ fakeConfig(
+ {
+ interface: {
+ endpointsMenu: false,
+ prompts: false,
+ agents: { use: false },
+ marketplace: { use: false },
+ },
+ },
+ 10,
+ ),
+ ];
+ const result = mergeConfigOverrides(base, configs) as unknown as Record<string, unknown>;
+ const iface = result.interfaceConfig as Record<string, unknown>;
+
+ // UI field should be merged
+ expect(iface.endpointsMenu).toBe(false);
+ // Boolean permission fields should be stripped
+ expect(iface.prompts).toBeUndefined();
+ // Object permission fields with only permission sub-keys should be stripped
+ expect(iface.agents).toBeUndefined();
+ expect(iface.marketplace).toBeUndefined();
+ // Untouched base field preserved
+ expect(iface.sidePanel).toBe(true);
+ });
+
+ it('preserves UI sub-keys in composite permission fields like mcpServers', () => {
+ const base = {
+ interfaceConfig: {},
+ } as unknown as AppConfig;
+
+ const configs = [
+ fakeConfig(
+ {
+ interface: {
+ mcpServers: {
+ use: true,
+ create: false,
+ share: false,
+ public: false,
+ placeholder: 'Search MCP servers...',
+ trustCheckbox: { label: 'I trust this server' },
+ },
+ },
+ },
+ 10,
+ ),
+ ];
+ const result = mergeConfigOverrides(base, configs) as unknown as Record<string, unknown>;
+ const iface = result.interfaceConfig as Record<string, unknown>;
+ const mcp = iface.mcpServers as Record<string, unknown>;
+
+ // UI sub-keys preserved
+ expect(mcp.placeholder).toBe('Search MCP servers...');
+ expect(mcp.trustCheckbox).toEqual({ label: 'I trust this server' });
+ // Permission sub-keys stripped
+ expect(mcp.use).toBeUndefined();
+ expect(mcp.create).toBeUndefined();
+ expect(mcp.share).toBeUndefined();
+ expect(mcp.public).toBeUndefined();
+ });
+
+ it('strips peoplePicker permission sub-keys (users, groups, roles)', () => {
+ const base = {
+ interfaceConfig: {},
+ } as unknown as AppConfig;
+
+ const configs = [
+ fakeConfig({ interface: { peoplePicker: { users: false, groups: true, roles: true } } }, 10),
+ ];
+ const result = mergeConfigOverrides(base, configs) as unknown as Record<string, unknown>;
+ const iface = result.interfaceConfig as Record<string, unknown>;
+
+ // All sub-keys are permission bits → entire field stripped
+ expect(iface.peoplePicker).toBeUndefined();
+ });
+
+ it('drops interface entirely when only permission fields are present', () => {
+ const base = {
+ interfaceConfig: { endpointsMenu: true },
+ } as unknown as AppConfig;
+
+ const configs = [fakeConfig({ interface: { prompts: false, agents: false } }, 10)];
+ const result = mergeConfigOverrides(base, configs) as unknown as Record<string, unknown>;
+ const iface = result.interfaceConfig as Record<string, unknown>;
+
+ // Base should be unchanged
+ expect(iface.endpointsMenu).toBe(true);
+ expect(iface.prompts).toBeUndefined();
+ expect(iface.agents).toBeUndefined();
+ });
+
it('remaps YAML-level keys to AppConfig equivalents', () => {
const configs = [
fakeConfig(
@@ -153,3 +252,38 @@ describe('mergeConfigOverrides', () => {
expect(result.mcpServers).toBeUndefined();
});
});
+
+describe('INTERFACE_PERMISSION_FIELDS', () => {
+ it('contains all expected permission fields', () => {
+ const expected = [
+ 'prompts',
+ 'agents',
+ 'bookmarks',
+ 'memories',
+ 'multiConvo',
+ 'temporaryChat',
+ 'runCode',
+ 'webSearch',
+ 'fileSearch',
+ 'fileCitations',
+ 'peoplePicker',
+ 'marketplace',
+ 'mcpServers',
+ 'remoteAgents',
+ ];
+ for (const field of expected) {
+ expect(INTERFACE_PERMISSION_FIELDS.has(field)).toBe(true);
+ }
+ });
+
+ it('has one entry per PermissionType — no duplicates or missing', () => {
+ expect(INTERFACE_PERMISSION_FIELDS.size).toBe(Object.values(PermissionTypes).length);
+ });
+
+ it('does not contain UI-only fields', () => {
+ const uiFields = ['endpointsMenu', 'modelSelect', 'parameters', 'presets', 'sidePanel'];
+ for (const field of uiFields) {
+ expect(INTERFACE_PERMISSION_FIELDS.has(field)).toBe(false);
+ }
+ });
+});
diff --git a/packages/data-schemas/src/app/resolution.ts b/packages/data-schemas/src/app/resolution.ts
index be35a1d706..08b4d1b12d 100644
--- a/packages/data-schemas/src/app/resolution.ts
+++ b/packages/data-schemas/src/app/resolution.ts
@@ -1,3 +1,4 @@
+import { INTERFACE_PERMISSION_FIELDS, PERMISSION_SUB_KEYS } from 'librechat-data-provider';
import type { TCustomConfig } from 'librechat-data-provider';
import type { AppConfig, IConfig } from '~/types';
@@ -65,7 +66,42 @@ export function mergeConfigOverrides(baseConfig: AppConfig, configs: IConfig[]):
if (config.overrides && typeof config.overrides === 'object') {
const remapped: AnyObject = {};
for (const [key, value] of Object.entries(config.overrides)) {
- remapped[OVERRIDE_KEY_MAP[key as keyof typeof OVERRIDE_KEY_MAP] ?? key] = value;
+ const mappedKey = OVERRIDE_KEY_MAP[key as keyof typeof OVERRIDE_KEY_MAP] ?? key;
+ if (
+ key === 'interface' &&
+ value != null &&
+ typeof value === 'object' &&
+ !Array.isArray(value)
+ ) {
+ const filtered: AnyObject = {};
+ for (const [field, fieldVal] of Object.entries(value as AnyObject)) {
+ if (!INTERFACE_PERMISSION_FIELDS.has(field)) {
+ filtered[field] = fieldVal;
+ } else if (
+ fieldVal != null &&
+ typeof fieldVal === 'object' &&
+ !Array.isArray(fieldVal)
+ ) {
+ // Composite permission field (e.g. mcpServers): strip permission
+ // sub-keys but preserve UI-only sub-keys like placeholder/trustCheckbox.
+ const uiOnly: AnyObject = {};
+ for (const [sub, subVal] of Object.entries(fieldVal as AnyObject)) {
+ if (!PERMISSION_SUB_KEYS.has(sub)) {
+ uiOnly[sub] = subVal;
+ }
+ }
+ if (Object.keys(uiOnly).length > 0) {
+ filtered[field] = uiOnly;
+ }
+ }
+ // boolean permission fields (e.g. runCode: false) are fully stripped
+ }
+ if (Object.keys(filtered).length > 0) {
+ remapped[mappedKey] = filtered;
+ }
+ } else {
+ remapped[mappedKey] = value;
+ }
}
merged = deepMerge(merged, remapped);
}