🐛 fix: Preserve typed values when adding entries to new sections (#37)

When the admin panel adds an indexed-array edit (`modelSpecs.list.0`,
`endpoints.azureOpenAI.groups.0`) and the array's parent path is absent
from the YAML baseline, the merge that builds `activeConfigValues`
silently bails out and writes the array at the wrong nesting level.
The form's view of the section ends up empty, so typed entries appear
to vanish on blur and saves persist `[{}]` instead of the typed values.

The fix auto-creates missing intermediate object nodes during the merge.
Existing primitive/array values at intermediate paths still bail out so
live baseline data is never overwritten.

Extracts the merge into a pure `mergeIndexedArrayEdits` helper in
`utils.ts` and locks the behavior with nine unit tests covering the
regression case, sibling preservation, multi-edit indexing, defensive
bail-outs, and deep parent chains.

Linear: AI-894

Author: dustinhealy

src/components/configuration/ConfigPage.tsx

@@ -35,6 +35,7 @@ import { StickyActionBar } from '@/components/shared';
 import { ConfigTabContent } from './ConfigTabContent';
 import { ImportYamlDialog } from './ImportYamlDialog';
 import { ContentToolbar } from './ContentToolbar';
+import { mergeIndexedArrayEdits } from './utils';
 import { SystemCapabilities } from '@/constants';
 import { ConfigTabBar } from './ConfigTabBar';
 import { InfoBanner } from './InfoBanner';
@@ -276,25 +277,7 @@ export function ConfigPage({ initialTab, highlightField, initialScope }: t.Confi
     if (!baseActiveConfigValues) return baseActiveConfigValues;
     const indexedEdits = Object.entries(editedValues).filter(([k]) => /\.\d+$/.test(k));
     if (indexedEdits.length === 0) return baseActiveConfigValues;
-    const merged = { ...baseActiveConfigValues };
-    for (const [path, value] of indexedEdits) {
-      const segments = path.split('.');
-      const index = Number(segments.pop()!);
-      const arrayPath = segments;
-      let parent: Record<string, t.ConfigValue> = merged;
-      for (let i = 0; i < arrayPath.length - 1; i++) {
-        const seg = arrayPath[i];
-        if (parent[seg] && typeof parent[seg] === 'object' && !Array.isArray(parent[seg])) {
-          parent[seg] = { ...(parent[seg] as Record<string, t.ConfigValue>) };
-          parent = parent[seg] as Record<string, t.ConfigValue>;
-        } else break;
-      }
-      const lastSeg = arrayPath[arrayPath.length - 1];
-      const arr = Array.isArray(parent[lastSeg]) ? [...(parent[lastSeg] as t.ConfigValue[])] : [];
-      arr[index] = value;
-      parent[lastSeg] = arr;
-    }
-    return merged;
+    return mergeIndexedArrayEdits(baseActiveConfigValues, indexedEdits);
   }, [baseActiveConfigValues, editedValues]);
 
   const scopeConfiguredPaths = useMemo(() => {

src/components/configuration/utils.test.ts

@@ -1,5 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { getControlType, getEnumOptions, getArrayItemType, splitUnionTypes } from './utils';
+import {
+  getControlType,
+  getEnumOptions,
+  getArrayItemType,
+  splitUnionTypes,
+  mergeIndexedArrayEdits,
+} from './utils';
 import { createField } from '@/test/fixtures';
 
 describe('getControlType', () => {
@@ -236,3 +242,93 @@ describe('getEnumOptions — union(literal(...)) parsing', () => {
     expect(getEnumOptions('union(string | number)')).toEqual([]);
   });
 });
+
+describe('mergeIndexedArrayEdits', () => {
+  it('creates the array under a parent path absent from the baseline', () => {
+    /**
+     * Regression: the merge previously bailed out and wrote the array at the
+     * wrong nesting level when its parent (e.g. modelSpecs) wasn't in
+     * librechat.yaml, causing typed list entries to disappear from view.
+     */
+    const merged = mergeIndexedArrayEdits({}, [
+      ['modelSpecs.list.0', { name: 'test', label: 'Test' }],
+    ]);
+    expect(merged).toEqual({
+      modelSpecs: { list: [{ name: 'test', label: 'Test' }] },
+    });
+  });
+
+  it('preserves baseline siblings when introducing a new section', () => {
+    const merged = mergeIndexedArrayEdits({ interface: { parameters: true } }, [
+      ['modelSpecs.list.0', { name: 'a' }],
+    ]);
+    expect(merged).toEqual({
+      interface: { parameters: true },
+      modelSpecs: { list: [{ name: 'a' }] },
+    });
+  });
+
+  it('merges into an existing parent without clobbering its keys', () => {
+    const merged = mergeIndexedArrayEdits(
+      { modelSpecs: { enforce: true, prioritize: false } },
+      [['modelSpecs.list.0', { name: 'a' }]],
+    );
+    expect(merged.modelSpecs).toEqual({
+      enforce: true,
+      prioritize: false,
+      list: [{ name: 'a' }],
+    });
+  });
+
+  it('places multiple indexed edits at their correct positions', () => {
+    const merged = mergeIndexedArrayEdits({}, [
+      ['modelSpecs.list.0', { name: 'a' }],
+      ['modelSpecs.list.2', { name: 'c' }],
+    ]);
+    const list = (merged.modelSpecs as { list: Array<{ name: string } | undefined> }).list;
+    expect(list[0]).toEqual({ name: 'a' });
+    expect(list[1]).toBeUndefined();
+    expect(list[2]).toEqual({ name: 'c' });
+  });
+
+  it('returns the baseline unchanged when there are no indexed edits', () => {
+    const baseline = { interface: { parameters: true } };
+    expect(mergeIndexedArrayEdits(baseline, [])).toEqual(baseline);
+  });
+
+  it('does not mutate the baseline object', () => {
+    const baseline: Record<string, unknown> = { modelSpecs: { enforce: true } };
+    const before = JSON.parse(JSON.stringify(baseline));
+    mergeIndexedArrayEdits(baseline as Record<string, never>, [
+      ['modelSpecs.list.0', { name: 'a' }],
+    ]);
+    expect(baseline).toEqual(before);
+  });
+
+  it('skips an edit when an intermediate path is a primitive', () => {
+    /**
+     * Defensive: refuse to overwrite a primitive at an intermediate path
+     * because doing so would silently destroy unrelated baseline data.
+     */
+    const merged = mergeIndexedArrayEdits({ modelSpecs: 'not-an-object' }, [
+      ['modelSpecs.list.0', { name: 'a' }],
+    ]);
+    expect(merged).toEqual({ modelSpecs: 'not-an-object' });
+  });
+
+  it('skips an edit when an intermediate path is an array', () => {
+    const merged = mergeIndexedArrayEdits({ modelSpecs: [1, 2, 3] }, [
+      ['modelSpecs.list.0', { name: 'a' }],
+    ]);
+    expect(merged).toEqual({ modelSpecs: [1, 2, 3] });
+  });
+
+  it('walks deep parent chains, creating each missing level', () => {
+    const merged = mergeIndexedArrayEdits({}, [
+      ['endpoints.custom.deep.list.0', { name: 'x' }],
+    ]);
+    expect(merged).toEqual({
+      endpoints: { custom: { deep: { list: [{ name: 'x' }] } } },
+    });
+  });
+});

src/components/configuration/utils.ts

@@ -222,3 +222,48 @@ export function hasDescendant(path: string, paths?: Set<string>): boolean {
   }
   return false;
 }
+
+/**
+ * Merge indexed-array edits (entries whose flat path ends in `.<digit>`) into
+ * a config tree. Each indexed edit's value replaces the array element at that
+ * index; the array's parent path is auto-created if absent so newly-introduced
+ * sections (e.g. `modelSpecs` not present in `librechat.yaml`) merge in at the
+ * correct nesting level rather than getting written to the wrong parent.
+ *
+ * Skips an edit when an intermediate path holds a primitive or array value,
+ * since overwriting those with a fresh object would silently destroy live
+ * baseline data. Caller is responsible for filtering `editedValues` down to
+ * indexed entries before passing.
+ */
+export function mergeIndexedArrayEdits(
+  baseline: Record<string, t.ConfigValue>,
+  indexedEdits: Array<[string, t.ConfigValue]>,
+): Record<string, t.ConfigValue> {
+  const merged = { ...baseline };
+  for (const [path, value] of indexedEdits) {
+    const segments = path.split('.');
+    const index = Number(segments.pop()!);
+    const arrayPath = segments;
+    let parent: Record<string, t.ConfigValue> = merged;
+    let bailed = false;
+    for (let i = 0; i < arrayPath.length - 1; i++) {
+      const seg = arrayPath[i];
+      const existing = parent[seg];
+      if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+        parent[seg] = { ...(existing as Record<string, t.ConfigValue>) };
+      } else if (existing == null) {
+        parent[seg] = {};
+      } else {
+        bailed = true;
+        break;
+      }
+      parent = parent[seg] as Record<string, t.ConfigValue>;
+    }
+    if (bailed) continue;
+    const lastSeg = arrayPath[arrayPath.length - 1];
+    const arr = Array.isArray(parent[lastSeg]) ? [...(parent[lastSeg] as t.ConfigValue[])] : [];
+    arr[index] = value;
+    parent[lastSeg] = arr;
+  }
+  return merged;
+}