Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
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.tsindex 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.tsindex 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],