diff --git a/src/components/configuration/ImportYamlDialog.tsx b/src/components/configuration/ImportYamlDialog.tsx
index 0cdd5ae9..41f81e22 100644
--- a/src/components/configuration/ImportYamlDialog.tsx
+++ b/src/components/configuration/ImportYamlDialog.tsx
@@ -5,6 +5,7 @@ import { Icon, Button, Dialog, Tabs } from '@clickhouse/click-ui';
 import type * as t from '@/types';
 import { availableScopesOptions, createGroupFn, createRoleFn, parseImportedYaml } from '@/server';
 import { getScopeTypeConfig } from '@/constants';
+import { InfoBanner } from './InfoBanner';
 import { useLocalize } from '@/hooks';
 import { cn } from '@/utils';
 
@@ -24,6 +25,7 @@ export function ImportYamlDialog({
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string>();
   const [validationErrors, setValidationErrors] = useState<t.ImportValidationError[]>();
+  const [preservedValues, setPreservedValues] = useState<t.ImportPreservedValue[]>([]);
 
   const [step, setStep] = useState<t.ImportStep>('input');
   const [parsedConfig, setParsedConfig] = useState<Record<string, t.ConfigValue> | null>(null);
@@ -52,6 +54,7 @@ export function ImportYamlDialog({
     setLoading(false);
     setError(undefined);
     setValidationErrors(undefined);
+    setPreservedValues([]);
     setStep('input');
     setParsedConfig(null);
     setTargetMode('base');
@@ -117,6 +120,7 @@ export function ImportYamlDialog({
 
       if (result.appConfig && typeof result.appConfig === 'object') {
         setParsedConfig(result.appConfig as Record<string, t.ConfigValue>);
+        setPreservedValues(result.preservedValues ?? []);
         setStep('target');
       }
     } catch (err) {
@@ -277,6 +281,17 @@ export function ImportYamlDialog({
 
           {step === 'target' && (
             <div ref={targetRef}>
+              {preservedValues.length > 0 && (
+                <div className="mb-3">
+                  <InfoBanner
+                    dismissible={false}
+                    text={localize('com_config_import_preserved_notice', {
+                      count: preservedValues.length,
+                      values: [...new Set(preservedValues.map((p) => p.value))].join(', '),
+                    })}
+                  />
+                </div>
+              )}
               <p className="mb-3 text-sm text-(--cui-color-text-muted)">
                 {localize('com_config_import_target')}
               </p>
diff --git a/src/components/configuration/__tests__/ImportYamlDialog.test.tsx b/src/components/configuration/__tests__/ImportYamlDialog.test.tsx
new file mode 100644
index 00000000..453a698f
--- /dev/null
+++ b/src/components/configuration/__tests__/ImportYamlDialog.test.tsx
@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { parseImportedYaml } from '@/server';
+import { ImportYamlDialog } from '../ImportYamlDialog';
+
+vi.mock('@/hooks/useLocalize', () => {
+  const localize = (key: string, options?: Record<string, string | number>) =>
+    options ? `${key} ${Object.values(options).join(' ')}` : key;
+  return { default: () => localize, useLocalize: () => localize };
+});
+
+vi.mock('@/server', () => ({
+  parseImportedYaml: vi.fn(),
+  createRoleFn: vi.fn(),
+  createGroupFn: vi.fn(),
+  availableScopesOptions: {
+    queryKey: ['availableScopes'],
+    queryFn: async () => [],
+  },
+}));
+
+interface MockChildrenProps {
+  children?: React.ReactNode;
+}
+interface MockDialogProps extends MockChildrenProps {
+  open?: boolean;
+}
+interface MockDialogContentProps extends MockChildrenProps {
+  title?: string;
+}
+interface MockButtonProps {
+  label: string;
+  onClick?: () => void;
+  disabled?: boolean;
+}
+interface MockAlertProps {
+  text: string;
+}
+
+vi.mock('@clickhouse/click-ui', () => {
+  const Dialog = ({ open, children }: MockDialogProps) => (open ? <div>{children}</div> : null);
+  Dialog.Content = ({ title, children }: MockDialogContentProps) => (
+    <div>
+      {title}
+      {children}
+    </div>
+  );
+  const Tabs = ({ children }: MockChildrenProps) => <div>{children}</div>;
+  Tabs.TriggersList = ({ children }: MockChildrenProps) => <div>{children}</div>;
+  Tabs.Trigger = ({ children }: MockChildrenProps) => <button type="button">{children}</button>;
+  Tabs.Content = ({ children }: MockChildrenProps) => <div>{children}</div>;
+  return {
+    Dialog,
+    Tabs,
+    Icon: ({ name }: { name: string }) => <span>{name}</span>,
+    Alert: ({ text }: MockAlertProps) => <div role="status">{text}</div>,
+    Button: ({ label, onClick, disabled }: MockButtonProps) => (
+      <button onClick={onClick} disabled={disabled}>
+        {label}
+      </button>
+    ),
+  };
+});
+
+const parseImportedYamlMock = vi.mocked(parseImportedYaml);
+
+function renderDialog() {
+  const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+  return render(
+    <QueryClientProvider client={queryClient}>
+      <ImportYamlDialog
+        open
+        onClose={vi.fn()}
+        onImport={vi.fn()}
+        onImportAsProfile={vi.fn().mockResolvedValue(undefined)}
+      />
+    </QueryClientProvider>,
+  );
+}
+
+async function validateYaml() {
+  fireEvent.change(screen.getByLabelText('com_config_import_paste'), {
+    target: { value: 'version: 1.3.12' },
+  });
+  fireEvent.click(screen.getByRole('button', { name: 'com_config_import_validate' }));
+  await screen.findByRole('radiogroup');
+}
+
+describe('ImportYamlDialog preserved values notice', () => {
+  beforeEach(() => {
+    parseImportedYamlMock.mockReset();
+  });
+
+  it('shows a non-blocking notice listing values the panel does not recognize', async () => {
+    parseImportedYamlMock.mockResolvedValue({
+      success: true,
+      error: undefined,
+      validationErrors: undefined,
+      preservedValues: [
+        { path: 'endpoints.agents.capabilities.4', value: 'subagents' },
+        { path: 'endpoints.agents.capabilities.7', value: 'skills' },
+      ],
+      appConfig: { version: '1.3.12' },
+    });
+
+    renderDialog();
+    await validateYaml();
+
+    const notice = screen.getByRole('status');
+    expect(notice).toHaveTextContent('com_config_import_preserved_notice 2 subagents, skills');
+    expect(screen.getByRole('button', { name: 'com_config_import_apply' })).not.toBeDisabled();
+  });
+
+  it('shows no notice when every value is recognized', async () => {
+    parseImportedYamlMock.mockResolvedValue({
+      success: true,
+      error: undefined,
+      validationErrors: undefined,
+      preservedValues: undefined,
+      appConfig: { version: '1.3.12' },
+    });
+
+    renderDialog();
+    await validateYaml();
+
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+  });
+});
diff --git a/src/components/configuration/fields/ListField.tsx b/src/components/configuration/fields/ListField.tsx
index 2c6edf3e..34c92f25 100644
--- a/src/components/configuration/fields/ListField.tsx
+++ b/src/components/configuration/fields/ListField.tsx
@@ -30,6 +30,10 @@ export function ListField({
 
   const resolvedPlaceholder = placeholder ?? localize('com_ui_enter_value');
   const resolvedItemLabel = itemLabel ?? localize('com_ui_item');
+  const knownOptionValues = options ? new Set(options.map((o) => o.value)) : null;
+  const selectedKnownCount = knownOptionValues
+    ? new Set(values.filter((v) => knownOptionValues.has(v))).size
+    : 0;
 
   const handleAdd = () => {
     if (options) {
@@ -76,6 +80,7 @@ export function ListField({
                 aria-label={itemLabel}
                 className="config-input flex-1"
               >
+                {!knownOptionValues?.has(value) && <option value={value}>{value}</option>}
                 {options.map((opt) => (
                   <option key={opt.value} value={opt.value}>
                     {opt.label}
@@ -113,7 +118,7 @@ export function ListField({
         );
       })}
 
-      {!disabled && (!options || values.length < options.length) && (
+      {!disabled && (!options || selectedKnownCount < options.length) && (
         <AddItemButton
           label={localize('com_ui_add_item', { item: resolvedItemLabel })}
           onClick={handleAdd}
diff --git a/src/components/configuration/fields/SelectField.tsx b/src/components/configuration/fields/SelectField.tsx
index 1a3b544b..33a3cc79 100644
--- a/src/components/configuration/fields/SelectField.tsx
+++ b/src/components/configuration/fields/SelectField.tsx
@@ -12,6 +12,7 @@ export function SelectField({
   'aria-label': ariaLabel,
 }: t.SelectFieldProps) {
   const localize = useLocalize();
+  const isUnknownValue = value !== '' && !options.some((o) => o.value === value);
 
   return (
     <div className="select-field-a11y max-w-75" id={id}>
@@ -22,6 +23,7 @@ export function SelectField({
         disabled={disabled}
         aria-label={ariaLabel}
       >
+        {isUnknownValue && <Select.Item value={value}>{value}</Select.Item>}
         {options.map((option) => (
           <Select.Item key={option.value} value={option.value}>
             {option.label}
diff --git a/src/components/configuration/fields/__tests__/ListField.test.tsx b/src/components/configuration/fields/__tests__/ListField.test.tsx
new file mode 100644
index 00000000..ed3ddaed
--- /dev/null
+++ b/src/components/configuration/fields/__tests__/ListField.test.tsx
@@ -0,0 +1,144 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { ListField } from '../ListField';
+
+vi.mock('@/hooks/useLocalize', () => ({
+  default: () => (key: string) => key,
+  useLocalize: () => (key: string) => key,
+}));
+
+interface MockButtonProps {
+  label: string;
+  onClick?: () => void;
+  disabled?: boolean;
+}
+interface MockIconButtonProps {
+  onClick?: () => void;
+  'aria-label'?: string;
+}
+
+vi.mock('@clickhouse/click-ui', () => ({
+  Button: ({ label, onClick, disabled }: MockButtonProps) => (
+    <button onClick={onClick} disabled={disabled}>
+      {label}
+    </button>
+  ),
+  IconButton: ({ onClick, 'aria-label': ariaLabel }: MockIconButtonProps) => (
+    <button onClick={onClick} aria-label={ariaLabel} />
+  ),
+}));
+
+const capabilityOptions = [
+  { label: 'execute_code', value: 'execute_code' },
+  { label: 'web_search', value: 'web_search' },
+  { label: 'tools', value: 'tools' },
+];
+
+describe('ListField with enum options', () => {
+  it('renders an unknown value as a visible selected option', () => {
+    render(
+      <ListField
+        id="capabilities"
+        values={['execute_code', 'capability_from_newer_librechat']}
+        onChange={vi.fn()}
+        options={capabilityOptions}
+      />,
+    );
+
+    const selects = screen.getAllByRole('combobox');
+    expect((selects[1] as HTMLSelectElement).value).toBe('capability_from_newer_librechat');
+    expect(
+      screen.getByRole('option', { name: 'capability_from_newer_librechat' }),
+    ).toBeInTheDocument();
+  });
+
+  it('does not render an extra option when all values are known', () => {
+    render(
+      <ListField
+        id="capabilities"
+        values={['execute_code', 'web_search']}
+        onChange={vi.fn()}
+        options={capabilityOptions}
+      />,
+    );
+
+    expect(screen.getAllByRole('option')).toHaveLength(capabilityOptions.length * 2);
+  });
+
+  it('keeps the unknown value when another row is edited', () => {
+    const onChange = vi.fn();
+    render(
+      <ListField
+        id="capabilities"
+        values={['execute_code', 'capability_from_newer_librechat']}
+        onChange={onChange}
+        options={capabilityOptions}
+      />,
+    );
+
+    fireEvent.change(screen.getAllByRole('combobox')[0], { target: { value: 'web_search' } });
+    expect(onChange).toHaveBeenCalledWith(['web_search', 'capability_from_newer_librechat']);
+  });
+
+  it('keeps the unknown value when another row is removed', () => {
+    const onChange = vi.fn();
+    render(
+      <ListField
+        id="capabilities"
+        values={['execute_code', 'capability_from_newer_librechat']}
+        onChange={onChange}
+        options={capabilityOptions}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'com_ui_delete com_ui_item 1' }));
+    expect(onChange).toHaveBeenCalledWith(['capability_from_newer_librechat']);
+  });
+
+  it('shows Add when a known option remains unselected despite an unknown value', () => {
+    const onChange = vi.fn();
+    render(
+      <ListField
+        id="capabilities"
+        values={['capability_from_newer_librechat', 'execute_code', 'web_search']}
+        onChange={onChange}
+        options={capabilityOptions}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'com_ui_add_item' }));
+    expect(onChange).toHaveBeenCalledWith([
+      'capability_from_newer_librechat',
+      'execute_code',
+      'web_search',
+      'tools',
+    ]);
+  });
+
+  it('hides Add when every known option is selected alongside an unknown value', () => {
+    render(
+      <ListField
+        id="capabilities"
+        values={['capability_from_newer_librechat', 'execute_code', 'web_search', 'tools']}
+        onChange={vi.fn()}
+        options={capabilityOptions}
+      />,
+    );
+
+    expect(screen.queryByRole('button', { name: 'com_ui_add_item' })).not.toBeInTheDocument();
+  });
+
+  it('shows the unknown value as plain text when disabled', () => {
+    render(
+      <ListField
+        id="capabilities"
+        values={['capability_from_newer_librechat']}
+        onChange={vi.fn()}
+        options={capabilityOptions}
+        disabled
+      />,
+    );
+
+    expect(screen.getByText('capability_from_newer_librechat')).toBeInTheDocument();
+  });
+});
diff --git a/src/components/configuration/fields/__tests__/SelectField.test.tsx b/src/components/configuration/fields/__tests__/SelectField.test.tsx
new file mode 100644
index 00000000..fe24aadc
--- /dev/null
+++ b/src/components/configuration/fields/__tests__/SelectField.test.tsx
@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { SelectField } from '../SelectField';
+
+vi.mock('@/hooks/useLocalize', () => ({
+  default: () => (key: string) => key,
+  useLocalize: () => (key: string) => key,
+}));
+
+interface MockSelectProps {
+  children?: React.ReactNode;
+  value?: string;
+  onSelect?: (value: string) => void;
+  'aria-label'?: string;
+}
+interface MockSelectItemProps {
+  children?: React.ReactNode;
+  value: string;
+}
+
+vi.mock('@clickhouse/click-ui', () => {
+  const Select = ({ children, value, onSelect, 'aria-label': ariaLabel }: MockSelectProps) => (
+    <select value={value ?? ''} onChange={(e) => onSelect?.(e.target.value)} aria-label={ariaLabel}>
+      {children}
+    </select>
+  );
+  Select.Item = ({ children, value }: MockSelectItemProps) => (
+    <option value={value}>{children}</option>
+  );
+  return { Select };
+});
+
+const formatOptions = [
+  { label: 'png', value: 'png' },
+  { label: 'webp', value: 'webp' },
+];
+
+describe('SelectField', () => {
+  it('renders an unknown value as a visible selected option', () => {
+    render(
+      <SelectField
+        id="imageOutputType"
+        value="format_from_newer_librechat"
+        options={formatOptions}
+        onChange={vi.fn()}
+      />,
+    );
+
+    const select = screen.getByRole('combobox') as HTMLSelectElement;
+    expect(select.value).toBe('format_from_newer_librechat');
+    expect(screen.getByRole('option', { name: 'format_from_newer_librechat' })).toBeInTheDocument();
+  });
+
+  it('does not render an extra option when the value is known', () => {
+    render(
+      <SelectField id="imageOutputType" value="png" options={formatOptions} onChange={vi.fn()} />,
+    );
+
+    expect(screen.getAllByRole('option')).toHaveLength(formatOptions.length);
+  });
+
+  it('does not render an extra option when the value is empty', () => {
+    render(
+      <SelectField id="imageOutputType" value="" options={formatOptions} onChange={vi.fn()} />,
+    );
+
+    expect(screen.getAllByRole('option')).toHaveLength(formatOptions.length);
+  });
+
+  it('keeps known options selectable alongside an unknown value', () => {
+    const onChange = vi.fn();
+    render(
+      <SelectField
+        id="imageOutputType"
+        value="format_from_newer_librechat"
+        options={formatOptions}
+        onChange={onChange}
+      />,
+    );
+
+    fireEvent.change(screen.getByRole('combobox'), { target: { value: 'png' } });
+    expect(onChange).toHaveBeenCalledWith('png');
+  });
+});
diff --git a/src/locales/en/translation.json b/src/locales/en/translation.json
index a00cd996..54f48124 100644
--- a/src/locales/en/translation.json
+++ b/src/locales/en/translation.json
@@ -149,6 +149,7 @@
   "com_config_import_validate": "Validate & import",
   "com_config_import_success": "Configuration imported successfully.",
   "com_config_import_error": "Import failed",
+  "com_config_import_preserved_notice": "Imported with {{count}} values this panel version does not recognize: {{values}}. They were preserved as-is and may come from a newer LibreChat release.",
   "com_config_import_target": "Import target",
   "com_config_import_apply": "Apply",
   "com_config_import_back": "Back",
diff --git a/src/server/config.test.ts b/src/server/config.test.ts
index 931bc7a5..a0a61414 100644
--- a/src/server/config.test.ts
+++ b/src/server/config.test.ts
@@ -12,6 +12,7 @@ import {
   extractSchemaTree,
   getZodTypeName,
   flattenTree,
+  parseYamlConfig,
   resolveSubSchema,
   validateFieldValue,
   parseIndexedArrayPath,
@@ -688,6 +689,20 @@ describe('validateFieldValue', () => {
     const bad = validateFieldValue('mcpServers.foo.headers.Authorization', 42);
     expect(bad.success).toBe(false);
   });
+
+  it('accepts unknown string enum values for agent capabilities (forward compatibility)', () => {
+    const result = validateFieldValue('endpoints.agents.capabilities', [
+      'execute_code',
+      'capability_from_newer_librechat',
+      'web_search',
+    ]);
+    expect(result).toEqual({ success: true });
+  });
+
+  it('rejects numeric values in enum arrays', () => {
+    const result = validateFieldValue('endpoints.agents.capabilities', ['execute_code', 123]);
+    expect(result.success).toBe(false);
+  });
 });
 
 /* ---------------------------------------------------------------------------
@@ -1283,3 +1298,168 @@ describe('validateFieldValue for endpoints', () => {
     expect(result).toEqual({ success: true });
   });
 });
+
+/* ---------------------------------------------------------------------------
+ * Regression — issue #72. Configs written for a LibreChat release newer than
+ * the bundled librechat-data-provider schema must still import: unknown string
+ * enum values (new agent capabilities, etc.) are preserved as-is instead of
+ * hard-failing, while structurally invalid configs keep failing.
+ * -----------------------------------------------------------------------*/
+
+describe('parseYamlConfig', () => {
+  const issue72Capabilities = [
+    'execute_code',
+    'file_search',
+    'web_search',
+    'artifacts',
+    'subagents',
+    'actions',
+    'context',
+    'skills',
+    'tools',
+    'chain',
+    'ocr',
+  ];
+
+  const issue72Yaml = `
+version: 1.3.12
+endpoints:
+  bedrock:
+    disabled: false
+  agents:
+    disableBuilder: false
+    allowedProviders:
+      - "bedrock"
+    capabilities:
+${issue72Capabilities.map((c) => `      - '${c}'`).join('\n')}
+`;
+
+  const yamlWithCapabilities = (capabilities: string[]) => `
+version: 1.3.12
+endpoints:
+  agents:
+    capabilities:
+${capabilities.map((c) => `      - '${c}'`).join('\n')}
+`;
+
+  const capabilitiesOf = (appConfig: Record<string, t.ConfigValue> | null) => {
+    const endpoints = appConfig?.endpoints as Record<string, t.ConfigValue> | undefined;
+    const agents = endpoints?.agents as Record<string, t.ConfigValue> | undefined;
+    return agents?.capabilities;
+  };
+
+  it('imports the issue #72 config including subagents and skills capabilities', () => {
+    const result = parseYamlConfig(issue72Yaml);
+    expect(result.success).toBe(true);
+    expect(result.error).toBeUndefined();
+    expect(result.preservedValues).toBeUndefined();
+    expect(capabilitiesOf(result.appConfig)).toEqual(issue72Capabilities);
+  });
+
+  it('preserves enum values from LibreChat releases newer than the bundled schema', () => {
+    const result = parseYamlConfig(
+      yamlWithCapabilities(['execute_code', 'capability_from_newer_librechat', 'web_search']),
+    );
+    expect(result.success).toBe(true);
+    expect(capabilitiesOf(result.appConfig)).toEqual([
+      'execute_code',
+      'capability_from_newer_librechat',
+      'web_search',
+    ]);
+  });
+
+  it('reports which values were preserved so the UI can surface them', () => {
+    const result = parseYamlConfig(
+      yamlWithCapabilities(['execute_code', 'capability_from_newer_librechat', 'web_search']),
+    );
+    expect(result.preservedValues).toEqual([
+      { path: 'endpoints.agents.capabilities.1', value: 'capability_from_newer_librechat' },
+    ]);
+  });
+
+  it('preserves multiple unknown enum values at their original positions', () => {
+    const result = parseYamlConfig(
+      yamlWithCapabilities(['future_first', 'tools', 'future_mid', 'ocr', 'future_last']),
+    );
+    expect(result.success).toBe(true);
+    expect(capabilitiesOf(result.appConfig)).toEqual([
+      'future_first',
+      'tools',
+      'future_mid',
+      'ocr',
+      'future_last',
+    ]);
+    expect(result.preservedValues?.map((p) => p.value)).toEqual([
+      'future_first',
+      'future_mid',
+      'future_last',
+    ]);
+  });
+
+  it('still parses the rest of the config when unknown enum values are preserved', () => {
+    const result = parseYamlConfig(`
+version: 1.3.12
+cache: true
+endpoints:
+  agents:
+    disableBuilder: false
+    capabilities:
+      - 'capability_from_newer_librechat'
+`);
+    expect(result.success).toBe(true);
+    expect(result.appConfig?.version).toBe('1.3.12');
+    expect(result.appConfig?.cache).toBe(true);
+  });
+
+  it('rejects structurally invalid configs', () => {
+    const result = parseYamlConfig(`
+version: 1.3.12
+endpoints:
+  agents:
+    capabilities: 'not-an-array'
+`);
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Config validation failed');
+    expect(result.appConfig).toBeNull();
+  });
+
+  it('rejects configs mixing unknown enum values with structural errors', () => {
+    const result = parseYamlConfig(`
+version: 1.3.12
+endpoints:
+  agents:
+    disableBuilder: 'not-a-boolean'
+    capabilities:
+      - 'capability_from_newer_librechat'
+`);
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Config validation failed');
+    expect(result.validationErrors).toEqual([
+      expect.objectContaining({ path: 'endpoints.agents.disableBuilder' }),
+    ]);
+  });
+
+  it('rejects numeric values in enum arrays', () => {
+    const result = parseYamlConfig(`
+version: 1.3.12
+endpoints:
+  agents:
+    capabilities:
+      - 123
+`);
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Config validation failed');
+  });
+
+  it('rejects invalid YAML syntax', () => {
+    const result = parseYamlConfig('version: [unclosed');
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid YAML syntax');
+  });
+
+  it('rejects YAML that is not an object', () => {
+    const result = parseYamlConfig('just a string');
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('YAML did not produce a valid configuration object');
+  });
+});
diff --git a/src/server/config.ts b/src/server/config.ts
index 32635157..d587fae5 100644
--- a/src/server/config.ts
+++ b/src/server/config.ts
@@ -556,6 +556,14 @@ export function resolveSubSchema(
   return current;
 }
 
+/** Enum mismatches where the received value is a string are forward-compatible:
+ *  newer LibreChat releases add enum members (e.g. agent capabilities) that the
+ *  bundled `librechat-data-provider` schema does not know about yet. Numeric or
+ *  otherwise non-string values are genuine type errors and stay blocking. */
+function isUnknownEnumIssue(issue: t.ZodIssueLike): boolean {
+  return issue.code === 'invalid_enum_value' && typeof issue.received === 'string';
+}
+
 export function validateFieldValue(
   fieldPath: string,
   value: unknown,
@@ -574,12 +582,15 @@ export function validateFieldValue(
       subSchema as {
         safeParse: (v: unknown) => {
           success: boolean;
-          error?: { issues: Array<{ message: string; path: (string | number)[] }> };
+          error?: { issues: t.ZodIssueLike[] };
         };
       }
     ).safeParse(value);
     if (!result.success && result.error) {
-      const messages = result.error.issues.map((i) => i.message);
+      const issues = result.error.issues ?? [];
+      const blocking = issues.filter((i) => !isUnknownEnumIssue(i));
+      if (issues.length > 0 && blocking.length === 0) return { success: true };
+      const messages = blocking.map((i) => i.message);
       return { success: false, error: messages.join('; ') || 'Validation failed' };
     }
   }
@@ -670,65 +681,172 @@ export const getConfigSchemaFields = createServerFn({ method: 'GET' }).handler(a
   }
 });
 
-export const parseImportedYaml = createServerFn({ method: 'POST' })
-  .inputValidator(z.object({ yamlContent: z.string() }))
-  .handler(async ({ data }: { data: { yamlContent: string } }) => {
-    let rawConfig: unknown;
-    try {
-      rawConfig = yaml.load(data.yamlContent, { schema: yaml.JSON_SCHEMA });
-    } catch (parseError) {
-      console.error('Failed to parse imported YAML content:', parseError);
-      return {
-        success: false,
-        error: 'Invalid YAML syntax. Please check the content for syntax errors.',
-        validationErrors: undefined,
-        appConfig: null,
-      };
-    }
+function getContainerAt(
+  root: Record<string, unknown>,
+  path: (string | number)[],
+): Record<string, unknown> | unknown[] | null {
+  let current: unknown = root;
+  for (const segment of path) {
+    if (!current || typeof current !== 'object') return null;
+    current = (current as Record<string, unknown>)[segment as string];
+  }
+  if (!current || typeof current !== 'object') return null;
+  return current as Record<string, unknown> | unknown[];
+}
 
-    if (!rawConfig || typeof rawConfig !== 'object') {
-      return {
-        success: false,
-        error: 'YAML did not produce a valid configuration object',
-        validationErrors: undefined,
-        appConfig: null,
-      };
+/**
+ * Removes the unknown enum values behind forward-compatible issues so the
+ * config re-parses cleanly (applying schema defaults, transforms, and
+ * unknown-key stripping), then splices the original values back into the
+ * parsed output at their original positions. Returns `null` when any value
+ * cannot be safely removed and restored, in which case the caller falls back
+ * to the regular hard validation failure — never a silently mutated config.
+ */
+function preserveUnknownEnumValues(
+  rawConfig: Record<string, unknown>,
+  issues: t.ZodIssueLike[],
+): Record<string, t.ConfigValue> | null {
+  const cleaned = structuredClone(rawConfig);
+  const arrayRemovals = new Map<
+    string,
+    { path: (string | number)[]; entries: Array<{ index: number; value: unknown }> }
+  >();
+  const scalarRemovals: Array<{ path: (string | number)[]; value: unknown }> = [];
+
+  for (const issue of issues) {
+    if (issue.path.length === 0) return null;
+    const parentPath = issue.path.slice(0, -1);
+    const lastSegment = issue.path[issue.path.length - 1];
+    const container = getContainerAt(cleaned, parentPath);
+    if (!container) return null;
+    if (Array.isArray(container)) {
+      if (typeof lastSegment !== 'number') return null;
+      const key = parentPath.join('.');
+      const removal = arrayRemovals.get(key) ?? { path: parentPath, entries: [] };
+      removal.entries.push({ index: lastSegment, value: container[lastSegment] });
+      arrayRemovals.set(key, removal);
+    } else {
+      scalarRemovals.push({ path: issue.path, value: container[lastSegment as string] });
+      delete container[lastSegment as string];
     }
+  }
 
-    const result = configSchema.safeParse(rawConfig);
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: 'Config validation failed',
-        validationErrors: result.error.errors.map(
-          (e: { path: (string | number)[]; message: string }) => ({
-            path: e.path.join('.'),
-            message: e.message,
-          }),
-        ),
-        appConfig: null,
-      };
-    }
+  for (const { path, entries } of arrayRemovals.values()) {
+    const arrayValue = getContainerAt(cleaned, path);
+    if (!Array.isArray(arrayValue)) return null;
+    entries.sort((a, b) => b.index - a.index);
+    for (const { index } of entries) arrayValue.splice(index, 1);
+  }
+
+  const reparsed = configSchema.safeParse(cleaned);
+  if (!reparsed.success) return null;
+  const output = reparsed.data as Record<string, unknown>;
+
+  for (const { path, entries } of arrayRemovals.values()) {
+    const arrayValue = getContainerAt(output, path);
+    if (!Array.isArray(arrayValue)) return null;
+    entries.sort((a, b) => a.index - b.index);
+    for (const { index, value } of entries) arrayValue.splice(index, 0, value);
+  }
+  for (const { path, value } of scalarRemovals) {
+    const container = getContainerAt(output, path.slice(0, -1));
+    if (!container || Array.isArray(container)) return null;
+    container[path[path.length - 1] as string] = value;
+  }
+
+  return output as Record<string, t.ConfigValue>;
+}
 
-    /**
-     * `librechat-data-provider` and `@librechat/data-schemas` both migrated
-     * to tsdown (upstream #13578, #13597) and now ship dual `.d.cts` + `.d.mts`
-     * declaration files. Under `moduleResolution: bundler`, TS treats
-     * `TCustomConfig` resolved through one declaration path as nominally
-     * distinct from `TCustomConfig` resolved through the other, even when
-     * structurally identical. That collision shows up here as "Two different
-     * types with this name exist, but they are unrelated" in the ServerFn
-     * registration. The consumer (ImportYamlDialog) treats appConfig as
-     * `Record<string, ConfigValue>`, so widening the return is the local fix.
-     */
+export function parseYamlConfig(yamlContent: string): {
+  success: boolean;
+  error: string | undefined;
+  validationErrors: t.ImportValidationError[] | undefined;
+  preservedValues: t.ImportPreservedValue[] | undefined;
+  appConfig: Record<string, t.ConfigValue> | null;
+} {
+  let rawConfig: unknown;
+  try {
+    rawConfig = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA });
+  } catch (parseError) {
+    console.error('Failed to parse imported YAML content:', parseError);
     return {
-      success: true,
-      error: undefined,
+      success: false,
+      error: 'Invalid YAML syntax. Please check the content for syntax errors.',
       validationErrors: undefined,
-      appConfig: result.data as Record<string, t.ConfigValue>,
+      preservedValues: undefined,
+      appConfig: null,
     };
-  });
+  }
+
+  if (!rawConfig || typeof rawConfig !== 'object') {
+    return {
+      success: false,
+      error: 'YAML did not produce a valid configuration object',
+      validationErrors: undefined,
+      preservedValues: undefined,
+      appConfig: null,
+    };
+  }
+
+  const result = configSchema.safeParse(rawConfig);
+
+  if (!result.success) {
+    const issues = result.error.errors as t.ZodIssueLike[];
+    const blocking = issues.filter((i) => !isUnknownEnumIssue(i));
+
+    if (blocking.length === 0) {
+      const appConfig = preserveUnknownEnumValues(rawConfig as Record<string, unknown>, issues);
+      if (appConfig) {
+        return {
+          success: true,
+          error: undefined,
+          validationErrors: undefined,
+          preservedValues: issues.map((i) => ({
+            path: i.path.join('.'),
+            value: i.received as string,
+          })),
+          appConfig,
+        };
+      }
+    }
+
+    return {
+      success: false,
+      error: 'Config validation failed',
+      validationErrors: (blocking.length > 0 ? blocking : issues).map((e) => ({
+        path: e.path.join('.'),
+        message: e.message,
+      })),
+      preservedValues: undefined,
+      appConfig: null,
+    };
+  }
+
+  /**
+   * `librechat-data-provider` and `@librechat/data-schemas` both migrated
+   * to tsdown (upstream #13578, #13597) and now ship dual `.d.cts` + `.d.mts`
+   * declaration files. Under `moduleResolution: bundler`, TS treats
+   * `TCustomConfig` resolved through one declaration path as nominally
+   * distinct from `TCustomConfig` resolved through the other, even when
+   * structurally identical. That collision shows up here as "Two different
+   * types with this name exist, but they are unrelated" in the ServerFn
+   * registration. The consumer (ImportYamlDialog) treats appConfig as
+   * `Record<string, ConfigValue>`, so widening the return is the local fix.
+   */
+  return {
+    success: true,
+    error: undefined,
+    validationErrors: undefined,
+    preservedValues: undefined,
+    appConfig: result.data as Record<string, t.ConfigValue>,
+  };
+}
+
+export const parseImportedYaml = createServerFn({ method: 'POST' })
+  .inputValidator(z.object({ yamlContent: z.string() }))
+  .handler(async ({ data }: { data: { yamlContent: string } }) =>
+    parseYamlConfig(data.yamlContent),
+  );
 
 function getFieldDefault(schema: t.ZodSchemaLike): { hasDefault: boolean; value: unknown } {
   let current = schema;
diff --git a/src/types/config-ui.ts b/src/types/config-ui.ts
index acf9de13..ade9cc0c 100644
--- a/src/types/config-ui.ts
+++ b/src/types/config-ui.ts
@@ -286,6 +286,11 @@ export interface ImportValidationError {
   message: string;
 }
 
+export interface ImportPreservedValue {
+  path: string;
+  value: string;
+}
+
 export interface InfoBannerProps {
   text: string;
   dismissible?: boolean;
diff --git a/src/types/config.ts b/src/types/config.ts
index 52e40f59..1897cb69 100644
--- a/src/types/config.ts
+++ b/src/types/config.ts
@@ -62,6 +62,13 @@ export interface ZodSchemaLike {
   shape?: Record<string, ZodSchemaLike>;
 }
 
+export interface ZodIssueLike {
+  code?: string;
+  received?: unknown;
+  message: string;
+  path: (string | number)[];
+}
+
 export interface FieldValidationError {
   fieldPath: string;
   error: string;