Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(desktop): preserve model settings saves across provider refreshes

321sssrt-bit035c72a45759
diff --git a/apps/desktop/src/renderer/hooks/__tests__/useModelContextLimit.test.ts b/apps/desktop/src/renderer/hooks/__tests__/useModelContextLimit.test.ts
index 021a09193a..b67b69f222 100644
--- a/apps/desktop/src/renderer/hooks/__tests__/useModelContextLimit.test.ts
+++ b/apps/desktop/src/renderer/hooks/__tests__/useModelContextLimit.test.ts
@@ -6,21 +6,150 @@ import { useModelContextLimit } from '../useModelContextLimit';
function deferred<T>() {
let resolve!: (value: T) => void;
- const promise = new Promise<T>((r) => {
+ let reject!: (reason: unknown) => void;
+ const promise = new Promise<T>((r, j) => {
resolve = r;
+ reject = j;
});
- return { promise, resolve };
+ return { promise, resolve, reject };
}
const target = { agent: 'codex' as const, providerId: 'openai', modelId: 'gpt-test' };
const view = (limit: number | null) => ({ limit, isCustomized: limit !== null });
const get = vi.fn();
const set = vi.fn();
const setCompaction = vi.fn();
+let providersChanged: () => void;
beforeEach(() => {
- vi.clearAllMocks();
+ vi.resetAllMocks();
setDataOwnerGeneration('owner-a', 1);
Object.assign(window, {
- electronAPI: { maker: { getModelContextLimit: get, setModelContextLimit: set, setModelCompaction: setCompaction } },
+ electronAPI: { maker: {
+ getModelContextLimit: get, setModelContextLimit: set, setModelCompaction: setCompaction,
+ onProvidersChanged: (listener: () => void) => { providersChanged = listener; return () => {}; },
+ } },
+ });
+});
+
+// B2: existing ownership tests did not overlap provider notifications with saves.
+// Unit tier: deferred IPC drives the real hook; assert committed values and visible errors.
+describe('provider refresh during model settings saves', () => {
+ const piTarget = { ...target, agent: 'pi' as const };
+ const saved = { ...view(128_000), compaction: { pct: 90, isCustomized: false } };
+ const mutations = [
+ { name: 'window', start: (hook: ReturnType<typeof useModelContextLimit>) => hook.setLimit(256_000),
+ result: { ...saved, ...view(256_000) }, api: set },
+ { name: 'reset', start: (hook: ReturnType<typeof useModelContextLimit>) => hook.reset(),
+ result: { ...saved, ...view(null) }, api: set },
+ { name: 'compaction', start: (hook: ReturnType<typeof useModelContextLimit>) => hook.setCompaction(80),
+ result: { ...saved, compaction: { pct: 80, isCustomized: true } }, api: setCompaction },
+ ];
+
+ it.each(mutations)('keeps the committed $name after a refresh during save', async ({ start, result, api }) => {
+ const pending = deferred<typeof saved>();
+ get.mockResolvedValue(saved);
+ api.mockReturnValueOnce(pending.promise);
+ const hook = renderHook(() => useModelContextLimit(piTarget));
+ await act(async () => {});
+ let saving!: Promise<void>;
+ act(() => { saving = start(hook.result.current); });
+ await act(async () => { providersChanged(); });
+ expect(hook.result.current.loading).toBe(true);
+ await act(async () => { get.mockResolvedValue(result); pending.resolve(result); await saving; });
+ expect(hook.result.current).toMatchObject({ ...result, error: false, loading: false });
+ hook.unmount();
+ });
+
+ it.each(mutations)('shows a failed $name and its recovered value despite refreshes', async ({ start, api }) => {
+ const pending = deferred<typeof saved>();
+ const recovery = deferred<typeof saved>();
+ get.mockResolvedValue(saved);
+ api.mockReturnValueOnce(pending.promise);
+ const hook = renderHook(() => useModelContextLimit(piTarget));
+ await act(async () => {});
+ let saving!: Promise<void>;
+ act(() => { saving = start(hook.result.current); });
+ await act(async () => { providersChanged(); });
+ get.mockReturnValueOnce(recovery.promise);
+ await act(async () => { pending.reject(new Error('synthetic save failure')); });
+ await act(async () => { providersChanged(); });
+ const recovered = { ...saved, ...view(192_000) };
+ await act(async () => { get.mockResolvedValue(recovered); recovery.resolve(recovered); await saving; });
+ expect(hook.result.current).toMatchObject({ ...recovered, error: true, loading: false });
+ hook.unmount();
+ });
+
+ it('keeps Codex native readback authoritative while provider events arrive', async () => {
+ const native = deferred<typeof saved>();
+ get.mockResolvedValueOnce(view(128_000)).mockReturnValueOnce(native.promise);
+ set.mockResolvedValue(view(256_000));
+ const hook = renderHook(() => useModelContextLimit(target));
+ await act(async () => {});
+ let saving!: Promise<void>;
+ await act(async () => { saving = hook.result.current.setLimit(256_000); });
+ await act(async () => { providersChanged(); });
+ // Main snapshots preferences before awaiting native metadata; a second window can update them meanwhile.
+ const latest = { ...saved, ...view(240_000), compaction: { pct: 80, isCustomized: true } };
+ await act(async () => {
+ get.mockResolvedValue(latest);
+ native.resolve({ ...saved, ...view(240_000) });
+ await saving;
+ });
+ expect(hook.result.current).toMatchObject({ ...latest, error: false, loading: false });
+ hook.unmount();
+ });
+
+ it('ignores a pre-save read that returns after the save, then accepts a new refresh', async () => {
+ const oldRead = deferred<ReturnType<typeof view>>();
+ get.mockResolvedValueOnce(view(128_000)).mockReturnValueOnce(oldRead.promise);
+ set.mockResolvedValue(view(256_000));
+ const hook = renderHook(() => useModelContextLimit(piTarget));
+ await act(async () => {});
+ act(() => { providersChanged(); });
+ await act(async () => { await hook.result.current.setLimit(256_000); });
+ await act(async () => { oldRead.resolve(view(128_000)); });
+ expect(hook.result.current.limit).toBe(256_000);
+ get.mockResolvedValueOnce(view(384_000));
+ await act(async () => { providersChanged(); });
+ expect(hook.result.current.limit).toBe(384_000);
+ hook.unmount();
+ });
+
+ it.each(['success', 'failure'])('ignores an older save %s after a newer save starts', async (outcome) => {
+ const first = deferred<ReturnType<typeof view>>();
+ const second = deferred<ReturnType<typeof view>>();
+ get.mockResolvedValue(view(128_000));
+ set.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
+ const hook = renderHook(() => useModelContextLimit(piTarget));
+ await act(async () => {});
+ act(() => { void hook.result.current.setLimit(256_000); void hook.result.current.setLimit(384_000); });
+ await act(async () => {
+ if (outcome === 'success') first.resolve(view(256_000));
+ else first.reject(new Error('older save failed'));
+ providersChanged();
+ });
+ expect(hook.result.current.loading).toBe(true);
+ await act(async () => { get.mockResolvedValue(view(384_000)); second.resolve(view(384_000)); });
+ expect(hook.result.current).toMatchObject({ limit: 384_000, error: false, loading: false });
+ hook.unmount();
+ });
+
+ it.each(['model', 'owner'])('allows the new %s to refresh while the old save is pending', async (boundary) => {
+ const pending = deferred<ReturnType<typeof view>>();
+ get.mockResolvedValueOnce(view(128_000)).mockResolvedValue(view(64_000));
+ set.mockReturnValueOnce(pending.promise);
+ const hook = renderHook(({ modelId }) => useModelContextLimit({ ...piTarget, modelId }),
+ { initialProps: { modelId: 'old' } });
+ await act(async () => {});
+ act(() => { void hook.result.current.setLimit(256_000); });
+ await act(async () => { providersChanged(); });
+ await act(async () => {
+ if (boundary === 'model') hook.rerender({ modelId: 'new' });
+ else { setDataOwnerGeneration('owner-b', 2); providersChanged(); }
+ });
+ expect(hook.result.current.limit).toBe(64_000);
+ await act(async () => { pending.reject(new Error('old scope failed')); });
+ expect(hook.result.current).toMatchObject({ limit: 64_000, error: false, loading: false });
+ hook.unmount();
});
});
describe('context editor request ownership', () => {
diff --git a/apps/desktop/src/renderer/hooks/useModelContextLimit.ts b/apps/desktop/src/renderer/hooks/useModelContextLimit.ts
index 0e47dcbdf6..b9d2422ee9 100644
--- a/apps/desktop/src/renderer/hooks/useModelContextLimit.ts
+++ b/apps/desktop/src/renderer/hooks/useModelContextLimit.ts
@@ -19,26 +19,44 @@ export function useModelContextLimit(target: ModelContextLimitTarget | null) {
const stableTarget = useMemo<ModelContextLimitTarget | null>(() => JSON.parse(key), [key]);
const [state, setState] = useState({ ...EMPTY, key, loading: true, error: false });
const generation = useRef(0);
+ const pendingWrite = useRef<{
+ request: number; owner: ReturnType<typeof getDataOwnerGeneration>; refresh: boolean;
+ } | null>(null);
const run = useCallback(
async (write?: { limit: number | null } | { compactionPct: number | null }) => {
+ // A save owns its result and recovery; provider notifications must not supersede it.
+ if (!write && pendingWrite.current?.request === generation.current
+ && isDataOwnerGenerationCurrent(pendingWrite.current.owner)) {
+ pendingWrite.current.refresh = true;
+ return;
+ }
const request = ++generation.current;
if (!stableTarget) {
setState({ ...EMPTY, key, loading: false, error: false });
return;
}
const owner = getDataOwnerGeneration();
+ if (write) pendingWrite.current = { request, owner, refresh: false };
const stamp = { dataOwnerId: owner.dataOwnerId, ownerGeneration: owner.generation };
const current = () => request === generation.current && isDataOwnerGenerationCurrent(owner);
+ const read = async () => {
+ let view: ModelContextLimitView;
+ do {
+ if (pendingWrite.current?.request === request) pendingWrite.current.refresh = false;
+ view = await window.electronAPI.maker.getModelContextLimit(stableTarget);
+ } while (current() && pendingWrite.current?.request === request && pendingWrite.current.refresh);
+ return view;
+ };
setState((prev) => ({ ...prev, loading: true, error: false }));
try {
let view = write
? 'compactionPct' in write
? await window.electronAPI.maker.setModelCompaction(stableTarget, write.compactionPct, stamp)
: await window.electronAPI.maker.setModelContextLimit(stableTarget, write.limit, stamp)
- : await window.electronAPI.maker.getModelContextLimit(stableTarget);
- if (write && stableTarget.agent === 'codex' && current()) {
- view = await window.electronAPI.maker.getModelContextLimit(stableTarget);
+ : await read();
+ if (write && current() && (stableTarget.agent === 'codex' || pendingWrite.current?.refresh)) {
+ view = await read();
}
if (current()) setState({ ...view, key, loading: false, error: false });
} catch (error) {
@@ -47,7 +65,7 @@ export function useModelContextLimit(target: ModelContextLimitTarget | null) {
// value even if rollback/readback also failed; never retain a stale edit.
if (write && current()) {
try {
- const view = await window.electronAPI.maker.getModelContextLimit(stableTarget);
+ const view = await read();
if (current()) setState({ ...view, key, loading: false, error: true });
return;
} catch (readError) {
@@ -55,6 +73,8 @@ export function useModelContextLimit(target: ModelContextLimitTarget | null) {
}
}
if (current()) setState((prev) => ({ ...prev, loading: false, error: true }));
+ } finally {
+ if (pendingWrite.current?.request === request) pendingWrite.current = null;
}
},
[stableTarget, key],