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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🧩 feat: Ignore Unknown Theme Color Tokens Instead of Dropping the Theme (#16529)
Marco Berettad06e7635dfa4
diff --git a/client/src/Providers/__tests__/DeploymentTheme.spec.tsx b/client/src/Providers/__tests__/DeploymentTheme.spec.tsxindex 2972563466..c1eaca0879 100644--- a/client/src/Providers/__tests__/DeploymentTheme.spec.tsx+++ b/client/src/Providers/__tests__/DeploymentTheme.spec.tsx@@ -201,7 +201,7 @@ describe('DeploymentTheme', () => {renderTheme(queryClient);await waitFor(() => expect(warn).toHaveBeenCalledTimes(1));- expect(warn.mock.calls[0][0]).toContain('Unknown color token: rgb-not-a-token');+ expect(warn.mock.calls[0][0]).toContain('Invalid RGB value for rgb-not-a-token: red');expect(root().dataset.theme).toBe('stored');});diff --git a/e2e/specs/mock/scenarios/theme-override.spec.ts b/e2e/specs/mock/scenarios/theme-override.spec.tsnew file mode 100644index 0000000000..a791bca439--- /dev/null+++ b/e2e/specs/mock/scenarios/theme-override.spec.ts@@ -0,0 +1,106 @@+import { expect, test } from '@playwright/test';+import type { APIRequestContext } from '@playwright/test';+import { getPrimaryE2EUser } from '../../../setup/users.mock';+import { loginAdmin, requestResult } from '../content-filters.helpers';+import { inOneProject } from './lint.helpers';+import { withMongo } from '../db';++/**+ * A theme a DB config override supplies is merged after the YAML loader ran, so the service+ * applies the loader's rules itself: unknown colors are left out of what `/api/config` serves,+ * and an override theme the client would reject leaves the principal with the base theme.+ */+test.describe.configure({ mode: 'serial', timeout: 120_000 });++type InterfaceBody = { interface?: { theme?: unknown; customWelcome?: string } };++/** A sibling field the override also sets, so a check never passes before the override applies. */+const MARKER = 'e2e theme override applied';++async function getPrimaryUserId(): Promise<string> {+ const { email } = getPrimaryE2EUser();+ const id = await withMongo(async (db) => {+ const user = await db.collection('users').findOne({ email }, { projection: { _id: 1 } });+ return user?._id?.toString();+ });+ if (!id) {+ throw new Error('primary user id not found');+ }+ return id;+}++async function withThemeOverride(+ request: APIRequestContext,+ theme: unknown,+ check: (token: string) => Promise<void>,+): Promise<void> {+ const token = await loginAdmin(request);+ const headers = { Authorization: `Bearer ${token}` };+ const path = `/api/admin/config/user/${encodeURIComponent(await getPrimaryUserId())}`;+ const saved = await request.put(path, {+ headers,+ data: { overrides: { interface: { theme, customWelcome: MARKER } } },+ });+ expect(saved.ok(), await saved.text()).toBe(true);+ try {+ await check(token);+ } finally {+ const removed = await request.delete(path, { headers, failOnStatusCode: false });+ expect([200, 404], await removed.text()).toContain(removed.status());+ }+}++async function servedInterface(+ request: APIRequestContext,+ token: string,+): Promise<InterfaceBody['interface']> {+ const config = await requestResult(request, { path: '/api/config', token });+ return (config.body as InterfaceBody | undefined)?.interface;+}++async function servedOverrideTheme(request: APIRequestContext, token: string): Promise<unknown> {+ let served: InterfaceBody['interface'];+ await expect+ .poll(async () => {+ served = await servedInterface(request, token);+ return served?.customWelcome;+ })+ .toBe(MARKER);+ return served?.theme;+}++test.describe('interface.theme from a config override', () => {+ test.beforeEach(() => inOneProject());++ test('an override theme with an unknown color token is served without it @scenario:override-theme-unknown-color-left-out', async ({+ request,+ }) => {+ const theme = {+ version: 1,+ name: 'e2e-override',+ modes: { light: { colors: { 'rgb-surface-primary': '1 2 3', 'surface-future': '4 5 6' } } },+ };+ await withThemeOverride(request, theme, async (token) => {+ expect(await servedOverrideTheme(request, token)).toEqual({+ version: 1,+ name: 'e2e-override',+ modes: { light: { colors: { 'rgb-surface-primary': '1 2 3' } } },+ });+ });+ });++ test('an invalid override theme leaves the user with the base theme @scenario:override-theme-invalid-keeps-base', async ({+ request,+ }) => {+ const token = await loginAdmin(request);+ const base = (await servedInterface(request, token))?.theme;+ const theme = {+ version: 1,+ name: 'e2e-override-invalid',+ modes: { dark: { colors: { 'rgb-surface-primary': '300 16 32' } } },+ };+ await withThemeOverride(request, theme, async (overrideToken) => {+ expect(await servedOverrideTheme(request, overrideToken)).toEqual(base);+ });+ });+});diff --git a/e2e/specs/mock/scenarios/theme-unknown-appearance.spec.ts b/e2e/specs/mock/scenarios/theme-unknown-appearance.spec.tsindex 00901ad230..dc4aa9d8f4 100644--- a/e2e/specs/mock/scenarios/theme-unknown-appearance.spec.ts+++ b/e2e/specs/mock/scenarios/theme-unknown-appearance.spec.ts@@ -118,36 +118,93 @@ test.describe('appearance tokens this build does not know', () => {});/**- * The same holds for a color role added after this build: a well-formed `rgb-` name with a valid- * triplet is dropped with a warning, so a newer definition keeps every color this build paints.+ * The same holds for a color token this build does not know, whether it is a role added later+ * or a misspelling: a plain token name with a valid triplet is dropped with a warning, so the+ * definition keeps every color this build paints. A bad value still rejects the definition.*/test.describe('color tokens this build does not know', () => {const NEWER_COLORS = {version: 1,name: 'e2e-newer-colors',modes: {- light: { colors: { 'rgb-surface-primary': '240 244 255', 'rgb-future-role': '1 2 3' } },- dark: { colors: { 'rgb-surface-primary': '12 16 32', 'rgb-future-role': '1 2 3' } },+ light: {+ colors: {+ 'rgb-surface-primary': '240 244 255',+ 'rgb-future-role': '1 2 3',+ 'surface-future': '7 8 9',+ },+ },+ dark: {+ colors: {+ 'rgb-surface-primary': '12 16 32',+ 'rgb-future-role': '1 2 3',+ 'surface-future': '7 8 9',+ },+ },},};- test('a stored theme with an unknown color role keeps the colors this build paints @scenario:stored-theme-unknown-color-token-applies-rest', async ({- page,- }) => {+ async function expectNewerColorsApplied(page: Page) {+ await expect(page.locator('html')).toHaveAttribute('data-theme', NEWER_COLORS.name);+ const dark = await page.evaluate(() => document.documentElement.classList.contains('dark'));+ expect(await themeValue(page, '--surface-primary')).toBe(dark ? '12 16 32' : '240 244 255');+ expect(await themeValue(page, '--future-role')).toBe('');+ const style = (await page.locator('html').getAttribute('style')) ?? '';+ expect(style).not.toContain('future');+ expect(style).not.toContain('7 8 9');+ }++ const collectWarnings = (page: Page): string[] => {const warnings: string[] = [];page.on('console', (message) => {if (message.type() === 'warning') {warnings.push(message.text());}});+ return warnings;+ };++ test('a stored theme with an unknown color token keeps the colors this build paints @scenario:stored-theme-unknown-color-token-applies-rest', async ({+ page,+ }) => {+ const warnings = collectWarnings(page);await storeTheme(page, NEWER_COLORS);await openChat(page);- await expect(page.locator('html')).toHaveAttribute('data-theme', NEWER_COLORS.name);- const dark = await page.evaluate(() => document.documentElement.classList.contains('dark'));- expect(await themeValue(page, '--surface-primary')).toBe(dark ? '12 16 32' : '240 244 255');- expect(await themeValue(page, '--future-role')).toBe('');+ await expectNewerColorsApplied(page);expect(warnings.join('\n')).toContain('color token ignored: rgb-future-role');+ expect(warnings.join('\n')).toContain('color token ignored: surface-future');+ });++ test('a deployment theme with an unknown color token keeps the colors this build paints @scenario:deployment-theme-unknown-color-token-applies-rest', async ({+ page,+ }) => {+ const warnings = collectWarnings(page);+ await serveTheme(page, NEWER_COLORS);++ await openChat(page);++ await expectNewerColorsApplied(page);+ expect(warnings.join('\n')).toContain('color token ignored: surface-future');+ });++ test('a stored theme whose unknown color token has an invalid value is still rejected @scenario:stored-theme-unknown-color-invalid-value-rejected', async ({+ page,+ }) => {+ const theme = {+ version: 1,+ name: 'e2e-invalid-unknown-color',+ modes: {+ light: { colors: { 'rgb-surface-primary': '240 244 255', 'surface-future': 'red' } },+ dark: { colors: { 'rgb-surface-primary': '12 16 32', 'surface-future': 'red' } },+ },+ };+ await storeTheme(page, theme);++ await openChat(page);++ await expect(page.locator('html')).not.toHaveAttribute('data-theme', theme.name);+ expect(await themeValue(page, '--surface-primary')).not.toBe('240 244 255');});});diff --git a/e2e/specs/mock/scenarios/yaml-theme-fallback.spec.ts b/e2e/specs/mock/scenarios/yaml-theme-fallback.spec.tsindex 66c07213b8..b2ec726e9a 100644--- a/e2e/specs/mock/scenarios/yaml-theme-fallback.spec.ts+++ b/e2e/specs/mock/scenarios/yaml-theme-fallback.spec.ts@@ -5,7 +5,7 @@ import { inOneProject, repoRoot, run } from './lint.helpers';/*** A mistake in `interface.theme` used to fail the whole librechat.yaml and stop the server. The* config loader that `/api` wires up now drops only the theme, names each problem by its path, and- * loads everything else. The mock lane serves one shared yaml, so these load their own fixtures+ * loads everything else; a token this version does not know only warns. The mock lane serves one shared yaml, so these load their own fixtures* through that same loader in a child process, the way the server does at startup and on reload.*/test.describe.configure({ timeout: 120_000 });@@ -56,17 +56,22 @@ test.describe('interface.theme in librechat.yaml', () => {delete process.env.CONFIG_PATH;});- test('a typo in a theme token leaves the server running on the default theme @scenario:yaml-theme-typo-falls-back', () => {+ test('a color token this version does not know is ignored and the theme still loads @scenario:yaml-theme-unknown-color-kept', () => {const { outcome, log } = loadFixture('unknown-token');expect(outcome.exited).toBeUndefined();- expect(outcome.interface).toEqual({ modelSelect: true });- expect(log).toContain('the default theme applies instead');+ expect(outcome.interface?.modelSelect).toBe(true);+ expect(outcome.interface?.theme).toEqual({+ version: 1,+ name: 'acme',+ modes: { light: { colors: { 'rgb-surface-primary': '240 244 255' } } },+ });+ expect(log).not.toContain('the default theme applies instead');expect(log).toContain(- 'interface.theme.modes.light.colors.rgb-surfce-secondary: Unknown color token: rgb-surfce-secondary',+ 'interface.theme.modes.light.colors.rgb-surfce-secondary: Unknown light color token ignored: rgb-surfce-secondary',);expect(log).toContain(- 'interface.theme.modes.light.colors.surface-tertiary: Unknown color token: surface-tertiary',+ 'interface.theme.modes.light.colors.surface-tertiary: Unknown light color token ignored: surface-tertiary',);});@@ -113,11 +118,11 @@ test.describe('interface.theme in librechat.yaml', () => {});test('a config reload with a broken theme applies the same fallback @scenario:yaml-theme-reload-falls-back', () => {- const { outcome, log } = loadFixture('unknown-token', 'reload');+ const { outcome, log } = loadFixture('bad-value', 'reload');expect(outcome.rejected).toBeUndefined();expect(outcome.interface).toEqual({ modelSelect: true });- expect(log).toContain('interface.theme.modes.light.colors.rgb-surfce-secondary');+ expect(log).toContain('interface.theme.modes.dark.colors.rgb-surface-primary');});test('an invalid key outside the theme still stops startup @scenario:yaml-theme-other-errors-still-exit', () => {diff --git a/packages/api/src/app/__fixtures__/theme/unknown-token-invalid.yaml b/packages/api/src/app/__fixtures__/theme/unknown-token-invalid.yamlnew file mode 100644index 0000000000..df166b3f45--- /dev/null+++ b/packages/api/src/app/__fixtures__/theme/unknown-token-invalid.yaml@@ -0,0 +1,15 @@+version: 1.3.17+cache: true+interface:+ modelSelect: true+ theme:+ version: 1+ name: acme+ modes:+ light:+ colors:+ rgb-surface-primary: '240 244 255'+ rgb-future-role: 'red'+ dark:+ colors:+ 'Surface Tertiary': '245 245 245'diff --git a/packages/api/src/app/loader.spec.ts b/packages/api/src/app/loader.spec.tsindex d0c523c6f2..da30bb27db 100644--- a/packages/api/src/app/loader.spec.ts+++ b/packages/api/src/app/loader.spec.ts@@ -55,21 +55,40 @@ describe('createCustomConfigLoader interface.theme', () => {expect(exit).not.toHaveBeenCalled();});- it('drops a theme naming an unknown color token and keeps the rest of the config', async () => {+ it('keeps a theme naming a color token this version does not know, without that token', async () => {const config = await load('unknown-token');expect(exit).not.toHaveBeenCalled();- expect(config).not.toBeNull();- expect(config?.interface).not.toHaveProperty('theme');+ expect(config?.interface?.theme).toEqual({+ version: 1,+ name: 'acme',+ modes: { light: { colors: { 'rgb-surface-primary': '240 244 255' } } },+ });expect(config?.interface?.modelSelect).toBe(true);expect(config?.cache).toBe(true);expect(warnings(warn)).toContain(- 'interface.theme.modes.light.colors.rgb-surfce-secondary: Unknown color token: rgb-surfce-secondary',+ 'interface.theme.modes.light.colors.rgb-surfce-secondary: Unknown light color token ignored: rgb-surfce-secondary',);expect(warnings(warn)).toContain(- 'interface.theme.modes.light.colors.surface-tertiary: Unknown color token: surface-tertiary',+ 'interface.theme.modes.light.colors.surface-tertiary: Unknown light color token ignored: surface-tertiary',+ );+ expect(warnings(warn)).not.toContain('the default theme applies instead');+ });++ it('still drops a theme whose unknown color token has an invalid value or name', async () => {+ const config = await load('unknown-token-invalid');++ expect(exit).not.toHaveBeenCalled();+ expect(config?.interface).not.toHaveProperty('theme');+ expect(config?.interface?.modelSelect).toBe(true);+ const logged = warnings(warn);+ expect(logged).toContain(+ 'interface.theme.modes.light.colors.rgb-future-role: Invalid RGB value for rgb-future-role: red',+ );+ expect(logged).toContain(+ 'interface.theme.modes.dark.colors.Surface Tertiary: Unknown color token: Surface Tertiary',);- expect(warnings(warn)).toContain('the default theme applies instead');+ expect(logged).toContain('the default theme applies instead');});it('reports every bad value with its path and drops the theme', async () => {@@ -141,12 +160,12 @@ describe('createCustomConfigLoader interface.theme', () => {describe('reload mode', () => {it('applies the same fallback instead of rejecting the reload', async () => {- const config = await load('unknown-token', 'reload');+ const config = await load('bad-value', 'reload');expect(config?.interface).not.toHaveProperty('theme');expect(config?.interface?.modelSelect).toBe(true);expect(warnings(warn)).toContain(- 'interface.theme.modes.light.colors.rgb-surfce-secondary: Unknown color token',+ 'interface.theme.modes.dark.colors.rgb-surface-primary: Invalid RGB value',);});diff --git a/packages/api/src/app/service.spec.ts b/packages/api/src/app/service.spec.tsindex b8bb615d57..48d0daecaa 100644--- a/packages/api/src/app/service.spec.ts+++ b/packages/api/src/app/service.spec.ts@@ -703,6 +703,68 @@ describe('createAppConfigService', () => {expect(config.modelSpecs?.list?.[0]?.preset?.agent_id).toBe('agent_abc');});+ it('leaves unknown colors out of a theme a DB override supplies', async () => {+ const deps = createDeps({+ getApplicableConfigs: jest.fn().mockResolvedValue([+ {+ priority: 10,+ isActive: true,+ overrides: {+ interface: {+ theme: {+ version: 1,+ name: 'override',+ modes: {+ light: {+ colors: { 'rgb-surface-primary': '1 2 3', 'surface-future': '4 5 6' },+ },+ },+ },+ },+ },+ },+ ]),+ });+ const { getAppConfig } = createAppConfigService(deps);++ const config = await getAppConfig({ role: 'USER' });++ expect(config.interfaceConfig?.theme).toEqual({+ version: 1,+ name: 'override',+ modes: { light: { colors: { 'rgb-surface-primary': '1 2 3' } } },+ });+ expect(config.interfaceConfig?.modelSelect).toBe(true);+ });++ it('keeps the base theme when a DB override supplies an invalid one', async () => {+ const deps = createDeps({+ loadBaseConfig: jest+ .fn()+ .mockResolvedValue({ interfaceConfig: { modelSelect: true, theme: 'clickhouse' } }),+ getApplicableConfigs: jest.fn().mockResolvedValue([+ {+ priority: 10,+ isActive: true,+ overrides: {+ interface: {+ theme: {+ version: 1,+ name: 'override',+ modes: { dark: { colors: { 'rgb-surface-primary': '300 16 32' } } },+ },+ },+ },+ },+ ]),+ });+ const { getAppConfig } = createAppConfigService(deps);++ const config = await getAppConfig({ role: 'USER' });++ expect(config.interfaceConfig?.theme).toBe('clickhouse');+ });+it('caches empty result — does not re-query DB on second call', async () => {const deps = createDeps({ getApplicableConfigs: jest.fn().mockResolvedValue([]) });const { getAppConfig } = createAppConfigService(deps);diff --git a/packages/api/src/app/service.ts b/packages/api/src/app/service.tsindex 3f0e503963..73000e3fcd 100644--- a/packages/api/src/app/service.ts+++ b/packages/api/src/app/service.ts@@ -18,6 +18,7 @@ import {import type { AppConfig, IConfig } from '@librechat/data-schemas';import type { Types } from 'mongoose';import type { CustomConfigLoadMode } from './loader';+import { checkAppConfigTheme } from './theme';const BASE_CONFIG_KEY = '_BASE_';@@ -147,6 +148,33 @@ export type AppConfigPrincipal = {principalId?: string | Types.ObjectId;};+/**+ * Applies the loader's theme rules to a theme a DB override replaced. Unknown colors are left+ * out as they are for the YAML theme; an override theme the client would reject counts as unset,+ * so the principal keeps the base theme instead of losing its theme to a bad override.+ */+function checkOverrideTheme(baseConfig: AppConfig, merged: AppConfig): AppConfig {+ const baseTheme = baseConfig.interfaceConfig?.theme;+ if (merged.interfaceConfig?.theme === baseTheme) {+ return merged;+ }+ const { appConfig, errors, warnings } = checkAppConfigTheme(merged);+ if (warnings.length > 0) {+ logger.warn(+ '[getAppConfig] interface.theme from a config override names tokens this version ignores:\n' ++ warnings.map((warning) => `- ${warning}`).join('\n'),+ );+ }+ if (errors.length === 0) {+ return appConfig;+ }+ logger.warn(+ '[getAppConfig] Ignoring interface.theme from a config override; the base theme applies instead:\n' ++ errors.map((error) => `- ${error}`).join('\n'),+ );+ return { ...merged, interfaceConfig: { ...merged.interfaceConfig, theme: baseTheme } };+}+/*** Materializes inferable model-spec fields (an omitted `preset.endpoint` for* agent specs) so every consumer of the effective config reads complete specs.@@ -541,10 +569,9 @@ export function createAppConfigService(deps: AppConfigServiceDeps): {try {const configs = await getApplicableConfigs(principals);if (configs.length > 0) {- merged = scopeCustomEndpoints(- materializeConfigModelSpecs(mergeConfigOverrides(scopedBaseConfig, configs)),- effectiveTenantId,- hiddenEndpoints,+ merged = checkOverrideTheme(+ baseConfig,+ materializeConfigModelSpecs(mergeConfigOverrides(baseConfig, configs)),);}} catch (error) {diff --git a/packages/api/src/app/theme.ts b/packages/api/src/app/theme.tsindex f604e99078..3b56453fb2 100644--- a/packages/api/src/app/theme.ts+++ b/packages/api/src/app/theme.ts@@ -7,6 +7,7 @@ import {collectThemeWarningIssues,} from 'librechat-data-provider';import type { ThemeIssue } from 'librechat-data-provider';+import type { AppConfig } from '@librechat/data-schemas';const THEME_PATH = ['interface', 'theme'];@@ -50,11 +51,37 @@ function collectErrors(theme: unknown): ThemeIssue[] {}));}+/**+ * A client older than this server tolerates only the unknown color names it was built to expect,+ * so a token this version does not paint is left out of the served theme rather than handed to+ * a cached client that might reject the whole definition for it.+ */+function withoutUnknownColors(+ theme: Record<string, unknown>,+ warnings: ThemeIssue[],+): Record<string, unknown> {+ const unknown = warnings.filter(({ path }) => path[2] === 'colors');+ if (unknown.length === 0 || !isPlainThemeRecord(theme.modes)) {+ return theme;+ }+ const modes: Record<string, unknown> = { ...theme.modes };+ unknown.forEach(({ path: [, mode, , token] }) => {+ const definition = modes[mode];+ if (!isPlainThemeRecord(definition) || !isPlainThemeRecord(definition.colors)) {+ return;+ }+ const { [token]: _ignored, ...colors } = definition.colors;+ modes[mode] = { ...definition, colors };+ });+ return { ...theme, modes };+}+/*** Checks `interface.theme` with the rules the client applies before painting it. A theme the* client would reject is removed, so the deployment falls back to the default theme and the rest- * of the config still loads; unknown appearance tokens, which the client drops on its own, only- * warn. A config without a theme, or with a valid one, is returned as the same object.+ * of the config still loads; unknown color and appearance tokens, which the client drops on its+ * own, only warn, and unknown colors are left out of the returned theme. A config without a+ * theme, or with a valid one naming only known colors, is returned as the same object.*/export function checkConfigTheme(config: unknown): ConfigThemeCheck {const unchanged: ConfigThemeCheck = { config, errors: [], warnings: [] };@@ -69,9 +96,43 @@ export function checkConfigTheme(config: unknown): ConfigThemeCheck {const theme = interfaceConfig.theme;const errors = collectErrors(theme).map(formatIssue);if (errors.length === 0) {- return { config, errors, warnings: collectThemeWarningIssues(theme).map(formatIssue) };+ const warningIssues = collectThemeWarningIssues(theme);+ const warnings = warningIssues.map(formatIssue);+ const served = isPlainThemeRecord(theme) ? withoutUnknownColors(theme, warningIssues) : theme;+ if (served === theme) {+ return { config, errors, warnings };+ }+ return {+ config: { ...config, interface: { ...interfaceConfig, theme: served } },+ errors,+ warnings,+ };}const { theme: _dropped, ...rest } = interfaceConfig;return { config: { ...config, interface: rest }, errors, warnings: [] };}++export interface AppConfigThemeCheck {+ /** The assembled config, the input itself unless its theme had to be cleaned or dropped. */+ appConfig: AppConfig;+ errors: string[];+ warnings: string[];+}++/**+ * The same check for an assembled config whose theme a DB override supplied: overrides are+ * merged after the YAML loader ran, so their theme would otherwise reach the client unchecked.+ */+export function checkAppConfigTheme(appConfig: AppConfig): AppConfigThemeCheck {+ const { interfaceConfig } = appConfig;+ if (interfaceConfig?.theme === undefined) {+ return { appConfig, errors: [], warnings: [] };+ }+ const { config, errors, warnings } = checkConfigTheme({ interface: interfaceConfig });+ const checked = (config as { interface: AppConfig['interfaceConfig'] }).interface;+ if (checked === interfaceConfig) {+ return { appConfig, errors, warnings };+ }+ return { appConfig: { ...appConfig, interfaceConfig: checked }, errors, warnings };+}diff --git a/packages/client/src/theme/context/ThemeProvider.spec.tsx b/packages/client/src/theme/context/ThemeProvider.spec.tsxindex c75437a3a9..2356e0e713 100644--- a/packages/client/src/theme/context/ThemeProvider.spec.tsx+++ b/packages/client/src/theme/context/ThemeProvider.spec.tsx@@ -931,6 +931,87 @@ describe('ThemeProvider', () => {});});+ describe('a definition carrying a color token this reader does not know', () => {+ const newerDefinition = {+ version: 1 as const,+ name: 'newer',+ modes: {+ light: { colors: { 'rgb-accent-primary': '4 5 6', 'surface-future': '7 8 9' } },+ dark: { colors: { 'rgb-accent-primary': '6 5 4', 'rgb-future-role': '9 8 7' } },+ },+ };+ let warn: jest.SpyInstance;++ beforeEach(() => {+ warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);+ });++ afterEach(() => {+ warn.mockRestore();+ });++ const expectApplied = () => {+ const root = document.documentElement;+ expect(root.dataset.theme).toBe('newer');+ expect(root.style.getPropertyValue('--accent-primary')).toBe('4 5 6');+ expect(root.getAttribute('style')).not.toContain('future');+ expect(root.getAttribute('style')).not.toContain('7 8 9');+ expect(warn).toHaveBeenCalledWith(+ '[ThemeProvider] Unknown light color token ignored: surface-future; ' ++ 'Unknown dark color token ignored: rgb-future-role',+ );+ };++ it('restores the stored definition with the rest applied and keeps the key stored', async () => {+ localStorage.setItem('theme-definition', JSON.stringify(newerDefinition));+ localStorage.setItem('theme-source', 'definition');++ render(+ <ThemeProvider initialTheme="light">+ <Controls />+ </ThemeProvider>,+ );++ await waitFor(expectApplied);+ expect(JSON.parse(localStorage.getItem('theme-definition') ?? '{}')).toEqual(newerDefinition);+ });++ it('applies the same definition from a controlled deployment prop', async () => {+ render(+ <ThemeProvider+ initialTheme="light"+ persistThemeDefinition={false}+ themeDefinition={newerDefinition}+ >+ <Controls />+ </ThemeProvider>,+ );++ await waitFor(expectApplied);+ expect(localStorage.getItem('theme-definition')).toBeNull();+ });++ it('still discards a stored definition whose unknown token has an invalid value', async () => {+ const invalid = {+ ...newerDefinition,+ modes: { light: { colors: { 'rgb-accent-primary': '4 5 6', 'surface-future': 'red' } } },+ };+ localStorage.setItem('theme-definition', JSON.stringify(invalid));++ render(+ <ThemeProvider initialTheme="light">+ <Controls />+ </ThemeProvider>,+ );++ await waitFor(() => {+ expect(document.documentElement.classList.contains('light')).toBe(true);+ });+ expect(document.documentElement.dataset.theme).toBeUndefined();+ expect(document.documentElement.style.getPropertyValue('--accent-primary')).toBe('');+ });+ });+it('uses a stable identity when a legacy consumer clears an active theme name', async () => {render(<ThemeProviderdiff --git a/packages/client/src/theme/registry.spec.ts b/packages/client/src/theme/registry.spec.tsindex 583829b7cd..a279043c4c 100644--- a/packages/client/src/theme/registry.spec.ts+++ b/packages/client/src/theme/registry.spec.ts@@ -1103,7 +1103,7 @@ describe('theme registry', () => {expect(validateThemeDefinition(invalidTheme)).toEqual(['Invalid RGB value for rgb-text-primary: 999 0 0',- 'Unknown color token: rgb-unknown',+ 'Invalid RGB value for rgb-unknown: red','Invalid appearance value for controlRadius: url(theme.css)','Invalid appearance value for shadowLg: 0 1px red; color: red','Invalid appearance value for shadowMd: not-a-shadow',@@ -1162,39 +1162,61 @@ describe('theme registry', () => {expect(() => resolveTheme(theme, 'light')).toThrow(TypeError);});- it('ignores a well-formed colour role it predates and paints the rest', () => {+ it('ignores a colour token it does not know and paints the rest', () => {const theme = {version: 1,name: 'colour',modes: {light: {- colors: { 'rgb-future': '1 2 3', 'rgb-accent-primary': '4 5 6' },+ colors: {+ 'rgb-future': '1 2 3',+ 'surface-future': '7 8 9',+ 'rgb-accent-primary': '4 5 6',+ },appearance: { futureSpacing: '1rem' },},+ dark: { colors: { 'rgb-surfce-primary': '1 1 1' } },},} as ThemeDefinition;expect(validateThemeDefinition(theme)).toEqual([]);expect(collectThemeWarnings(theme)).toEqual(['Unknown light color token ignored: rgb-future',+ 'Unknown light color token ignored: surface-future','Unknown light appearance token ignored: futureSpacing',+ 'Unknown dark color token ignored: rgb-surfce-primary',]);const resolved = resolveTheme(theme, 'light');expect(resolved.colors['rgb-accent-primary']).toBe('4 5 6');expect(resolved.colors).not.toHaveProperty('rgb-future');+ expect(resolved.colors).not.toHaveProperty('surface-future');+ expect(resolveTheme(theme, 'dark').colors).not.toHaveProperty('rgb-surfce-primary');});- it('still rejects an unknown colour token that is not a well-formed role', () => {+ it('still rejects an unknown colour token with an invalid value or a malformed name', () => {const theme = {version: 1,name: 'colour',- modes: { light: { colors: { 'rgb-future': 'red', future: '1 2 3' } } },+ modes: {+ light: {+ colors: {+ 'rgb-future': 'red',+ 'surface-future': '300 0 0',+ 'Surface Future': '1 2 3',+ 'rgb-x;}': '1 2 3',+ },+ },+ },} as ThemeDefinition;expect(validateThemeDefinition(theme)).toEqual([- 'Unknown color token: rgb-future',- 'Unknown color token: future',+ 'Invalid RGB value for rgb-future: red',+ 'Invalid RGB value for surface-future: 300 0 0',+ 'Unknown color token: Surface Future',+ 'Unknown color token: rgb-x;}',]);+ expect(collectThemeWarnings(theme)).toEqual([]);+ expect(() => resolveTheme(theme, 'light')).toThrow(TypeError);});it('still rejects an injection attempt carried by an unknown key', () => {diff --git a/packages/client/src/theme/registry.ts b/packages/client/src/theme/registry.tsindex fc2d00428c..b36d2a997b 100644--- a/packages/client/src/theme/registry.ts+++ b/packages/client/src/theme/registry.ts@@ -314,17 +314,13 @@ export const highContrastTheme: ThemeDefinition = Object.freeze({/** Tailwind composes `--tw-shadow` into one list with the ring layers, where `none` is invalid. */const disabledShadow = '0 0 #0000';-/** The client may be older than the server whose theme it paints, so it ignores color roles it- * predates the way it already ignores appearance keys. */-const clientReader = { ignoreFutureColors: true } as const;-/** The color and appearance tokens this reader does not know, which `resolveTheme` leaves out. */export function collectThemeWarnings(theme: ThemeDefinition): string[] {- return collectThemeWarningIssues(theme, clientReader).map(({ message }) => message);+ return collectThemeWarningIssues(theme).map(({ message }) => message);}export function validateThemeDefinition(theme: ThemeDefinition): string[] {- return collectThemeIssues(theme, clientReader).map(({ message }) => message);+ return collectThemeIssues(theme).map(({ message }) => message);}/**@@ -342,7 +338,7 @@ function definedEntries<T extends object>(values?: Partial<T>): Partial<T> {) as Partial<T>;}-/** A color role this reader predates passed validation as a warning; it never reaches the DOM. */+/** A color token this reader does not know passed validation as a warning; it never reaches the DOM. */function knownColors(colors?: IThemeRGB): IThemeRGB | undefined {if (!colors) {return colors;diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.tsindex a0ca00b949..361045207b 100644--- a/packages/data-provider/src/config.spec.ts+++ b/packages/data-provider/src/config.spec.ts@@ -2309,17 +2309,26 @@ describe('interface theme config', () => {expect(parseTheme({ ...inlineTheme, version: 2 }).success).toBe(false);});- it('rejects unknown keys and color names without the rgb- prefix', () => {+ it('rejects unknown keys and color names that are not plain tokens', () => {expect(parseTheme({ ...inlineTheme, css: 'body {}' }).success).toBe(false);expect(parseTheme({ ...inlineTheme, modes: { sepia: { colors: {} } } }).success).toBe(false);expect(parseTheme({...inlineTheme,- modes: { light: { colors: { 'surface-primary': '255 255 255' } } },+ modes: { light: { colors: { 'Surface Primary': '255 255 255' } } },}).success,).toBe(false);});+ it('accepts an unknown color token name so the loader can ignore it', () => {+ expect(+ parseTheme({+ ...inlineTheme,+ modes: { light: { colors: { 'surface-primary': '255 255 255' } } },+ }).success,+ ).toBe(true);+ });+it('accepts the ceilings and rejects values above them', () => {const atCeiling = { maxFiles: 500, maxInstructionsLength: 200000, maxDescriptionLength: 10000 };expect(chatProjectsConfigSchema.parse(atCeiling)).toEqual(atCeiling);diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex 2e0d6c7102..cce0f21f8e 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -2312,7 +2312,10 @@ export enum RetentionMode {const themeModeSchema = z.object({- colors: z.record(z.string().regex(/^rgb-/), z.string().regex(/^\d{1,3} \d{1,3} \d{1,3}$/)),+ colors: z.record(+ z.string().regex(/^[a-z][a-z0-9-]*$/),+ z.string().regex(/^\d{1,3} \d{1,3} \d{1,3}$/),+ ),appearance: z.record(z.string()),brands: z.record(z.string()),})diff --git a/packages/data-provider/src/theme.ts b/packages/data-provider/src/theme.tsindex 89ca2c9531..dc77cee942 100644--- a/packages/data-provider/src/theme.ts+++ b/packages/data-provider/src/theme.ts@@ -388,24 +388,15 @@ const isFutureAppearance = (key: string, value: unknown): boolean =>/^[a-z][a-zA-Z0-9]*$/.test(key) && typeof value === 'string' && !/[;{}<>]|url\s*\(/i.test(value);/**- * The same allowance for a color role: a well-formed `rgb-` name holding an RGB triplet is one- * this reader predates, so it is ignored rather than rejecting a theme a newer server or build- * wrote. Anything else under an unknown name is still an error.+ * The same allowance for a color role: a color token this reader does not know is ignored rather+ * than rejecting the theme, so a newer definition keeps every role this version can paint and a+ * misspelled one costs only itself. The name must still be a plain token; its value is checked+ * like any other role.*/-const isFutureColor = (key: string, value: unknown): boolean =>- /^rgb-[a-z][a-z0-9-]*$/.test(key) && isThemeRGB(value);+const isColorTokenName = (key: string): boolean => /^[a-z][a-z0-9-]*$/.test(key);const issue = (path: string[], message: string): ThemeIssue => ({ path, message });-export interface ThemeReadOptions {- /**- * A reader that may be older than the definition it paints (a cached client reading a newer- * server's theme) ignores well-formed color roles it predates. The server reads its own config- * with its own token list, so there an unknown role is a typo and stays an error.- */- ignoreFutureColors?: boolean;-}-/** LibreChat's own switch, which a theme naming only one of the two dimensions keeps for the other. */export const defaultSwitchSize = Object.freeze({ switchWidth: '2.75rem', switchHeight: '1.5rem' });@@ -465,10 +456,7 @@ function collectSwitchIssues(appearance: Record<string, unknown>, base: string[]}/** The color and appearance tokens this reader does not know, which a resolved theme leaves out. */-export function collectThemeWarningIssues(- theme: unknown,- { ignoreFutureColors = false }: ThemeReadOptions = {},-): ThemeIssue[] {+export function collectThemeWarningIssues(theme: unknown): ThemeIssue[] {if (!isPlainThemeRecord(theme) || !isPlainThemeRecord(theme.modes)) {return [];}@@ -479,14 +467,15 @@ export function collectThemeWarningIssues(return [];}const { colors, appearance } = definition;- const futureColors =- ignoreFutureColors && isPlainThemeRecord(colors)- ? Object.entries(colors)- .filter(([key, value]) => !colorTokenSet.has(key) && isFutureColor(key, value))- .map(([key]) =>- issue(['modes', mode, 'colors', key], `Unknown ${mode} color token ignored: ${key}`),- )- : [];+ const futureColors = isPlainThemeRecord(colors)+ ? Object.entries(colors)+ .filter(+ ([key, value]) => !colorTokenSet.has(key) && isColorTokenName(key) && isThemeRGB(value),+ )+ .map(([key]) =>+ issue(['modes', mode, 'colors', key], `Unknown ${mode} color token ignored: ${key}`),+ )+ : [];const futureAppearance = isPlainThemeRecord(appearance)? Object.keys(appearance).filter((key) => !isThemeAppearanceToken(key))@@ -524,11 +513,7 @@ function collectBrandIssues(brands: unknown, path: string[]): ThemeIssue[] {});}-function collectModeIssues(- mode: 'light' | 'dark',- definition: unknown,- { ignoreFutureColors = false }: ThemeReadOptions,-): ThemeIssue[] {+function collectModeIssues(mode: 'light' | 'dark', definition: unknown): ThemeIssue[] {const base = ['modes', mode];if (definition === undefined) {return [];@@ -547,10 +532,8 @@ function collectModeIssues(} else {Object.entries(colors ?? {}).forEach(([key, value]) => {const path = [...base, 'colors', key];- if (!colorTokenSet.has(key)) {- if (!ignoreFutureColors || !isFutureColor(key, value)) {- issues.push(issue(path, `Unknown color token: ${key}`));- }+ if (!colorTokenSet.has(key) && !isColorTokenName(key)) {+ issues.push(issue(path, `Unknown color token: ${key}`));return;}if (value !== undefined && !isThemeRGB(value)) {@@ -586,7 +569,7 @@ function collectModeIssues(}/** Every reason a definition cannot be painted; empty when it can. */-export function collectThemeIssues(theme: unknown, options: ThemeReadOptions = {}): ThemeIssue[] {+export function collectThemeIssues(theme: unknown): ThemeIssue[] {if (!isPlainThemeRecord(theme)) {return [issue([], 'Theme definition must be an object')];}@@ -611,7 +594,7 @@ export function collectThemeIssues(theme: unknown, options: ThemeReadOptions = {.filter((mode) => mode !== 'light' && mode !== 'dark').forEach((mode) => issues.push(issue(['modes', mode], `Unknown theme mode: ${mode}`)));- themeModes.forEach((mode) => issues.push(...collectModeIssues(mode, modes[mode], options)));+ themeModes.forEach((mode) => issues.push(...collectModeIssues(mode, modes[mode])));if (theme.brands !== undefined && !isPlainThemeRecord(theme.brands)) {issues.push(issue(['brands'], 'Theme brands must be an object'));