Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* providerModelMemory —— 按「(agent, model) → effort / fast」记全局模型预设,外加每个来源
* 「上次选中的模型」,localStorage 持久化,跨会话 / 跨重启在本机生效。
*
* 背景:
* 用户把思考深度 / Fast 理解成「这个模型的默认设置」,而不是「这个来源下这个模型的设置」。
* 因此在首页调整 Opus 后,其它对话里的 Opus 非选中行也必须立即看到同一预设,即便两个页面
* 分别把 Opus 路由到 Anthropic / XD。当前正在使用 Opus 的会话仍由 live DB/runtime 值保护,
* 只有切走再切回时才采用最新全局预设。
*
* 此前 renderer 有三层模型记忆:
* 1) per-vendor 草稿默认(newMakerDraft.lastByVendor,历史上还有服务端全局单槽,已移除);
* 2) per-session(sessions 表 model/effort/providerId 各一份);
* 3) per-model effort(effortByModel,只按 modelId 记)。
* 本 store 现在明确把模型预设放在 `${agent}:*` 全局槽,同时保留来源槽的 lastModel,用于切来源
* 时落到正确的模型。来源槽里的 effort/fast 仅作为 v2 旧数据 / 旧客户端兼容副本,读取时全局槽优先。
*
* 谁读谁写:
* - 写:ChatInput —— 用户真正选定 (model, effort) 后更新全局模型预设 + 该来源 lastModel
* (setProviderModelChoice);只编辑非选中模型时仅更新预设、不改 lastModel
* (setProviderModelEffort)。
* - 读:
* · ModelSelector 的 resolveSourceSwitch —— 切来源时取该来源 lastModel + 其 effort
* (getProviderModelChoice)作为落点 hint;
* · ChatInput 的 effort 解析 —— 选回某 model 时恢复全局预设,再按目标来源 capability 校验
* (getProviderModelEffort)。
*
* key 设计:`${agentKind}:${providerId}` → ProviderMemory,`${agentKind}:*` → 全局模型预设。
* xd 来源同时服务 cc / codex 两个 agent,若只按 providerId 分槽,cc 会话与 codex 会话会
* 互相覆盖对方在 xd 下的选择。agent 维度始终保留;只有同 agent 的同 model 才跨来源共享预设。
*
* 按 dataOwnerId 分区持久化;升级时首个稳定 owner 一次性认领旧设备全局快照,避免多账号
* 互相继承 effort / Fast。持久化频率极低(仅用户点 dropdown 触发),同步写 localStorage,不做 batch / debounce
* —— 与 newMakerDraft 的取舍一致(避免热更新 relaunch 强退丢最近一次改动)。
*
* 版本:STORAGE_KEY 为 v2(多槽)。未建立 owner 分区前若只有历史 v1(单槽 {model,effort})
* 数据,仍可迁移为首个 owner 的 v2 快照,不破坏老用户的「来源 lastModel」连续性。
*/
import { useSyncExternalStore } from 'react';
import type { AgentKind } from '@/hooks/useAgentCapabilities';
import type { Effort } from '@/lib/userPreferences.types';
const STORAGE_KEY = 'xdt:providerModelMemory:v2';
/** 历史单槽版本 key —— 冷启动迁移源(只读,不再写)。 */
const LEGACY_STORAGE_KEY_V1 = 'xdt:providerModelMemory:v1';
/** v2 schema 内的保留来源 id:同一 agent 下跨真实 provider 共享的模型级预设槽。 */
// 定义在 modelConfigCopy(配置副本的归一化要拒绝它),这里 re-export 给既有消费方。
import { MODEL_PRESET_SLOT_ID } from './modelConfigCopy';
export { MODEL_PRESET_SLOT_ID };
let activeDataOwnerId: string | null = null;
function ownerStorageKey(ownerId: string): string {
return `${STORAGE_KEY}:${encodeURIComponent(ownerId)}`;
}
function storageKey(): string {
return activeDataOwnerId ? ownerStorageKey(activeDataOwnerId) : STORAGE_KEY;
}
/**
* 单个来源槽:真实来源槽记「上次选中的模型」+ 兼容副本;`*` 槽记权威模型级 effort / fast。
* lastModel 可为空(只记过 effort/fast 没法确定 lastModel 的脏数据);
* lastModel 或任一模型预设非空就保留。
*/
interface ProviderMemory {
lastModel: string;
effortByModel: Record<string, Effort>;
fastByModel: Record<string, boolean | 'ultrafast'>;
thinkingByModel: Record<string, boolean>;
}
/** getProviderModelChoice 的返回形状(该来源上次的 model + 其 effort)。供 resolveSourceSwitch 消费。 */
export interface ProviderModelChoice {
model: string;
effort: Effort;
}
function keyOf(agent: AgentKind, providerId: string): string {
return `${agent}:${providerId}`;
}
function presetKeyOf(agent: AgentKind): string {
return keyOf(agent, MODEL_PRESET_SLOT_ID);
}
/** `${agent}` → 该 agent 的 slot key(反推用;agent 名本身不含 `:`)。 */
function agentOfSlotKey(key: string): AgentKind | undefined {
const sep = key.indexOf(':');
if (sep <= 0) return undefined;
const agent = key.slice(0, sep);
return agent === 'claude-code' || agent === 'codex' || agent === 'pi' ? agent : undefined;
}
/**
* **v2 历史数据回填**:`set-effort` 在旧版本只写来源槽,`*` 权威槽从来没被写过。
* 若直接把读路径改成「全局优先」,老用户的全部预设会一次性消失 —— 所以首次读到旧表时,
* 把各来源槽里已有的值合并进对应的 `${agent}:*` 槽(只补空缺,不覆盖已存在的全局值)。
*
* 冲突时取**首见**值:历史数据无法回溯哪一笔是用户最后一次选择,而来源槽的键序只反映
* 「哪个来源先被写过」,不反映操作时序,取末见反而更随意。用户之后任何一次显式调档都会
* 用真实选择覆盖它,一次性成本可接受。
*
* 只在内存里补,**不主动落盘**:读路径立即看到权威值,下一次真实写入会自然把它带出去;
* 落盘失败 / 只读场景也不会因此产生写副作用。
*/
function backfillGlobalPresets(map: Record<string, ProviderMemory>): Record<string, ProviderMemory> {
const presetEffort = new Map<string, Record<string, Effort>>();
const presetFast = new Map<string, Record<string, boolean | 'ultrafast'>>();
const presetThinking = new Map<string, Record<string, boolean>>();
for (const [key, slot] of Object.entries(map)) {
const agent = agentOfSlotKey(key);
if (!agent) continue;
if (key.slice(key.indexOf(':') + 1) === MODEL_PRESET_SLOT_ID) continue;
const presetKey = presetKeyOf(agent);
const effort = presetEffort.get(presetKey) ?? {};
for (const [model, value] of Object.entries(slot.effortByModel)) {
if (!(model in effort)) effort[model] = value;
}
const fast = presetFast.get(presetKey) ?? {};
for (const [model, value] of Object.entries(slot.fastByModel)) {
if (!(model in fast)) fast[model] = value;
}
const thinking = presetThinking.get(presetKey) ?? {};
for (const [model, value] of Object.entries(slot.thinkingByModel)) {
if (!(model in thinking)) thinking[model] = value;
}
presetEffort.set(presetKey, effort);
presetFast.set(presetKey, fast);
presetThinking.set(presetKey, thinking);
}
const out: Record<string, ProviderMemory> = { ...map };
let changed = false;
const merge = (
target: Record<string, Effort | boolean>,
source: Record<string, Effort | boolean> | undefined,
): boolean => {
let touched = false;
if (!source) return touched;
for (const [model, value] of Object.entries(source)) {
if (model in target) continue;
target[model] = value;
touched = true;
}
return touched;
};
for (const [presetKey, effort] of presetEffort) {
const existing = out[presetKey];
const nextEffort: Record<string, Effort> = { ...(existing?.effortByModel ?? {}) };
const nextFast: Record<string, boolean | 'ultrafast'> = { ...(existing?.fastByModel ?? {}) };
const nextThinking: Record<string, boolean> = { ...(existing?.thinkingByModel ?? {}) };
// 三个维度必须**逐个**合并:写成 `merge(a) || merge(b) || merge(c)` 会因为短路
// 在第一个命中后就跳过剩下的 —— 只回填 effort 而漏掉 fast / thinking,与回填本身
// 要消灭的「跨来源丢档位」是同一类缺陷。
let touched = merge(nextEffort, effort);
touched = merge(nextFast, presetFast.get(presetKey)) || touched;
touched = merge(nextThinking, presetThinking.get(presetKey)) || touched;
if (!touched) continue;
out[presetKey] = {
lastModel: existing?.lastModel ?? '',
effortByModel: nextEffort,
fastByModel: nextFast,
thinkingByModel: nextThinking,
};
changed = true;
}
return changed ? out : map;
}
/** sanitize + 历史全局槽回填。localStorage 的每个读出口都走它,两条路径口径才一致。 */
function readMap(raw: unknown): Record<string, ProviderMemory> {
return backfillGlobalPresets(sanitize(raw));
}
/**
* 严格校验 v2:每个槽收敛成 { lastModel, effortByModel },其中 effortByModel 只保留
* model / effort 都是非空 string 的条目;lastModel 和预设都为空才丢弃。
* 老版本 / 手改 localStorage 损坏时静默回退空表(不抛)。
*/
function sanitize(raw: unknown): Record<string, ProviderMemory> {
if (!raw || typeof raw !== 'object') return {};
const out: Record<string, ProviderMemory> = {};
for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
if (!k || !v || typeof v !== 'object') continue;
const rec = v as {
lastModel?: unknown;
effortByModel?: unknown;
fastByModel?: unknown;
thinkingByModel?: unknown;
};
const effortByModel: Record<string, Effort> = {};
if (
rec.effortByModel &&
typeof rec.effortByModel === 'object' &&
!Array.isArray(rec.effortByModel)
) {
for (const [mid, eff] of Object.entries(rec.effortByModel as Record<string, unknown>)) {
if (mid && typeof eff === 'string' && eff.length > 0) effortByModel[mid] = eff as Effort;
}
}
const fastByModel: Record<string, boolean | 'ultrafast'> = {};
if (rec.fastByModel && typeof rec.fastByModel === 'object' && !Array.isArray(rec.fastByModel)) {
for (const [mid, fb] of Object.entries(rec.fastByModel as Record<string, unknown>)) {
if (mid && (typeof fb === 'boolean' || fb === 'ultrafast')) fastByModel[mid] = fb;
}
}
const thinkingByModel: Record<string, boolean> = {};
if (
rec.thinkingByModel &&
typeof rec.thinkingByModel === 'object' &&
!Array.isArray(rec.thinkingByModel)
) {
for (const [mid, tb] of Object.entries(rec.thinkingByModel as Record<string, unknown>)) {
if (mid && typeof tb === 'boolean') thinkingByModel[mid] = tb;
}
}
if (
!(typeof rec.lastModel === 'string' && rec.lastModel.length > 0) &&
Object.keys(effortByModel).length === 0 &&
Object.keys(fastByModel).length === 0 &&
Object.keys(thinkingByModel).length === 0
)
continue;
out[k] = {
lastModel: typeof rec.lastModel === 'string' ? rec.lastModel : '',
effortByModel,
fastByModel,
thinkingByModel,
};
}
return out;
}
/** 迁移历史 v1 单槽({model,effort})→ v2 多槽({lastModel:model, effortByModel:{model:effort}})。 */
function migrateV1(raw: unknown): Record<string, ProviderMemory> {
if (!raw || typeof raw !== 'object') return {};
const out: Record<string, ProviderMemory> = {};
for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
if (!k || !v || typeof v !== 'object') continue;
const model = (v as { model?: unknown }).model;
const effort = (v as { effort?: unknown }).effort;
if (
typeof model === 'string' &&
model.length > 0 &&
typeof effort === 'string' &&
effort.length > 0
) {
out[k] = {
lastModel: model,
effortByModel: { [model]: effort as Effort },
fastByModel: {},
thinkingByModel: {},
};
}
}
return out;
}
/**
* 旧版只有一份设备全局快照。升级后的第一个稳定 owner 一次性认领它;随后删除旧 key,
* 其它账号只读各自命名空间,避免 A 的 effort / Fast 让 B 被误判为已自定义。
*/
function migrateLegacyToOwner(ownerId: string): void {
if (typeof window === 'undefined') return;
try {
const scopedKey = ownerStorageKey(ownerId);
if (window.localStorage.getItem(scopedKey) !== null) return;
const rawV2 = window.localStorage.getItem(STORAGE_KEY);
const rawV1 = window.localStorage.getItem(LEGACY_STORAGE_KEY_V1);
const migrated = rawV2
? backfillGlobalPresets(sanitize(JSON.parse(rawV2)))
: rawV1
? backfillGlobalPresets(migrateV1(JSON.parse(rawV1)))
: null;
if (!migrated) return;
window.localStorage.setItem(scopedKey, JSON.stringify(migrated));
if (window.localStorage.getItem(scopedKey) === null) return;
window.localStorage.removeItem(STORAGE_KEY);
window.localStorage.removeItem(LEGACY_STORAGE_KEY_V1);
} catch {
// 认领失败时保留旧 key;当前 owner 按空分区运行,绝不把未归属数据串给其它账号。
}
}
// 进程内缓存(惰性加载)。读多写少,避免每次读都 parse localStorage。
let cache: Record<string, ProviderMemory> | null = null;
/** 一次用户写入的最小表达;写盘失败后重放到最新共享快照,不能保存并覆盖整张旧表。 */
type ProviderMemoryOp =
| {
kind: 'set-effort';
agent: AgentKind;
providerId: string;
model: string;
effort: Effort;
}
| { kind: 'set-last-model'; agent: AgentKind; providerId: string; model: string }
| { kind: 'set-fast'; agent: AgentKind; providerId: string; model: string; enabled: boolean | 'ultrafast' }
| { kind: 'set-thinking'; agent: AgentKind; providerId: string; model: string; enabled: boolean }
| { kind: 'clear-effort'; agent: AgentKind; providerId: string; model: string }
| { kind: 'clear-fast'; agent: AgentKind; providerId: string; model: string };
interface PendingProviderMemoryOp {
op: ProviderMemoryOp;
/** 首次写失败前该字段的共享值;恢复时已变化说明别窗有更新,本旧操作必须退休。 */
baseline: {
providerValue: Effort | boolean | undefined;
lastModel: string;
presetValue: Effort | boolean | undefined;
/**
* clear-effort / clear-fast 额外要看的写集:该 agent 下、该模型在**每个**来源槽里
* 的值(全来源清除会连它们一起删)。只记 providerValue + presetValue 是不够的 ——
* 别的窗口改了第三个来源时这两个都没变,旧清除会按陈旧快照把别人的新值删掉。
* set-* 与 set-last-model 不写这个字段。
*/
clearedSlots?: Record<string, Effort | boolean | undefined>;
};
conflictKey: string;
}
/** localStorage 临时不可写时只留本窗口未落盘的操作,按 owner 隔离。 */
const pendingOpsByStorageKey = new Map<string, PendingProviderMemoryOp[]>();
const MAX_PENDING_OPS_PER_KEY = 100;
function sameRecord<T extends string | boolean>(
left: Record<string, T>,
right: Record<string, T>,
): boolean {
const leftKeys = Object.keys(left);
const rightKeys = Object.keys(right);
return leftKeys.length === rightKeys.length && leftKeys.every((key) => left[key] === right[key]);
}
function sameMap(
left: Record<string, ProviderMemory>,
right: Record<string, ProviderMemory>,
): boolean {
const leftKeys = Object.keys(left);
const rightKeys = Object.keys(right);
return (
leftKeys.length === rightKeys.length &&
leftKeys.every((key) => {
const a = left[key];
const b = right[key];
return Boolean(
a &&
b &&
a.lastModel === b.lastModel &&
sameRecord(a.effortByModel, b.effortByModel) &&
sameRecord(a.fastByModel, b.fastByModel) &&
sameRecord(a.thinkingByModel, b.thinkingByModel),
);
})
);
}
/**
* 把一次用户写入应用到整表。
*
* **模型级维度(effort / fast / thinking)双写**:`${agent}:*` 权威槽 + `${agent}:${providerId}`
* 来源兼容副本。只写来源槽会让 doc 承诺的「同模型跨来源共享」落空(旧版本正是如此:
* `*` 槽只被 clear 分支扫过,从不被写也不被读,实际生效的是分散的来源槽 —— 于是同一模型
* 换个来源就换回旧档位,表现为「推理强度自己变低」)。来源副本留给旧 v2 客户端与旧
* device-link 快照继续工作。
*
* `lastModel` 仍是来源维度(它回答的是「这个来源上次选的是哪个模型」),不双写。
*/
/**
* clear-effort / clear-fast 的**全来源写集**:该 agent 下、该模型在除权威槽以外每个来源
* 槽里的当前值,以及删掉该键后的槽。apply 与冲突基线都从这里取,两边口径不会漂移。
*/
function clearedSourceValues(
map: Record<string, ProviderMemory>,
op: ProviderMemoryOp,
): {
/** 槽 key → 删键后的槽(只含有该键的槽;空 = 没有可删的副本)。 */
nextSlots: Record<string, ProviderMemory>;
/** 槽 key → 删之前的旧值(供写盘失败重放时判断别窗有没有改过它)。 */
values: Record<string, Effort | boolean | undefined>;
} {
const field = op.kind === 'clear-effort' ? 'effortByModel' : 'fastByModel';
const presetKey = presetKeyOf(op.agent);
const nextSlots: Record<string, ProviderMemory> = {};
const values: Record<string, Effort | boolean | undefined> = {};
for (const [key, slot] of Object.entries(map)) {
if (key === presetKey) continue;
if (agentOfSlotKey(key) !== op.agent) continue;
// 记下每个来源槽的当前值,**包括没有该键的槽**(值 undefined):别窗从「无」写
// 成一个具体值也是变化,旧清除同样该退休。
values[key] = slot[field][op.model];
const nextSlot = withoutModelKey(slot, field, op.model);
if (nextSlot) nextSlots[key] = nextSlot;
}
values[keyOf(op.agent, op.providerId)] ??= map[keyOf(op.agent, op.providerId)]?.[field][op.model];
return { nextSlots, values };
}
function applyProviderMemoryOp(
map: Record<string, ProviderMemory>,
op: ProviderMemoryOp,
): Record<string, ProviderMemory> {
const providerKey = keyOf(op.agent, op.providerId);
const provider = map[providerKey];
if (op.kind === 'set-effort') {
// 双写的两个槽都到达目标值才算「无事可做」。只看来源槽会漏写权威槽:两处不同步时
// (旧客户端只写来源槽、或回填只补空缺造成的分歧)用户这次显式选择会被短路丢掉。
if (
provider?.effortByModel[op.model] === op.effort &&
map[presetKeyOf(op.agent)]?.effortByModel[op.model] === op.effort
) {
return map;
}
return {
...map,
[providerKey]: {
lastModel: provider?.lastModel ?? '',
effortByModel: { ...(provider?.effortByModel ?? {}), [op.model]: op.effort },
fastByModel: provider?.fastByModel ?? {},
thinkingByModel: provider?.thinkingByModel ?? {},
},
...withModelKey(map, presetKeyOf(op.agent), 'effortByModel', op.model, op.effort),
};
}
if (op.kind === 'set-last-model') {
if (provider?.lastModel === op.model) return map;
return {
...map,
[providerKey]: {
lastModel: op.model,
effortByModel: provider?.effortByModel ?? {},
fastByModel: provider?.fastByModel ?? {},
thinkingByModel: provider?.thinkingByModel ?? {},
},
};
}
if (op.kind === 'set-fast') {
if (
provider?.fastByModel?.[op.model] === op.enabled &&
map[presetKeyOf(op.agent)]?.fastByModel?.[op.model] === op.enabled
) {
return map;
}
return {
...map,
[providerKey]: {
lastModel: provider?.lastModel ?? '',
effortByModel: provider?.effortByModel ?? {},
fastByModel: { ...(provider?.fastByModel ?? {}), [op.model]: op.enabled },
thinkingByModel: provider?.thinkingByModel ?? {},
},
...withModelKey(map, presetKeyOf(op.agent), 'fastByModel', op.model, op.enabled),
};
}
if (op.kind === 'set-thinking') {
if (
provider?.thinkingByModel?.[op.model] === op.enabled &&
map[presetKeyOf(op.agent)]?.thinkingByModel?.[op.model] === op.enabled
) {
return map;
}
return {
...map,
[providerKey]: {
lastModel: provider?.lastModel ?? '',
effortByModel: provider?.effortByModel ?? {},
fastByModel: provider?.fastByModel ?? {},
thinkingByModel: { ...(provider?.thinkingByModel ?? {}), [op.model]: op.enabled },
},
...withModelKey(map, presetKeyOf(op.agent), 'thinkingByModel', op.model, op.enabled),
};
}
const field = op.kind === 'clear-effort' ? 'effortByModel' : 'fastByModel';
const presetKey = presetKeyOf(op.agent);
const nextProvider = withoutModelKey(provider, field, op.model);
const nextPreset = withoutModelKey(map[presetKey], field, op.model);
// 清除是**全局**语义(「没有该键 ⇒ 跟随当前版本的目录默认」),所以同一个模型在**所有**
// 来源槽里的副本都要删。只删当前来源的话,别的来源那份会被 backfillGlobalPresets
// 补回刚清空的权威槽 —— 用户的「恢复默认」被悄悄撤销(且不需要新旧版本混跑)。
const cleared = clearedSourceValues(map, op);
const clearedAny = Object.keys(cleared.nextSlots).length > 0;
if (!nextProvider && !nextPreset && !clearedAny) return map;
return {
...map,
...cleared.nextSlots,
...(nextProvider ? { [providerKey]: nextProvider } : {}),
...(nextPreset ? { [presetKey]: nextPreset } : {}),
};
}
function opDimension(op: ProviderMemoryOp): 'effort' | 'fast' | 'thinking' | 'last-model' {
if (op.kind === 'set-last-model') return 'last-model';
if (op.kind === 'set-thinking') return 'thinking';
if (op.kind === 'set-fast' || op.kind === 'clear-fast') return 'fast';
return 'effort';
}
function opConflictKey(op: ProviderMemoryOp): string {
if (op.kind === 'set-last-model') return `${keyOf(op.agent, op.providerId)}:last-model`;
return `${keyOf(op.agent, op.providerId)}:${op.model}:${opDimension(op)}`;
}
/** 捕获该维度的完整基线;匹配时再按最终 op 的实际写集选字段。 */
function captureOpConflictBaseline(
map: Record<string, ProviderMemory>,
op: ProviderMemoryOp,
): PendingProviderMemoryOp['baseline'] {
const provider = map[keyOf(op.agent, op.providerId)];
if (op.kind === 'set-last-model') {
return {
providerValue: undefined,
lastModel: provider?.lastModel ?? '',
presetValue: undefined,
};
}
// 三个模型级维度的写集都是「权威槽 + 来源槽」两处,基线必须两处都取 —— 只取来源槽
// 会让权威槽的冲突检查恒通过(两侧都是 undefined),该退休的旧操作不退休。
const preset = map[presetKeyOf(op.agent)];
// clear 的写集是「权威槽 + 所有来源副本」,基线也要这么多值:只取 providerValue +
// presetValue 的话,别的窗口改了第三个来源时这两个都没变,旧清除按陈旧快照重放会把
// 它刚写的新值一并删掉(Greptile 二审 finding)。
if (op.kind === 'clear-effort' || op.kind === 'clear-fast') {
return {
providerValue: undefined,
lastModel: provider?.lastModel ?? '',
// 权威槽的值仍要单独比:clearedSourceValues 为保持「只扫来源副本」的语义刻意跳过
// 权威槽,所以它的变化只能在这里被发现。少了这一项,另一窗口写权威槽、来源值都没
// 变时,旧清除会按陈旧快照重放,把那个新预设删回默认值(Greptile 三审 finding)。
presetValue: op.kind === 'clear-fast'
? preset?.fastByModel[op.model]
: preset?.effortByModel[op.model],
clearedSlots: clearedSourceValues(map, op).values,
};
}
if (opDimension(op) === 'thinking') {
return {
providerValue: provider?.thinkingByModel[op.model],
lastModel: provider?.lastModel ?? '',
presetValue: preset?.thinkingByModel[op.model],
};
}
if (opDimension(op) === 'fast') {
return {
providerValue: provider?.fastByModel[op.model],
lastModel: provider?.lastModel ?? '',
presetValue: preset?.fastByModel[op.model],
};
}
return {
providerValue: provider?.effortByModel[op.model],
lastModel: provider?.lastModel ?? '',
presetValue: preset?.effortByModel[op.model],
};
}
function matchesOpConflictBaseline(
map: Record<string, ProviderMemory>,
pending: PendingProviderMemoryOp,
): boolean {
const { op, baseline } = pending;
const current = captureOpConflictBaseline(map, op);
if (op.kind === 'set-last-model') return current.lastModel === baseline.lastModel;
// set-effort / set-fast / set-thinking 同时写权威槽与来源副本,两个槽都要仍处在基线上;
// 任一被别的窗口改动过,这笔旧操作就退休,不用过期快照覆盖别人的新选择。
if (current.providerValue !== baseline.providerValue) return false;
if (current.presetValue !== baseline.presetValue) return false;
if (baseline.clearedSlots) {
for (const [key, value] of Object.entries(baseline.clearedSlots)) {
const slot = map[key];
const field = op.kind === 'clear-effort' ? 'effortByModel' : 'fastByModel';
if (slot?.[field][op.model] !== value) return false;
}
}
return true;
}
function recordPendingOp(
key: string,
op: ProviderMemoryOp,
base: Record<string, ProviderMemory>,
): void {
const conflictKey = opConflictKey(op);
const current = pendingOpsByStorageKey.get(key) ?? [];
const previous = current.find((entry) => entry.conflictKey === conflictKey);
const next = [
...current.filter((entry) => entry.conflictKey !== conflictKey),
{
op,
conflictKey,
// 同字段多次失败只保留最终意图,但基线必须是第一次失败前的共享值。
baseline: previous?.baseline ?? captureOpConflictBaseline(base, op),
},
];
pendingOpsByStorageKey.set(key, next.slice(-MAX_PENDING_OPS_PER_KEY));
}
function applyPendingOps(
key: string,
map: Record<string, ProviderMemory>,
): Record<string, ProviderMemory> {
let next = map;
const pendingOps = pendingOpsByStorageKey.get(key) ?? [];
const survivors: PendingProviderMemoryOp[] = [];
for (const pending of pendingOps) {
if (!matchesOpConflictBaseline(next, pending)) continue;
survivors.push(pending);
next = applyProviderMemoryOp(next, pending.op);
}
if (survivors.length !== pendingOps.length) {
if (survivors.length > 0) pendingOpsByStorageKey.set(key, survivors);
else pendingOpsByStorageKey.delete(key);
}
return next;
}
function loadFromStorage(): Record<string, ProviderMemory> {
if (typeof window === 'undefined') return {};
try {
const raw = window.localStorage.getItem(storageKey());
return raw ? readMap(JSON.parse(raw)) : {};
} catch {
return {};
}
}
function load(): Record<string, ProviderMemory> {
if (cache) return cache;
const key = storageKey();
if (typeof window === 'undefined') {
cache = {};
return cache;
}
try {
const rawV2 = window.localStorage.getItem(storageKey());
if (rawV2) {
cache = applyPendingOps(key, readMap(JSON.parse(rawV2)));
return cache;
}
// 无 v2 → 尝试从历史 v1 迁移(只灌缓存,下次 set 再落盘 v2)。
const rawV1 = activeDataOwnerId ? null : window.localStorage.getItem(LEGACY_STORAGE_KEY_V1);
cache = applyPendingOps(key, rawV1 ? backfillGlobalPresets(migrateV1(JSON.parse(rawV1))) : {});
} catch {
cache = {};
}
return cache;
}
/**
* 整表写回前重读当前 owner 分区,避免另一个 renderer 刚写入的 override 被本窗口旧缓存覆盖。
* localStorage 不可读时保留本窗口内存态,不能用空表抹掉尚未成功持久化的用户选择。
*/
function freshMap(): Record<string, ProviderMemory> {
if (typeof window === 'undefined') return load();
const key = storageKey();
let raw: string | null;
try {
raw = window.localStorage.getItem(storageKey());
} catch {
return load();
}
if (raw === null) return load();
try {
const stored = readMap(JSON.parse(raw));
const next = applyPendingOps(key, stored);
if (pendingOpsByStorageKey.has(key)) {
try {
if (!sameMap(stored, next)) window.localStorage.setItem(key, JSON.stringify(next));
pendingOpsByStorageKey.delete(key);
} catch {
// 仍不可写:保留最小 op,下一次写入继续在最新共享快照上重放。
}
}
if (cache === null || !sameMap(cache, next)) {
cache = next;
emit();
}
return next;
} catch {
return load();
}
}
// 变更通知:device-link 被控端要把 providerModelMemory 镜像给 main(草稿列表行的真实读源),
// 控制端的镜像 / ModelSelector 也据此重渲染。本窗口 persist 与其它 renderer 的 storage 事件
// 都在采纳最新缓存后 bump version + emit。
const listeners = new Set<() => void>();
let version = 0;
function emit(): void {
version++;
for (const l of listeners) l();
}
function subscribe(listener: () => void): () => void {
listeners.add(listener);
return () => listeners.delete(listener);
}
function getVersion(): number {
return version;
}
/** React hook —— 订阅 providerModelMemory 变更版本号(useSyncExternalStore)。 */
export function useProviderModelMemoryVersion(): number {
return useSyncExternalStore(subscribe, getVersion, getVersion);
}
/** 订阅 providerModelMemory 变更(非 React,如 App.tsx 把快照镜像给 main)。 */
export function subscribeProviderModelMemory(listener: () => void): () => void {
return subscribe(listener);
}
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 分区。
const next = applyPendingOps(storageKey(), loadFromStorage());
if (cache !== null && sameMap(cache, next)) return;
cache = next;
emit();
};
window.addEventListener('storage', onStorage);
return () => window.removeEventListener('storage', onStorage);
})();
if (import.meta.hot) {
import.meta.hot.dispose(() => {
removeStorageListener?.();
});
}
/**
* 是否已有任一模型级预设 override。
*
* 旧版本可能只在本表留下 effort / Fast(或 thinking)而没有 newMakerDraft 的模型标记;
* 这些仍是明确的用户设置,连接态默认组合不得把它们覆盖掉。
*/
export function hasAnyProviderModelOverride(): boolean {
return Object.values(load()).some(
(slot) =>
Object.keys(slot.effortByModel).length > 0 ||
Object.keys(slot.fastByModel).length > 0 ||
Object.keys(slot.thinkingByModel).length > 0,
);
}
/** Saved selections identify an existing profile without creating a settings override. */
export function hasProviderModelHistory(): boolean {
return Object.values(load()).some((slot) => slot.lastModel.length > 0);
}
function persist(
map: Record<string, ProviderMemory>,
ops: ProviderMemoryOp[],
base: Record<string, ProviderMemory>,
): void {
const key = storageKey();
cache = map;
emit();
if (typeof window === 'undefined') return;
try {
window.localStorage.setItem(key, JSON.stringify(map));
pendingOpsByStorageKey.delete(key);
} catch {
// 只记最小操作;恢复可写后重放到最新共享快照,不能用本窗口旧整表覆盖另一 renderer。
for (const op of ops) recordPendingOp(key, op, base);
}
}
/**
* 读某 (agent, 来源) 上次选中的 (model, effort);无记录 / 无法确定 lastModel 返回 undefined。
* 用于切来源时决定落到哪个模型 + 哪一档(resolveSourceSwitch)。
*/
export function getProviderModelChoice(
agent: AgentKind,
providerId: string,
): ProviderModelChoice | undefined {
if (!providerId) return undefined;
const rec = load()[keyOf(agent, providerId)];
if (!rec || !rec.lastModel) return undefined;
// 档位按权威全局槽取(切来源时同一模型应保持用户上一次的选择),来源槽只兜底旧数据。
const effort =
load()[presetKeyOf(agent)]?.effortByModel[rec.lastModel] ?? rec.effortByModel[rec.lastModel];
return effort ? { model: rec.lastModel, effort } : undefined;
}
/**
* 读某 (agent, 模型) 的全局 effort —— `${agent}:*` 权威槽优先,来源槽只作旧数据兜底。
* providerId 仍参与入参保护与旧 v2 兼容读取,但**不再是权威**:同模型跨来源 / 跨对话共享。
*/
export function getProviderModelEffort(
agent: AgentKind,
providerId: string,
model: string,
): Effort | undefined {
if (!providerId || !model) return undefined;
const map = load();
return (
map[presetKeyOf(agent)]?.effortByModel[model] ?? map[keyOf(agent, providerId)]?.effortByModel[model]
);
}
function setModelEffort(
agent: AgentKind,
providerId: string,
model: string,
effort: Effort,
updateLastModel: boolean,
): void {
if (!providerId || providerId === MODEL_PRESET_SLOT_ID || !model || !effort) return;
const map = freshMap();
const ops: ProviderMemoryOp[] = [
{ kind: 'set-effort', agent, providerId, model, effort },
...(updateLastModel
? [{ kind: 'set-last-model', agent, providerId, model } as ProviderMemoryOp]
: []),
];
const next = ops.reduce(applyProviderMemoryOp, map);
if (next === map) return;
persist(next, ops, map);
}
/** 只更新模型级全局 effort,不把「编辑非选中模型」误记为该来源上次选中的模型。 */
export function setProviderModelEffort(
agent: AgentKind,
providerId: string,
model: string,
effort: Effort,
): void {
setModelEffort(agent, providerId, model, effort, false);
}
/**
* 写用户真正选定的 (model, effort):更新该来源 lastModel + 模型级全局 effort。
* 同时保留来源兼容副本,供旧 v2 客户端 / 旧 device-link 快照继续工作。
*/
export function setProviderModelChoice(
agent: AgentKind,
providerId: string,
model: string,
effort: Effort,
): void {
setModelEffort(agent, providerId, model, effort, true);
}
/**
* 读某 (agent, 模型) 的全局 fast —— 权威槽优先,来源槽兜底(同 effort)。
* 显式 false 是有效值,所以用 `??` 而不是 `||`:两个槽都没有才是 undefined(跟随默认)。
*/
export function getProviderModelFast(
agent: AgentKind,
providerId: string,
model: string,
): boolean | 'ultrafast' | undefined {
if (!providerId || !model) return undefined;
const map = load();
return (
map[presetKeyOf(agent)]?.fastByModel?.[model] ?? map[keyOf(agent, providerId)]?.fastByModel?.[model]
);
}
/**
* 写某 (agent, 模型) 的全局 fast,同时保留来源兼容副本;不动 effort / lastModel。同值短路。
*/
export function setProviderModelFast(
agent: AgentKind,
providerId: string,
model: string,
enabled: boolean | 'ultrafast',
): void {
if (!providerId || providerId === MODEL_PRESET_SLOT_ID || !model) return;
const map = freshMap();
const op: ProviderMemoryOp = { kind: 'set-fast', agent, providerId, model, enabled };
const next = applyProviderMemoryOp(map, op);
if (next === map) return;
persist(next, [op], map);
}
export function getProviderModelThinking(
agent: AgentKind,
providerId: string,
model: string,
): boolean | undefined {
if (!providerId || !model) return undefined;
const map = load();
return (
map[presetKeyOf(agent)]?.thinkingByModel?.[model] ??
map[keyOf(agent, providerId)]?.thinkingByModel?.[model]
);
}
export function setProviderModelThinking(
agent: AgentKind,
providerId: string,
model: string,
enabled: boolean,
): void {
if (!providerId || providerId === MODEL_PRESET_SLOT_ID || !model) return;
const map = freshMap();
const op: ProviderMemoryOp = { kind: 'set-thinking', agent, providerId, model, enabled };
const next = applyProviderMemoryOp(map, op);
if (next === map) return;
persist(next, [op], map);
}
/**
* 把某个模型键写进指定槽(一般为 `${agent}:*` 权威槽);槽不存在则新建。
* 只返回需要覆盖的那个键,调用方展开进整表 —— 与 clear 侧只清点名槽同一形状。
*/
function withModelKey<K extends 'effortByModel' | 'fastByModel' | 'thinkingByModel'>(
map: Record<string, ProviderMemory>,
slotKey: string,
field: K,
model: string,
value: string | boolean,
): Record<string, ProviderMemory> {
const slot = map[slotKey];
const nextField = { ...(slot?.[field] ?? {}) };
// 类型上 K 决定 value 的形状;这里按字段取,调用方已保证配对。
(nextField as Record<string, string | boolean>)[model] = value;
return {
[slotKey]: {
lastModel: slot?.lastModel ?? '',
effortByModel: field === 'effortByModel' ? (nextField as Record<string, Effort>) : slot?.effortByModel ?? {},
fastByModel: field === 'fastByModel' ? (nextField as Record<string, boolean | 'ultrafast'>) : slot?.fastByModel ?? {},
thinkingByModel:
field === 'thinkingByModel' ? (nextField as Record<string, boolean>) : slot?.thinkingByModel ?? {},
},
};
}
/**
* 从某个槽里删掉一个模型键(effort / fast 任一维),不动同槽其余键与 lastModel。
* 槽不存在或该键本就没有 → 返回 null 表示「无事可做」(调用方据此短路,不做无意义落盘)。
*/
function withoutModelKey(
slot: ProviderMemory | undefined,
field: 'effortByModel' | 'fastByModel',
model: string,
): ProviderMemory | null {
if (!slot || !(model in slot[field])) return null;
const nextField = { ...slot[field] };
delete nextField[model];
return { ...slot, [field]: nextField } as ProviderMemory;
}
/**
* **删除**某 (agent, 模型) 的深度记忆 —— 「恢复推荐 / 回落默认」的正确语义
* (configuration-and-overrides §4:override 表里没有该键 ⇒ 跟随当前版本的默认,而不是
* 把这一版的默认**快照**写进用户配置)。写快照的老做法会把用户钉死在旧默认上:服务端
* 之后改了推荐档,没自定义过的用户吃不到。
*
* 权威的 `${agent}:*` 全局槽与来源兼容副本**两处都要删**:读路径是「全局优先、来源兜底」
* (getProviderModelEffort),只删一处的话另一处会把旧值顶回来。
*/
export function clearProviderModelEffort(
agent: AgentKind,
providerId: string,
model: string,
): void {
if (!providerId || providerId === MODEL_PRESET_SLOT_ID || !model) return;
const map = freshMap();
const op: ProviderMemoryOp = { kind: 'clear-effort', agent, providerId, model };
const next = applyProviderMemoryOp(map, op);
if (next === map) return;
persist(next, [op], map);
}
/**
* **删除**某 (agent, 模型) 的 Fast 记忆。语义同 clearProviderModelEffort:
* 表里没有该键 ⇒ 跟随默认(读侧 `getProviderModelFast` 返回 undefined,调用方按「关」解释),
* 而不是落一份「显式 false」的快照 —— 后者同样是把当前默认固化成用户配置。
*/
export function clearProviderModelFast(agent: AgentKind, providerId: string, model: string): void {
if (!providerId || providerId === MODEL_PRESET_SLOT_ID || !model) return;
const map = freshMap();
const op: ProviderMemoryOp = { kind: 'clear-fast', agent, providerId, model };
const next = applyProviderMemoryOp(map, op);
if (next === map) return;
persist(next, [op], map);
}
/**
* 快照当前全部槽的 (effortByModel, fastByModel, thinkingByModel)(丢弃 lastModel)。
* 用于 renderer → main 缓存和 device-link 控制端镜像被控设备的全局模型预设。
* 深拷贝,调用方拿到的快照不随后续本地改动变化。
*/
type ModelMemorySeed = Record<string, Pick<ProviderMemory, 'effortByModel' | 'fastByModel' | 'thinkingByModel'>>;
export function snapshotForSeed(): ModelMemorySeed;
export function snapshotForSeed(expectedOwner: string | null): ModelMemorySeed | null;
export function snapshotForSeed(expectedOwner?: string | null): ModelMemorySeed | null {
if (expectedOwner !== undefined && activeDataOwnerId !== expectedOwner) return null;
const out: ModelMemorySeed = {};
for (const [k, slot] of Object.entries(load())) {
out[k] = {
effortByModel: { ...slot.effortByModel },
fastByModel: { ...slot.fastByModel },
thinkingByModel: { ...slot.thinkingByModel },
};
}
return out;
}
/** 随认证 dataOwnerId 切换模型预设命名空间,和 newMakerDraft / modelEnginePrefs 同步。 */
export function setProviderModelMemoryOwner(ownerId: string | null): void {
const normalized = typeof ownerId === 'string' && ownerId.trim().length > 0 ? ownerId : null;
if (activeDataOwnerId === normalized) return;
if (normalized) migrateLegacyToOwner(normalized);
activeDataOwnerId = normalized;
cache = null;
emit();
}
/** 测试用 —— 重置缓存 + 清 localStorage(其它代码不应调用)。 */
export function __resetForTest(): void {
const keyBeforeReset = storageKey();
cache = null;
pendingOpsByStorageKey.clear();
if (typeof window !== 'undefined') {
try {
window.localStorage.removeItem(keyBeforeReset);
window.localStorage.removeItem(STORAGE_KEY);
window.localStorage.removeItem(LEGACY_STORAGE_KEY_V1);
} catch {
// ignore
}
}
activeDataOwnerId = null;
}
export const __STORAGE_KEY = STORAGE_KEY;
export const __LEGACY_STORAGE_KEY_V1 = LEGACY_STORAGE_KEY_V1;