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(remote-agent): remember effort and Fast for remote provider models

Lizibc1993bc3049
diff --git a/apps/desktop/src/renderer/__tests__/agentDeviceModelMemory.test.ts b/apps/desktop/src/renderer/__tests__/agentDeviceModelMemory.test.ts
new file mode 100644
index 0000000000..8c431f2910
--- /dev/null
+++ b/apps/desktop/src/renderer/__tests__/agentDeviceModelMemory.test.ts
@@ -0,0 +1,146 @@
+/**
+ * agentDeviceModelMemory.test.ts
+ * ---------------------------------------------------------------------------
+ * 回归 state/agentDeviceModelMemory.ts(远程 Agent 的每模型档位记忆)的核心约定:
+ * 1. set/get 往返 + localStorage 持久化(模拟 app 重启后恢复)
+ * 2. 按电脑 / Agent / 供应商 / 模型隔离,不串到别处
+ * 3. 删键 = 跟随默认;空槽不留在存储里
+ * 4. 按 dataOwnerId 分区,账号之间不继承
+ * 5. 读写器引用稳定;快照深拷贝
+ * 6. 损坏的 localStorage 静默回退空表
+ *
+ * 项目 vitest env=node,无 window。沿用 providerModelMemory.test.ts 的最小 localStorage stub。
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+class MemLocalStorage {
+ private store = new Map<string, string>();
+ getItem(k: string): string | null {
+ return this.store.has(k) ? (this.store.get(k) as string) : null;
+ }
+ setItem(k: string, v: string): void {
+ this.store.set(k, v);
+ }
+ removeItem(k: string): void {
+ this.store.delete(k);
+ }
+ keys(): string[] {
+ return [...this.store.keys()];
+ }
+}
+
+let memStorage: MemLocalStorage;
+
+beforeEach(() => {
+ memStorage = new MemLocalStorage();
+ vi.stubGlobal('window', { localStorage: memStorage });
+ vi.stubGlobal('localStorage', memStorage);
+ vi.resetModules();
+});
+
+async function loadModule() {
+ return await import('@/state/agentDeviceModelMemory');
+}
+
+describe('agentDeviceModelMemory', () => {
+ it('记下的档位 / Fast 跨重启保留', async () => {
+ const before = await loadModule();
+ before.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ before.setAgentDeviceModelFast('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', true);
+
+ vi.resetModules(); // 模拟重启:进程内缓存清空,只剩 localStorage
+ const after = await loadModule();
+ expect(after.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBe(
+ 'xhigh',
+ );
+ expect(after.getAgentDeviceModelFast('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBe(
+ true,
+ );
+ });
+
+ it('按电脑、Agent、供应商、模型分别记,互不影响', async () => {
+ const m = await loadModule();
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-sonnet-5', 'low');
+
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-sonnet-5')).toBe(
+ 'low',
+ );
+ expect(m.getAgentDeviceModelEffort('dev-b', 'claude-code', 'anthropic', 'claude-opus-5')).toBeUndefined();
+ expect(m.getAgentDeviceModelEffort('dev-a', 'pi', 'anthropic', 'claude-opus-5')).toBeUndefined();
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'xd', 'claude-opus-5')).toBeUndefined();
+ });
+
+ it('不写进本机模型预设(providerModelMemory)', async () => {
+ const m = await loadModule();
+ const local = await import('@/state/providerModelMemory');
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ expect(local.getProviderModelEffort('claude-code', 'anthropic', 'claude-opus-5')).toBeUndefined();
+ expect(local.hasAnyProviderModelOverride()).toBe(false);
+ });
+
+ it('恢复推荐 = 删键;删空的槽不留在存储里', async () => {
+ const m = await loadModule();
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ m.setAgentDeviceModelFast('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', true);
+ m.clearAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5');
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBeUndefined();
+ expect(m.getAgentDeviceModelFast('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBe(true);
+
+ m.clearAgentDeviceModelFast('dev-a', 'claude-code', 'anthropic', 'claude-opus-5');
+ expect(m.snapshotAgentDeviceModelMemory('dev-a')).toBeUndefined();
+ expect(JSON.parse(memStorage.getItem(m.__STORAGE_KEY) ?? '{}')).toEqual({});
+ });
+
+ it('按账号分区:另一个账号读不到', async () => {
+ const m = await loadModule();
+ m.setAgentDeviceModelMemoryOwner('owner-1');
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ m.setAgentDeviceModelMemoryOwner('owner-2');
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBeUndefined();
+ m.setAgentDeviceModelMemoryOwner('owner-1');
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBe(
+ 'xhigh',
+ );
+ expect(memStorage.keys()).toEqual([`${m.__STORAGE_KEY}:owner-1`]);
+ });
+
+ it('读写器按电脑缓存、引用稳定,读写落到对应电脑', async () => {
+ const m = await loadModule();
+ const accessors = m.agentDeviceModelMemoryAccessors('dev-a');
+ expect(m.agentDeviceModelMemoryAccessors('dev-a')).toBe(accessors);
+ expect(m.agentDeviceModelMemoryAccessors('dev-b')).not.toBe(accessors);
+
+ accessors.setChoice?.('codex', 'openai', 'gpt-5.6', 'medium');
+ accessors.setFast('codex', 'openai', 'gpt-5.6', true);
+ expect(accessors.getEffort('codex', 'openai', 'gpt-5.6')).toBe('medium');
+ expect(m.getAgentDeviceModelFast('dev-a', 'codex', 'openai', 'gpt-5.6')).toBe(true);
+ expect(m.agentDeviceModelMemoryAccessors('dev-b').getEffort('codex', 'openai', 'gpt-5.6')).toBeUndefined();
+ });
+
+ it('快照是深拷贝,形状与 providerModelMemory 的来源槽一致', async () => {
+ const m = await loadModule();
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ const snapshot = m.snapshotAgentDeviceModelMemory('dev-a');
+ expect(snapshot).toEqual({
+ 'claude-code:anthropic': {
+ effortByModel: { 'claude-opus-5': 'xhigh' },
+ fastByModel: {},
+ thinkingByModel: {},
+ },
+ });
+ snapshot!['claude-code:anthropic']!.effortByModel['claude-opus-5'] = 'low';
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBe(
+ 'xhigh',
+ );
+ });
+
+ it('localStorage 内容损坏时静默回退空表', async () => {
+ memStorage.setItem('xdt:agentDeviceModelMemory:v1', '{not json');
+ const m = await loadModule();
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBeUndefined();
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'high');
+ expect(m.getAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5')).toBe('high');
+ });
+});
diff --git a/apps/desktop/src/renderer/__tests__/chatInputModelSelectorRouting.test.ts b/apps/desktop/src/renderer/__tests__/chatInputModelSelectorRouting.test.ts
index 4a6185eb0d..bcae6897fb 100644
--- a/apps/desktop/src/renderer/__tests__/chatInputModelSelectorRouting.test.ts
+++ b/apps/desktop/src/renderer/__tests__/chatInputModelSelectorRouting.test.ts
@@ -503,10 +503,10 @@ describe('ChatInput model source switching wiring', () => {
]) {
expect(draftBlock).toContain(write);
}
- // 远程 Agent 换落点:记忆按目标目录写(回本机写本机预设,去另一台电脑不写),
- // 落点原样交给草稿层。
- expect(draftBlock).toContain('selection.agentDevice === null');
- expect(draftBlock).toContain('? LOCAL_MODEL_MEMORY');
+ // 远程 Agent 换落点:记忆按目标目录写(回本机写本机预设,去另一台电脑写本机为那台记的
+ // 一份),落点原样交给草稿层。
+ expect(draftBlock).toContain('? agentDeviceModelMemoryAccessors(selection.agentDevice.deviceId)');
+ expect(draftBlock).toContain(': LOCAL_MODEL_MEMORY;');
expect(draftBlock).toContain('agentDevice: selection.agentDevice');
// 「恢复推荐」已先删除记忆键;直通草稿时不得把推荐档位重新写成 override。
expect(draftBlock).toContain('!selection.resetToRecommended');
diff --git a/apps/desktop/src/renderer/__tests__/remoteAgentModelMemoryWiring.test.ts b/apps/desktop/src/renderer/__tests__/remoteAgentModelMemoryWiring.test.ts
new file mode 100644
index 0000000000..031b42a0fc
--- /dev/null
+++ b/apps/desktop/src/renderer/__tests__/remoteAgentModelMemoryWiring.test.ts
@@ -0,0 +1,114 @@
+/**
+ * 远程 Agent · 模型档位记忆的渲染端接线(2026-10-07 用户反馈:远程供应商的 effort 等设置
+ * 重启或切走再切回就要重新选)。
+ *
+ * 起因:模型目录在另一台电脑时 ChatInput / 模型面板一概不读写记忆,草稿只靠进程内的「上一次
+ * 选择」。这里锁住几条接线:
+ * 1. Agent 在另一台电脑时,ChatInput 用本机为那台电脑记的那一份(远程控制仍不掺本机记忆);
+ * 2. 面板浏览别的电脑的目录时,各行读写那台电脑的记忆;从本机选到另一台电脑时按目标电脑写;
+ * 3. 草稿切模型按那台电脑的每模型档位还原;记忆按账号分区;
+ * 4. 已建任务换模 / 换电脑(含下一条消息前再调档)时,档位记进模型所在目录的那份。
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const read = (relative: string): string =>
+ readFileSync(resolve(__dirname, relative), 'utf8').replace(/\r\n/g, '\n');
+
+const chatInputSource = read('../components/new-chat/ChatInput.tsx');
+const selectorSource = read('../components/new-chat/ModelSelector.tsx');
+const panelSource = read('../components/new-chat/UnifiedModelPanel.tsx');
+const draftRouteSource = read('../features/cc-agent/NewMakerDraftRoute.tsx');
+const authSource = read('../contexts/AuthContext.tsx');
+
+describe('ChatInput:远程 Agent 的模型记忆', () => {
+ it('远程控制不掺本机记忆;Agent 在另一台电脑时用那台电脑的记忆', () => {
+ const memo = chatInputSource.indexOf('const modelMemory = useMemo<ModelMemoryAccessors | undefined>');
+ expect(memo).toBeGreaterThan(0);
+ const deviceLink = chatInputSource.indexOf('if (deviceLinkDeviceId) return undefined;', memo);
+ const agentDevice = chatInputSource.indexOf(
+ 'if (catalogDeviceId) return agentDeviceModelMemoryAccessors(catalogDeviceId);',
+ memo,
+ );
+ expect(deviceLink).toBeGreaterThan(memo);
+ expect(agentDevice).toBeGreaterThan(deviceLink);
+ });
+
+ it('草稿与已建任务的面板都拿到按电脑取记忆的入口', () => {
+ expect(chatInputSource.split('deviceModelMemory: agentDeviceModelMemoryAccessors,').length - 1).toBe(2);
+ });
+
+ it('从本机选到另一台电脑的模型时,档位按目标电脑写', () => {
+ expect(chatInputSource).toContain(
+ '? agentDeviceModelMemoryAccessors(selection.agentDevice.deviceId)',
+ );
+ });
+
+ it('记忆变化时重渲染', () => {
+ expect(chatInputSource).toContain('useAgentDeviceModelMemoryVersion();');
+ });
+
+ it('按模型所在目录写档位:另一台电脑写那台的一份,本机写本机预设', () => {
+ const helper = chatInputSource.indexOf('function rememberCatalogModelPrefs(');
+ expect(helper).toBeGreaterThan(0);
+ const body = chatInputSource.slice(helper, chatInputSource.indexOf('\n}\n', helper));
+ expect(body).toContain(
+ 'const memory = deviceId ? agentDeviceModelMemoryAccessors(deviceId) : LOCAL_MODEL_MEMORY;',
+ );
+ expect(body).toContain('memory.setEffort(agent, providerId, modelId, patch.effort)');
+ expect(body).toContain('memory.setFast(agent, providerId, modelId, patch.fast)');
+ });
+
+ it('Agent 在另一台电脑的任务:换模后意图期调档记进那台的记忆,不写本机新建任务记忆', () => {
+ const start = chatInputSource.indexOf('const syncSessionDraftModelPrefs = useCallback(');
+ expect(start).toBeGreaterThan(0);
+ const agentDeviceBranch = chatInputSource.indexOf('if (agentDeviceId) {', start);
+ const remember = chatInputSource.indexOf(
+ 'rememberCatalogModelPrefs(agentDeviceId, agentKind, memoryProviderId, modelId, patch);',
+ agentDeviceBranch,
+ );
+ const localWrites = chatInputSource.indexOf('setProviderModelChoice(agentKind,', start);
+ expect(agentDeviceBranch).toBeGreaterThan(start);
+ expect(remember).toBeGreaterThan(agentDeviceBranch);
+ // 分支在本机写入之前 return,不掺本机预设与新建任务记忆。
+ const earlyReturn = chatInputSource.indexOf('return;', remember);
+ expect(earlyReturn).toBeGreaterThan(remember);
+ expect(localWrites).toBeGreaterThan(earlyReturn);
+ });
+
+ it('已有任务换电脑:档位记进目标电脑那份目录的记忆', () => {
+ expect(chatInputSource).toContain(
+ 'rememberCatalogModelPrefs(relocateTo, targetAgentKind, providerId, newModelId, {',
+ );
+ expect(chatInputSource).toMatch(
+ /rememberCatalogModelPrefs\(\s*relocateTo,\s*targetAgentKind,\s*syncedProviderId,\s*newModelId,\s*syncedPatch,\s*\)/,
+ );
+ });
+});
+
+describe('模型面板:浏览别的电脑的目录', () => {
+ it('不是 Agent 当前所在电脑的目录时,读写那台电脑的记忆', () => {
+ expect(selectorSource).toContain('remoteAgent.deviceModelMemory?.(remoteBrowse.deviceId)');
+ });
+
+ it('选择器与联合面板都订阅这份记忆的版本号', () => {
+ expect(selectorSource).toContain('useAgentDeviceModelMemoryVersion()');
+ expect(panelSource).toContain(
+ 'const memoryVersion = useProviderModelMemoryVersion() + useAgentDeviceModelMemoryVersion();',
+ );
+ });
+});
+
+describe('草稿与账号分区', () => {
+ it('草稿取回那台电脑的选择时随记忆变化重新计算', () => {
+ const memo = draftRouteSource.indexOf('const deviceDraftDefaults = useMemo<RemoteDraftDefaults | null>(');
+ expect(memo).toBeGreaterThan(0);
+ const deps = draftRouteSource.indexOf('agentDeviceModelMemoryVersion,', memo);
+ expect(deps).toBeGreaterThan(memo);
+ });
+
+ it('随登录账号切换分区', () => {
+ expect(authSource).toContain('setAgentDeviceModelMemoryOwner(state.dataOwnerId);');
+ });
+});
diff --git a/apps/desktop/src/renderer/__tests__/remoteAgentRelocationWiring.test.ts b/apps/desktop/src/renderer/__tests__/remoteAgentRelocationWiring.test.ts
index 41ed5ece7b..1415754c6b 100644
--- a/apps/desktop/src/renderer/__tests__/remoteAgentRelocationWiring.test.ts
+++ b/apps/desktop/src/renderer/__tests__/remoteAgentRelocationWiring.test.ts
@@ -61,7 +61,9 @@ describe('ChatInput:换位置进切换事务', () => {
expect(chatInputSource).toContain(
'...(relocateTo !== undefined ? { agentDeviceId: relocateTo } : {}),',
);
- expect(chatInputSource).toContain('if (relocateTo === undefined) syncSessionDraftModelPrefs(');
+ // 换电脑只把档位记进目标目录的记忆,不走写新建任务记忆的 syncSessionDraftModelPrefs。
+ expect(chatInputSource.split('if (relocateTo !== undefined) {').length - 1).toBe(2);
+ expect(chatInputSource).not.toContain('if (relocateTo === undefined) syncSessionDraftModelPrefs(');
});
it('意图期内目录跟随意图里的电脑', () => {
diff --git a/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx b/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx
index 8d3906d6c7..64b1a073f1 100644
--- a/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/ChatInput.tsx
@@ -349,6 +349,10 @@ import {
setProviderModelThinking,
useProviderModelMemoryVersion,
} from '@/state/providerModelMemory';
+import {
+ agentDeviceModelMemoryAccessors,
+ useAgentDeviceModelMemoryVersion,
+} from '@/state/agentDeviceModelMemory';
import {
setSessionFavoriteAnchor as setSessionFavoriteAnchorMemory,
useSessionFavoriteAnchor,
@@ -887,6 +891,23 @@ const LOCAL_MODEL_MEMORY: ModelMemoryAccessors = {
clearFast: clearProviderModelFast,
};
+/**
+ * 把已有任务里选定的档位 / Fast 记进**这个模型所在目录**的那份记忆:deviceId = null 写本机预设,
+ * 否则写本机为那台电脑单独记的一份。只写模型档位,不碰新建任务记忆。来源缺失时不写。
+ */
+function rememberCatalogModelPrefs(
+ deviceId: string | null,
+ agent: AgentKind,
+ providerId: string | null | undefined,
+ modelId: string,
+ patch: { effort?: Effort; fast?: boolean },
+): void {
+ if (!providerId || !modelId) return;
+ const memory = deviceId ? agentDeviceModelMemoryAccessors(deviceId) : LOCAL_MODEL_MEMORY;
+ if (patch.effort !== undefined) memory.setEffort(agent, providerId, modelId, patch.effort);
+ if (patch.fast !== undefined) memory.setFast(agent, providerId, modelId, patch.fast);
+}
+
/** 统一模型选择器联合列表的候选引擎全集(与 SELECTABLE_VENDORS 同一顺序)。 */
const UNIFIED_AGENT_KINDS: readonly AgentKind[] = ['claude-code', 'codex', 'pi'];
@@ -2035,15 +2056,19 @@ export function ChatInput({
// 该会话切走后再切回此模型,才会采用最新全局预设。
// - 首页草稿无 live 会话,NewMakerDraftRoute 会把当前显示模型的 props 也从全局预设派生。
// - device-link 必须使用被控端镜像 override;旧被控端拿不到镜像时宁可无记忆,也不掺控制端本机。
+ // - 远程 Agent(Agent 在另一台电脑,任务在本机)用本机为那台电脑单独记的一份(按电脑分开,
+ // 跨重启保留),不掺本机目录的记忆。
useProviderModelMemoryVersion();
+ useAgentDeviceModelMemoryVersion();
const modelMemory = useMemo<ModelMemoryAccessors | undefined>(() => {
if (sshCodexHostId) return undefined;
// device-link 远程草稿 / 会话:用纯显示镜像 override(读被控端全局预设、写穿被控端)。
if (modelMemoryOverride) return modelMemoryOverride;
// 模型目录在另一台电脑时不掺本机记忆(那台的来源 id 与本机的不是一回事)。
- if (catalogDeviceId) return undefined;
+ if (deviceLinkDeviceId) return undefined;
+ if (catalogDeviceId) return agentDeviceModelMemoryAccessors(catalogDeviceId);
return LOCAL_MODEL_MEMORY;
- }, [catalogDeviceId, modelMemoryOverride, sshCodexHostId]);
+ }, [catalogDeviceId, deviceLinkDeviceId, modelMemoryOverride, sshCodexHostId]);
// 远程 Agent(仅本机新任务草稿):模型面板左侧栏同时列出其他电脑上的供应商。
const remoteAgentOptions = useMemo<RemoteAgentSelectorOptions | undefined>(
@@ -2053,6 +2078,7 @@ export function ChatInput({
devices: remoteAgentDevices,
selectedDeviceId: agentDeviceId,
localModelMemory: LOCAL_MODEL_MEMORY,
+ deviceModelMemory: agentDeviceModelMemoryAccessors,
}
: undefined,
[sessionId, deviceLinkDeviceId, remoteHostId, remoteAgentDevices, agentDeviceId],
@@ -6220,12 +6246,17 @@ export function ChatInput({
} = {},
) => {
const agentKind = opts.agentKind ?? currentModelAgentKind;
- // Agent 在另一台电脑运行的任务:模型属于那台的目录,不写回本机的新建任务记忆。
- if (!sessionId || !agentKind || !modelId || sshCodexHostId || agentDeviceId) return;
+ if (!sessionId || !agentKind || !modelId || sshCodexHostId) return;
const activeProviderId =
opts.activeProviderId !== undefined ? opts.activeProviderId : selectedProviderId;
const memoryProviderId =
opts.memoryProviderId !== undefined ? opts.memoryProviderId : effectiveSourceId;
+ // Agent 在另一台电脑运行的任务:模型属于那台的目录,不写回本机的新建任务记忆;
+ // 档位与 Fast 只记进本机为那台电脑单独记的一份(换模后意图期调档也走这里)。
+ if (agentDeviceId) {
+ rememberCatalogModelPrefs(agentDeviceId, agentKind, memoryProviderId, modelId, patch);
+ return;
+ }
const remoteDeviceId =
opts.remoteDeviceId ?? getSessionDeviceId(sessionId) ?? deviceLinkDeviceId;
const markModelChoice = opts.markModelChoice === true;
@@ -6821,21 +6852,29 @@ export function ChatInput({
const syncedEffort = authoritative ? authoritative.effort : newEffort;
const syncedFast = authoritative ? authoritative.fastMode : targetFast;
const syncedProviderId = authoritative ? authoritative.providerId : providerId;
- // 换电脑的选择属于目标电脑的目录,不写进本机的新建任务记忆。
- if (relocateTo === undefined) syncSessionDraftModelPrefs(
- newModelId,
- {
- ...(syncedEffort ? { effort: syncedEffort } : {}),
- ...(syncedFast !== undefined ? { fast: syncedFast } : {}),
- },
- {
+ const syncedPatch = {
+ ...(syncedEffort ? { effort: syncedEffort } : {}),
+ ...(syncedFast !== undefined ? { fast: syncedFast } : {}),
+ };
+ // 换电脑的选择属于目标电脑的目录:不写进本机的新建任务记忆,档位与 Fast 记进目标
+ // 那份目录的记忆(意图期再调档同样落在这里)。
+ if (relocateTo !== undefined) {
+ rememberCatalogModelPrefs(
+ relocateTo,
+ targetAgentKind,
+ syncedProviderId,
+ newModelId,
+ syncedPatch,
+ );
+ } else {
+ syncSessionDraftModelPrefs(newModelId, syncedPatch, {
activeProviderId: syncedProviderId,
memoryProviderId: syncedProviderId,
remoteDeviceId: deviceLinkDeviceId ?? undefined,
agentKind: targetAgentKind,
markModelChoice: true,
- },
- );
+ });
+ }
if (makerChatStore.getSnapshot(sourceSessionId).agentStatus.isRunning) {
toast.success(
t('newChat.chatInput.agentSwitch.deferred', {
@@ -6890,17 +6929,24 @@ export function ChatInput({
}
// 立即切换路径(harness / registry 缺省兜底,生产不走):维持旧收敛语义。
makerChatStore.noteAgentSwitched(sourceSessionId, targetAgentKind);
- if (relocateTo === undefined) syncSessionDraftModelPrefs(
- newModelId,
- { effort: newEffort, fast: targetFast },
- {
- activeProviderId: providerId,
- memoryProviderId: providerId,
- remoteDeviceId: deviceLinkDeviceId ?? undefined,
- agentKind: targetAgentKind,
- markModelChoice: true,
- },
- );
+ if (relocateTo !== undefined) {
+ rememberCatalogModelPrefs(relocateTo, targetAgentKind, providerId, newModelId, {
+ effort: newEffort,
+ fast: targetFast,
+ });
+ } else {
+ syncSessionDraftModelPrefs(
+ newModelId,
+ { effort: newEffort, fast: targetFast },
+ {
+ activeProviderId: providerId,
+ memoryProviderId: providerId,
+ remoteDeviceId: deviceLinkDeviceId ?? undefined,
+ agentKind: targetAgentKind,
+ markModelChoice: true,
+ },
+ );
+ }
if (!result.engineReady) {
toast.error(t('newChat.chatInput.agentSwitch.engineNotReady'), { duration: 4000 });
}
@@ -7084,6 +7130,7 @@ export function ChatInput({
devices: remoteAgentDevices,
selectedDeviceId: effectiveAgentDeviceId,
localModelMemory: LOCAL_MODEL_MEMORY,
+ deviceModelMemory: agentDeviceModelMemoryAccessors,
onRelocate: async (selection) => {
if (!(await confirmAgentRelocation(selection.agentDevice))) return false;
return performAgentSwitchRef.current(selection.agent, selection.modelId, selection.providerId, {
@@ -7188,15 +7235,15 @@ export function ChatInput({
if (sessionId || settingsLocked) return;
const targetKind = vendorKeyToAgentKind(selection.engine);
// 这一行与当前目录不在同一台电脑(远程 Agent 换落点):记忆按目标目录写 —— 落到本机就写
- // 本机预设;落到另一台电脑就不写(那台的记忆由它自己的草稿播种接管)。
+ // 本机预设;落到另一台电脑就写本机为那台记的那一份。
const crossDevice =
selection.agentDevice !== undefined &&
(selection.agentDevice?.deviceId ?? null) !== agentDeviceId;
- const targetMemory = crossDevice
- ? selection.agentDevice === null
- ? LOCAL_MODEL_MEMORY
- : undefined
- : modelMemory;
+ const targetMemory = !crossDevice
+ ? modelMemory
+ : selection.agentDevice
+ ? agentDeviceModelMemoryAccessors(selection.agentDevice.deviceId)
+ : LOCAL_MODEL_MEMORY;
if (targetKind && selection.providerId && !selection.resetToRecommended) {
if (selection.effort) {
targetMemory?.setEffort(
diff --git a/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx b/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx
index fb0c3020eb..f6be521eb3 100644
--- a/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/ModelSelector.tsx
@@ -115,6 +115,7 @@ import { isModelEnabled, useModelVisibilityVersion } from '@/state/modelVisibili
import { seedDefaultFavorite } from '@/state/modelFavorites';
import { useProviderModelMemoryVersion } from '@/state/providerModelMemory';
import { useDeviceLinkModelMirrorVersion } from '@/state/deviceLinkModelMirror';
+import { useAgentDeviceModelMemoryVersion } from '@/state/agentDeviceModelMemory';
import {
connectedProvidersForAgent,
chatEligibleSourcesForModel,
@@ -664,6 +665,11 @@ export interface RemoteAgentSelectorOptions {
selectedDeviceId: string | null;
/** 本机目录的模型记忆。Agent 当前在其他电脑时,浏览本机目录用它显示各行的档位。 */
localModelMemory?: ModelMemoryAccessors;
+ /**
+ * 本机为某台电脑记的模型记忆。浏览不是 Agent 当前所在的那台电脑的目录时,用它显示 / 记住
+ * 各行的档位与 Fast(当前所在那台走 modelMemory)。
+ */
+ deviceModelMemory?: (deviceId: string) => ModelMemoryAccessors;
/**
* 已建任务传:选中的行不在 Agent 落点那台电脑的目录里 = 把 Agent 挪过去(与跨引擎同一套意图,
* 下一条消息发送时生效)。返回 false = 没有执行(确认被取消 / 登记失败),面板留在原地。
@@ -1219,7 +1225,7 @@ function ModelSelectorContentView({
!remoteAgent || browsingSelectedCatalog
? modelMemoryProp
: remoteBrowse
- ? undefined
+ ? remoteAgent.deviceModelMemory?.(remoteBrowse.deviceId)
: remoteAgent.localModelMemory;
// 列表样式试用开关(本机偏好):footer 的切换按钮 + 面板行样式共用。
const constrainedListMaxHeight = modelListMaxHeightForRows(maxVisibleModelRows);
@@ -1350,10 +1356,14 @@ function ModelSelectorContentView({
const [editTick, setEditTick] = useState(0);
const bump = () => setEditTick((n) => n + 1);
// 跨进程 / 远程改动:device-link push 会直接改底层 store(providerModelMemory /
- // deviceLinkModelMirror),不经本组件的 editTick。订阅两份 store 的版本号,任一变化即重渲染、
- // 重算行 effort/fast 显示(本机用 providerModelMemory,远程用被控端镜像)。
+ // deviceLinkModelMirror),不经本组件的 editTick。订阅三份 store 的版本号,任一变化即重渲染、
+ // 重算行 effort/fast 显示(本机用 providerModelMemory,远程控制用被控端镜像,远程 Agent 用
+ // agentDeviceModelMemory)。
const storeVersion =
- editTick + useProviderModelMemoryVersion() + useDeviceLinkModelMirrorVersion();
+ editTick +
+ useProviderModelMemoryVersion() +
+ useDeviceLinkModelMirrorVersion() +
+ useAgentDeviceModelMemoryVersion();
void storeVersion;
const listRef = useRef<HTMLDivElement | null>(null);
diff --git a/apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx b/apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx
index 98e452deb9..af9462dde1 100644
--- a/apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx
+++ b/apps/desktop/src/renderer/components/new-chat/UnifiedModelPanel.tsx
@@ -18,6 +18,7 @@ import type { Effort } from '@/lib/userPreferences.types';
import { getModelEngineOverride, useModelEnginePrefsVersion } from '@/state/modelEnginePrefs';
import { useModelFavorites, type ModelFavoriteItem } from '@/state/modelFavorites';
import { useProviderModelMemoryVersion } from '@/state/providerModelMemory';
+import { useAgentDeviceModelMemoryVersion } from '@/state/agentDeviceModelMemory';
import { flashScrollbar } from '@/lib/scrollbarAutoHide';
import { MORPH_CONTENT_RESIZE_EVENT } from '@/components/ui/morph-popover';
@@ -345,9 +346,10 @@ export function UnifiedModelPanel({
const remoteFavorites = useRemoteModelFavorites(deviceId);
const favorites = selectionPolicy === 'official' ? NO_FAVORITES : deviceId ? remoteFavorites.items : storedFavorites;
// 引擎 override / 深度 / Fast 三份 store 的版本号:任一变化都要重算行三元组与浮层
- // (其它窗口的 storage 事件、device-link 推送同样经这两个版本号进来)。
+ // (其它窗口的 storage 事件、device-link 推送同样经这两个版本号进来)。远程 Agent 的档位记忆
+ // 是另一份 store,版本号并进 memoryVersion。
const enginePrefsVersion = useModelEnginePrefsVersion();
- const memoryVersion = useProviderModelMemoryVersion();
+ const memoryVersion = useProviderModelMemoryVersion() + useAgentDeviceModelMemoryVersion();
const sessionAgent = sessionEngineFilter?.currentAgent;
diff --git a/apps/desktop/src/renderer/contexts/AuthContext.tsx b/apps/desktop/src/renderer/contexts/AuthContext.tsx
index cbe7670b22..0116395c88 100644
--- a/apps/desktop/src/renderer/contexts/AuthContext.tsx
+++ b/apps/desktop/src/renderer/contexts/AuthContext.tsx
@@ -47,6 +47,7 @@ import { isGhostPanelWindow } from '@/lib/ghostPanelWindow';
import { setModelEnginePrefsOwner } from '@/state/modelEnginePrefs';
import { setModelFavoritesOwner } from '@/state/modelFavorites';
import { setProviderModelMemoryOwner } from '@/state/providerModelMemory';
+import { setAgentDeviceModelMemoryOwner } from '@/state/agentDeviceModelMemory';
import { setFavoriteAnchorMemoryOwner } from '@/state/favoriteAnchorMemory';
import { setNewMakerDraftOwner } from '@/state/newMakerDraft';
import { setModelVisibilityOwner } from '@/state/modelVisibilityPrefs';
@@ -333,6 +334,7 @@ export function AuthProvider({
setDataOwnerGenerationState(state.ownerGeneration);
setNewMakerDraftOwner(state.dataOwnerId);
setProviderModelMemoryOwner(state.dataOwnerId);
+ setAgentDeviceModelMemoryOwner(state.dataOwnerId);
// 模型选择器的持久记忆与 newMakerDraft 同待遇:同一处、同一个 dataOwnerId、
// 登出时同样传 null(state.dataOwnerId 在 signed-out 快照里就是 null,分区键退回
// 无后缀的默认槽)。漏接 = 多账号串号(providerModelMemory 的旧教训)。
diff --git a/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx b/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
index c9271be9b1..79376ba2e2 100644
--- a/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
@@ -116,6 +116,7 @@ import {
setProviderModelFast,
useProviderModelMemoryVersion,
} from '@/state/providerModelMemory';
+import { useAgentDeviceModelMemoryVersion } from '@/state/agentDeviceModelMemory';
import {
deliverRecoverableHandoff,
rememberRecoverableHandoff,
@@ -1560,14 +1561,22 @@ export function NewMakerDraftRoute() {
]);
// 运行 Agent 的电脑只提供模型目录:任务在本机,没有远程草稿默认值,改用本次运行内对这台
- // 电脑的上一次选择(见 agentDeviceDraftMemory)。
+ // 电脑的上一次选择 + 本机为这台电脑记的每模型档位(见 agentDeviceDraftMemory)。
+ const agentDeviceModelMemoryVersion = useAgentDeviceModelMemoryVersion();
const deviceDraftDefaultsReady = isAgentDeviceDraft || remoteDraftState.status === 'ready';
const deviceDraftDefaults = useMemo<RemoteDraftDefaults | null>(
() =>
isAgentDeviceDraft && effectiveAgentDeviceId
? recallAgentDeviceSelection(effectiveAgentDeviceId, capabilityAgentKind)
: remoteDraftState.value,
- [isAgentDeviceDraft, effectiveAgentDeviceId, capabilityAgentKind, remoteDraftState.value],
+ // agentDeviceModelMemoryVersion:档位记忆变了要重新取回,切模型时才按最新档位还原。
+ [
+ isAgentDeviceDraft,
+ effectiveAgentDeviceId,
+ capabilityAgentKind,
+ remoteDraftState.value,
+ agentDeviceModelMemoryVersion,
+ ],
);
// seed dlSel:等被控端 capabilities + 草稿值都就绪后播种。切设备 / vendor 必须重种;同一目标
diff --git a/apps/desktop/src/renderer/features/cc-agent/__tests__/agentDeviceDraftMemory.test.ts b/apps/desktop/src/renderer/features/cc-agent/__tests__/agentDeviceDraftMemory.test.ts
new file mode 100644
index 0000000000..b8ee5a222a
--- /dev/null
+++ b/apps/desktop/src/renderer/features/cc-agent/__tests__/agentDeviceDraftMemory.test.ts
@@ -0,0 +1,139 @@
+/**
+ * 远程 Agent 草稿:切到别的模型再切回来时,还原本机为那台电脑记的该模型档位 / Fast,
+ * 而不是落回目录默认。
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { AgentCapabilities } from '@/hooks/useAgentCapabilities';
+
+class MemLocalStorage {
+ private store = new Map<string, string>();
+ getItem(k: string): string | null {
+ return this.store.has(k) ? (this.store.get(k) as string) : null;
+ }
+ setItem(k: string, v: string): void {
+ this.store.set(k, v);
+ }
+ removeItem(k: string): void {
+ this.store.delete(k);
+ }
+}
+
+beforeEach(() => {
+ const storage = new MemLocalStorage();
+ vi.stubGlobal('window', { localStorage: storage });
+ vi.stubGlobal('localStorage', storage);
+ vi.resetModules();
+});
+
+async function loadModules() {
+ const draftMemory = await import('../agentDeviceDraftMemory');
+ const modelMemory = await import('@/state/agentDeviceModelMemory');
+ const { resolveDeviceLinkDraftDefaults } = await import('../deviceLinkDraftDefaults');
+ return { ...draftMemory, ...modelMemory, resolveDeviceLinkDraftDefaults };
+}
+
+function caps(): AgentCapabilities {
+ return {
+ availableModels: [
+ {
+ id: 'claude-opus-5',
+ displayName: 'Opus 5',
+ contextWindow: 1_000_000,
+ efforts: ['high', 'xhigh'],
+ defaultEffort: 'high',
+ supportsFastMode: true,
+ },
+ {
+ id: 'claude-sonnet-5',
+ displayName: 'Sonnet 5',
+ contextWindow: 1_000_000,
+ efforts: ['low', 'high'],
+ defaultEffort: 'high',
+ supportsFastMode: false,
+ },
+ ],
+ hasFastMode: true,
+ effortLevels: [
+ { id: 'low', displayName: 'Low' },
+ { id: 'high', displayName: 'High' },
+ { id: 'xhigh', displayName: 'X-High' },
+ ],
+ permissionModes: [{ id: 'acceptEdits', displayName: 'Accept edits' }],
+ };
+}
+
+describe('agentDeviceDraftMemory', () => {
+ it('还没选过这台电脑 → null(由目录默认播种)', async () => {
+ const m = await loadModules();
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ expect(m.recallAgentDeviceSelection('dev-a', 'claude-code')).toBeNull();
+ });
+
+ it('取回上一次选择时带上这台电脑的每模型档位', async () => {
+ const m = await loadModules();
+ m.setAgentDeviceModelEffort('dev-a', 'claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ m.rememberAgentDeviceSelection('dev-a', 'claude-code', {
+ model: 'claude-sonnet-5',
+ effort: 'low',
+ fastMode: false,
+ providerId: 'anthropic',
+ });
+ const recalled = m.recallAgentDeviceSelection('dev-a', 'claude-code');
+ expect(recalled?.model).toBe('claude-sonnet-5');
+ expect(recalled?.providerModelMemory?.['claude-code:anthropic']?.effortByModel).toEqual({
+ 'claude-opus-5': 'xhigh',
+ });
+ // 别的电脑不带这份记忆。
+ m.rememberAgentDeviceSelection('dev-b', 'claude-code', {
+ model: 'claude-sonnet-5',
+ effort: 'low',
+ fastMode: false,
+ providerId: 'anthropic',
+ });
+ expect(m.recallAgentDeviceSelection('dev-b', 'claude-code')?.providerModelMemory).toBeUndefined();
+ });
+
+ it('A 设 xhigh+Fast → 切到 B → 切回 A:还原 xhigh 与 Fast,而不是默认 high', async () => {
+ const m = await loadModules();
+ // 在 A 上调档(ChatInput 经读写器写进这台电脑的记忆)。
+ const memory = m.agentDeviceModelMemoryAccessors('dev-a');
+ memory.setChoice?.('claude-code', 'anthropic', 'claude-opus-5', 'xhigh');
+ memory.setFast('claude-code', 'anthropic', 'claude-opus-5', true);
+ // 切到 B 后,「上一次选择」只剩 B。
+ m.rememberAgentDeviceSelection('dev-a', 'claude-code', {
+ model: 'claude-sonnet-5',
+ effort: 'low',
+ fastMode: false,
+ providerId: 'anthropic',
+ });
+
+ const back = m.resolveDeviceLinkDraftDefaults(
+ caps(),
+ m.recallAgentDeviceSelection('dev-a', 'claude-code'),
+ 'claude-opus-5',
+ 'claude-code',
+ );
+ expect(back.model).toBe('claude-opus-5');
+ expect(back.effort).toBe('xhigh');
+ expect(back.fastMode).toBe(true);
+ });
+
+ it('切回从没调过档的模型 → 仍是目录默认', async () => {
+ const m = await loadModules();
+ m.rememberAgentDeviceSelection('dev-a', 'claude-code', {
+ model: 'claude-sonnet-5',
+ effort: 'low',
+ fastMode: false,
+ providerId: 'anthropic',
+ });
+ const back = m.resolveDeviceLinkDraftDefaults(
+ caps(),
+ m.recallAgentDeviceSelection('dev-a', 'claude-code'),
+ 'claude-opus-5',
+ 'claude-code',
+ );
+ expect(back.effort).toBe('high');
+ expect(back.fastMode).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/renderer/features/cc-agent/agentDeviceDraftMemory.ts b/apps/desktop/src/renderer/features/cc-agent/agentDeviceDraftMemory.ts
index 25604a7cff..5f6e139362 100644
--- a/apps/desktop/src/renderer/features/cc-agent/agentDeviceDraftMemory.ts
+++ b/apps/desktop/src/renderer/features/cc-agent/agentDeviceDraftMemory.ts
@@ -4,7 +4,12 @@
* 模型目录属于运行 Agent 的那台电脑,不能写进本机草稿记忆(lastByVendor / 模型预设)——
* 否则回到本机任务时会带着本机没有的模型。这里按「电脑 + Agent」记住上一次的选择,
* 只在本次运行内有效,与草稿里的 agentDeviceId 一样不跨重启。
+ *
+ * 每个模型各自的档位 / Fast 另由 agentDeviceModelMemory 按电脑持久化(跨重启);取回上一次
+ * 选择时一并带上那台电脑的这份记忆,切到别的模型时据此还原该模型的档位。
*/
+import { snapshotAgentDeviceModelMemory } from '@/state/agentDeviceModelMemory';
+
import type { DeviceLinkDraftSelection, RemoteDraftDefaults } from './deviceLinkDraftDefaults';
const memory = new Map<string, RemoteDraftDefaults>();
@@ -28,7 +33,10 @@ export function rememberAgentDeviceSelection(
}
export function recallAgentDeviceSelection(deviceId: string, agentKind: string): RemoteDraftDefaults | null {
- return memory.get(key(deviceId, agentKind)) ?? null;
+ const last = memory.get(key(deviceId, agentKind));
+ if (!last) return null;
+ const providerModelMemory = snapshotAgentDeviceModelMemory(deviceId);
+ return providerModelMemory ? { ...last, providerModelMemory } : last;
}
/** 测试用。 */
diff --git a/apps/desktop/src/renderer/state/agentDeviceModelMemory.ts b/apps/desktop/src/renderer/state/agentDeviceModelMemory.ts
new file mode 100644
index 0000000000..0483eccea0
--- /dev/null
+++ b/apps/desktop/src/renderer/state/agentDeviceModelMemory.ts
@@ -0,0 +1,385 @@
+/**
+ * agentDeviceModelMemory —— 远程 Agent(Agent 在同账号另一台电脑上运行)的模型档位记忆:
+ * 按「电脑 + Agent + 供应商 + 模型」记 effort / Fast / thinking,localStorage 持久化,跨任务、
+ * 跨重启在本机生效。
+ *
+ * 为什么单独一份(而非复用 providerModelMemory):
+ * 远程 Agent 用的是那台电脑的供应商目录,来源 id 与本机的不是一回事(同叫 anthropic,可能是
+ * 两个不同账号)。写进本机 providerModelMemory 会让本机任务带上那台的档位;而且本机那份
+ * 会经 snapshotForSeed 同步给 main 与远程控制端,混进来会被当成本机的模型预设。
+ * 也不写回那台电脑自己的记忆:远程调用只借用它的供应商,不改它本地的设置。
+ *
+ * 表里只存用户改过的值(override):没有该键 ⇒ 跟随那台电脑目录的当前默认;「恢复推荐」= 删键。
+ *
+ * 按 dataOwnerId 分区持久化(setAgentDeviceModelMemoryOwner),与 providerModelMemory 同一处切换,
+ * 避免多账号互相继承档位。写入频率极低(只在用户改档 / 选模型时),同步写 localStorage,不做
+ * batch / debounce —— 与 providerModelMemory 的取舍一致(热更新 relaunch 强退不丢最近一次改动)。
+ */
+
+import { useSyncExternalStore } from 'react';
+
+import type { ModelMemoryAccessors } from '@/components/new-chat/ModelSelector';
+import type { AgentKind } from '@/hooks/useAgentCapabilities';
+import type { Effort } from '@/lib/userPreferences.types';
+
+const STORAGE_KEY = 'xdt:agentDeviceModelMemory:v1';
+
+/** 某台电脑某 (agent, 来源) 下每个模型的 override。 */
+interface Slot {
+ effortByModel: Record<string, Effort>;
+ fastByModel: Record<string, boolean>;
+ thinkingByModel: Record<string, boolean>;
+}
+
+/** deviceId → (`${agent}:${providerId}` → Slot)。 */
+type MemoryMap = Record<string, Record<string, Slot>>;
+
+/** 与 providerModelMemory snapshot 同形,供 resolveDeviceLinkDraftDefaults 按目标模型还原档位。 */
+export type AgentDeviceModelMemorySnapshot = Record<
+ string,
+ {
+ effortByModel: Record<string, string>;
+ fastByModel: Record<string, boolean>;
+ thinkingByModel: Record<string, boolean>;
+ }
+>;
+
+type SlotField = keyof Slot;
+
+let activeDataOwnerId: string | null = null;
+
+function storageKey(): string {
+ return activeDataOwnerId
+ ? `${STORAGE_KEY}:${encodeURIComponent(activeDataOwnerId)}`
+ : STORAGE_KEY;
+}
+
+function slotKey(agent: AgentKind, providerId: string): string {
+ return `${agent}:${providerId}`;
+}
+
+function sanitizeRecord<T extends string | boolean>(
+ raw: unknown,
+ valid: (value: unknown) => value is T,
+): Record<string, T> {
+ const out: Record<string, T> = {};
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out;
+ for (const [model, value] of Object.entries(raw as Record<string, unknown>)) {
+ if (model && valid(value)) out[model] = value;
+ }
+ return out;
+}
+
+const isEffort = (value: unknown): value is Effort =>
+ typeof value === 'string' && value.length > 0;
+const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';
+
+function isEmptySlot(slot: Slot): boolean {
+ return (
+ Object.keys(slot.effortByModel).length === 0 &&
+ Object.keys(slot.fastByModel).length === 0 &&
+ Object.keys(slot.thinkingByModel).length === 0
+ );
+}
+
+/** 损坏 / 手改的 localStorage 静默收敛,空槽、空设备一并丢弃。 */
+function sanitize(raw: unknown): MemoryMap {
+ const out: MemoryMap = {};
+ if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return out;
+ for (const [deviceId, slots] of Object.entries(raw as Record<string, unknown>)) {
+ if (!deviceId || !slots || typeof slots !== 'object' || Array.isArray(slots)) continue;
+ const bySlot: Record<string, Slot> = {};
+ for (const [key, value] of Object.entries(slots as Record<string, unknown>)) {
+ if (!key || !value || typeof value !== 'object') continue;
+ const rec = value as Partial<Record<SlotField, unknown>>;
+ const slot: Slot = {
+ effortByModel: sanitizeRecord(rec.effortByModel, isEffort),
+ fastByModel: sanitizeRecord(rec.fastByModel, isBoolean),
+ thinkingByModel: sanitizeRecord(rec.thinkingByModel, isBoolean),
+ };
+ if (!isEmptySlot(slot)) bySlot[key] = slot;
+ }
+ if (Object.keys(bySlot).length > 0) out[deviceId] = bySlot;
+ }
+ return out;
+}
+
+// 进程内缓存(惰性加载)。读多写少,避免每次读都 parse localStorage。
+let cache: MemoryMap | null = null;
+
+function loadFromStorage(): MemoryMap {
+ if (typeof window === 'undefined') return {};
+ try {
+ const raw = window.localStorage.getItem(storageKey());
+ return raw ? sanitize(JSON.parse(raw)) : {};
+ } catch {
+ return {};
+ }
+}
+
+function load(): MemoryMap {
+ if (!cache) cache = loadFromStorage();
+ return cache;
+}
+
+/**
+ * 写前重读当前 owner 分区,避免另一个 renderer 刚写入的值被本窗口旧缓存整表覆盖。
+ * localStorage 不可读时保留本窗口内存态,不能用空表抹掉尚未成功持久化的用户选择。
+ */
+function freshMap(): MemoryMap {
+ if (typeof window === 'undefined') return load();
+ let raw: string | null;
+ try {
+ raw = window.localStorage.getItem(storageKey());
+ } catch {
+ return load();
+ }
+ if (raw === null) return load();
+ try {
+ return sanitize(JSON.parse(raw));
+ } catch {
+ return load();
+ }
+}
+
+const listeners = new Set<() => void>();
+let version = 0;
+function emit(): void {
+ version++;
+ for (const listener of listeners) listener();
+}
+function subscribe(listener: () => void): () => void {
+ listeners.add(listener);
+ return () => listeners.delete(listener);
+}
+function getVersion(): number {
+ return version;
+}
+
+/** React hook —— 订阅变更版本号(模型面板据此重算各行的档位 / Fast 显示)。 */
+export function useAgentDeviceModelMemoryVersion(): number {
+ return useSyncExternalStore(subscribe, getVersion, getVersion);
+}
+
+function persist(next: MemoryMap): void {
+ cache = next;
+ emit();
+ if (typeof window === 'undefined') return;
+ try {
+ window.localStorage.setItem(storageKey(), JSON.stringify(next));
+ } catch {
+ // 写不进去时保留本窗口内存态,本次运行内仍然记得;下一次写入会再整表尝试落盘。
+ }
+}
+
+const removeStorageListener = (() => {
+ if (typeof window === 'undefined' || typeof window.addEventListener !== 'function') return null;
+ const onStorage = (event: StorageEvent): void => {
+ if (event.storageArea && event.storageArea !== window.localStorage) return;
+ if (event.key !== null && event.key !== storageKey()) return;
+ // storage 事件可能迟到,event.newValue 不是当前真相;始终重读当前 owner 分区。
+ cache = loadFromStorage();
+ emit();
+ };
+ window.addEventListener('storage', onStorage);
+ return () => window.removeEventListener('storage', onStorage);
+})();
+
+if (import.meta.hot) {
+ import.meta.hot.dispose(() => {
+ removeStorageListener?.();
+ });
+}
+
+function readSlot(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+): Slot | undefined {
+ if (!deviceId || !providerId || !model) return undefined;
+ return load()[deviceId]?.[slotKey(agent, providerId)];
+}
+
+/** 写一个模型键;value 为 undefined = 删键(跟随默认)。同值 / 本就没有时短路,不落盘。 */
+function writeValue<F extends SlotField>(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+ field: F,
+ value: Slot[F][string] | undefined,
+): void {
+ if (!deviceId || !providerId || !model) return;
+ const map = freshMap();
+ const key = slotKey(agent, providerId);
+ const device = map[deviceId] ?? {};
+ const slot = device[key] ?? { effortByModel: {}, fastByModel: {}, thinkingByModel: {} };
+ // 磁盘已是目标值:不落盘。本窗口缓存若还是旧的,别窗那笔写入的 storage 事件会刷新它。
+ if (slot[field][model] === value) return;
+ const nextField = { ...slot[field] } as Record<string, Slot[F][string]>;
+ if (value === undefined) delete nextField[model];
+ else nextField[model] = value;
+ const nextSlot = { ...slot, [field]: nextField } as Slot;
+ const nextDevice = { ...device };
+ if (isEmptySlot(nextSlot)) delete nextDevice[key];
+ else nextDevice[key] = nextSlot;
+ const next = { ...map };
+ if (Object.keys(nextDevice).length === 0) delete next[deviceId];
+ else next[deviceId] = nextDevice;
+ persist(next);
+}
+
+export function getAgentDeviceModelEffort(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+): Effort | undefined {
+ return readSlot(deviceId, agent, providerId, model)?.effortByModel[model];
+}
+
+export function setAgentDeviceModelEffort(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+ effort: Effort,
+): void {
+ if (!effort) return;
+ writeValue(deviceId, agent, providerId, model, 'effortByModel', effort);
+}
+
+export function clearAgentDeviceModelEffort(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+): void {
+ writeValue(deviceId, agent, providerId, model, 'effortByModel', undefined);
+}
+
+export function getAgentDeviceModelFast(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+): boolean | undefined {
+ return readSlot(deviceId, agent, providerId, model)?.fastByModel[model];
+}
+
+export function setAgentDeviceModelFast(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+ enabled: boolean,
+): void {
+ writeValue(deviceId, agent, providerId, model, 'fastByModel', enabled);
+}
+
+export function clearAgentDeviceModelFast(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+): void {
+ writeValue(deviceId, agent, providerId, model, 'fastByModel', undefined);
+}
+
+export function getAgentDeviceModelThinking(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+): boolean | undefined {
+ return readSlot(deviceId, agent, providerId, model)?.thinkingByModel[model];
+}
+
+export function setAgentDeviceModelThinking(
+ deviceId: string,
+ agent: AgentKind,
+ providerId: string,
+ model: string,
+ enabled: boolean,
+): void {
+ writeValue(deviceId, agent, providerId, model, 'thinkingByModel', enabled);
+}
+
+/** 某台电脑的全部 override 快照(深拷贝);没有记录时返回 undefined。 */
+export function snapshotAgentDeviceModelMemory(
+ deviceId: string,
+): AgentDeviceModelMemorySnapshot | undefined {
+ const device = deviceId ? load()[deviceId] : undefined;
+ if (!device) return undefined;
+ const out: AgentDeviceModelMemorySnapshot = {};
+ for (const [key, slot] of Object.entries(device)) {
+ out[key] = {
+ effortByModel: { ...slot.effortByModel },
+ fastByModel: { ...slot.fastByModel },
+ thinkingByModel: { ...slot.thinkingByModel },
+ };
+ }
+ return out;
+}
+
+// 读写器按 deviceId 缓存,引用稳定(选择器 / 面板把它放进 memo 依赖)。读写都在调用时取当前
+// owner 分区,所以切账号不需要重建。
+const accessorsByDevice = new Map<string, ModelMemoryAccessors>();
+
+/** 给模型选择器注入的读写器:读写这台电脑的档位记忆。 */
+export function agentDeviceModelMemoryAccessors(deviceId: string): ModelMemoryAccessors {
+ let accessors = accessorsByDevice.get(deviceId);
+ if (!accessors) {
+ accessors = {
+ getEffort: (agent, providerId, model) =>
+ getAgentDeviceModelEffort(deviceId, agent, providerId, model),
+ setEffort: (agent, providerId, model, effort) =>
+ setAgentDeviceModelEffort(deviceId, agent, providerId, model, effort),
+ // 这里没有「来源上次选中的模型」要记,选中与只改档写的是同一份 override。
+ setChoice: (agent, providerId, model, effort) =>
+ setAgentDeviceModelEffort(deviceId, agent, providerId, model, effort),
+ getFast: (agent, providerId, model) =>
+ getAgentDeviceModelFast(deviceId, agent, providerId, model),
+ setFast: (agent, providerId, model, enabled) =>
+ setAgentDeviceModelFast(deviceId, agent, providerId, model, enabled),
+ getThinking: (agent, providerId, model) =>
+ getAgentDeviceModelThinking(deviceId, agent, providerId, model),
+ setThinking: (agent, providerId, model, enabled) =>
+ setAgentDeviceModelThinking(deviceId, agent, providerId, model, enabled),
+ clearEffort: (agent, providerId, model) =>
+ clearAgentDeviceModelEffort(deviceId, agent, providerId, model),
+ clearFast: (agent, providerId, model) =>
+ clearAgentDeviceModelFast(deviceId, agent, providerId, model),
+ };
+ accessorsByDevice.set(deviceId, accessors);
+ }
+ return accessors;
+}
+
+/** 随认证 dataOwnerId 切换命名空间,和 providerModelMemory / newMakerDraft 同步。 */
+export function setAgentDeviceModelMemoryOwner(ownerId: string | null): void {
+ const normalized = typeof ownerId === 'string' && ownerId.trim().length > 0 ? ownerId : null;
+ if (activeDataOwnerId === normalized) return;
+ activeDataOwnerId = normalized;
+ cache = null;
+ emit();
+}
+
+/** 测试用 —— 重置缓存 + 清 localStorage(其它代码不应调用)。 */
+export function __resetForTest(): void {
+ const keyBeforeReset = storageKey();
+ cache = null;
+ accessorsByDevice.clear();
+ if (typeof window !== 'undefined') {
+ try {
+ window.localStorage.removeItem(keyBeforeReset);
+ window.localStorage.removeItem(STORAGE_KEY);
+ } catch {
+ // ignore
+ }
+ }
+ activeDataOwnerId = null;
+}
+
+export const __STORAGE_KEY = STORAGE_KEY;