Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { useEffect, useRef, type MutableRefObject, type Dispatch, type SetStateAction } from 'react';
import type { UseDeviceProvidersResult } from '@/device-link/useDeviceProviders';
import { mobileDebugLog } from '@/debug/mobileDebugLog';
import { isStoredAgentRestorePending, nextStoredAgentRestoreStep, canResolveStoredAgentRuntime, pickAgentDefaultRuntime, defaultPermissionModeForNewSessionAgent, resolveNewSessionAutoDefault, type NewSessionStoredPreferences, type StoredAgentRestoreState, type NewSessionAgentKind, type NewSessionRuntime, type NewSessionDraft } from './newSession';
import { buildMobileModelSections, flattenProviderSections, isFastRestorable, type ProviderModelRow } from './providerModelSections';
import type { MobileAgentCapabilities, MobileModelOption } from './agentCapabilities';
import type { MobileModelMemoryAccessors } from './draftModelMemory';
import type { NewSessionHostDefaults } from './newSessionHostDefaultsCache';
import { confirmFullAccessChange } from './fullAccessConfirmation';
export function useNewSessionDefaultSelection({
newSessionPreferences,
newSessionPreferencesLoaded,
userTouchedRuntimeRef,
preferredDefaultDevice,
selectedDeviceId,
hostDraftDefaults,
hostDefaultsSettled,
hostRuntimeFor,
deviceProviders,
deviceProvidersRef,
catalogReadyRef,
flatModelsForUnsupportedHost,
targetAgentHasFast,
draftMemory,
autoDefaultDeviceRef,
setDraft,
settleRuntime,
appliedPermissionMemoryRef,
draft,
runtimeActionSeqRef,
selectedDeviceRef,
capabilities,
modelRows,
modelSections,
}: {
newSessionPreferences: NewSessionStoredPreferences | null;
newSessionPreferencesLoaded: boolean;
userTouchedRuntimeRef: MutableRefObject<boolean>;
preferredDefaultDevice: { deviceId: string } | null | undefined;
selectedDeviceId: string;
hostDraftDefaults: NewSessionHostDefaults | null;
hostDefaultsSettled: boolean;
hostRuntimeFor: (agent: NewSessionAgentKind) => NewSessionRuntime | null;
deviceProviders: UseDeviceProvidersResult;
deviceProvidersRef: MutableRefObject<UseDeviceProvidersResult>;
catalogReadyRef: MutableRefObject<boolean>;
flatModelsForUnsupportedHost: (deviceId: string, agent: NewSessionAgentKind, unsupported: boolean) => readonly MobileModelOption[] | undefined;
targetAgentHasFast: (deviceId: string, agent: NewSessionAgentKind) => boolean;
draftMemory: MobileModelMemoryAccessors;
autoDefaultDeviceRef: MutableRefObject<string | null>;
setDraft: Dispatch<SetStateAction<NewSessionDraft>>;
settleRuntime: (source: string, deviceId: string) => void;
appliedPermissionMemoryRef: MutableRefObject<boolean>;
draft: NewSessionDraft;
runtimeActionSeqRef: MutableRefObject<number>;
selectedDeviceRef: MutableRefObject<string>;
capabilities: MobileAgentCapabilities | null;
modelRows: ProviderModelRow[];
modelSections: ReturnType<typeof buildMobileModelSections>;
}) {
const storedAgentRestoreRef = useRef<StoredAgentRestoreState | null>(null);
const autoDefaultSnapshotRef = useRef<NewSessionHostDefaults | null | undefined>(undefined);
useEffect(() => {
const storedAgentKind = newSessionPreferences?.agentKind;
if (!newSessionPreferencesLoaded || !storedAgentKind) return;
if (userTouchedRuntimeRef.current) return;
const restored = storedAgentRestoreRef.current;
if (!isStoredAgentRestorePending({
storedAgentKind,
appliedStoredAgentKind: restored?.phase === 'done' ? restored.agentKind : null,
expectedDeviceId: preferredDefaultDevice?.deviceId ?? '',
selectedDeviceId,
})) return;
// agent 偏好一到就恢复;模型要等被控电脑的新建任务默认与目录,否则选不出模型。
const step = nextStoredAgentRestoreStep({
storedAgentKind,
restored,
modelReady: canResolveStoredAgentRuntime({
deviceId: selectedDeviceId,
hostDefaultsSettled: hostDraftDefaults?.deviceId === selectedDeviceId
&& storedAgentKind in hostDraftDefaults.byAgent,
hostRuntime: hostRuntimeFor(storedAgentKind),
catalogReady: deviceProviders.ready,
providersUnsupported: deviceProviders.unsupported,
}),
});
if (!step) return;
mobileDebugLog('debug', 'new-session', 'stored agent restore', { step, agentKind: storedAgentKind });
const previousRestore = restored;
const restoreState: StoredAgentRestoreState = { agentKind: storedAgentKind, phase: step === 'agent' ? 'agent' : 'done' };
storedAgentRestoreRef.current = restoreState;
// 现场按最新目录算该 agent 的默认运行配置(rows 与 ready 必须同一代,codex review P2)。
const resolveStoredRuntime = (currentEffort: string) => {
const rowsNow = flattenProviderSections(
buildMobileModelSections({
providers: deviceProvidersRef.current.providers,
agentKind: storedAgentKind,
visibilityOverrides: deviceProvidersRef.current.modelVisibilityOverrides,
}).sections,
);
const next = pickAgentDefaultRuntime({
agentKind: storedAgentKind,
hostRuntime: hostRuntimeFor(storedAgentKind),
modelRows: rowsNow,
providers: deviceProvidersRef.current.providers,
currentEffort,
catalogReady: catalogReadyRef.current,
visibilityOverrides: deviceProvidersRef.current.modelVisibilityOverrides,
flatModels: flatModelsForUnsupportedHost(selectedDeviceId, storedAgentKind, deviceProvidersRef.current.unsupported),
});
const rememberedFast = next.providerId
? draftMemory.getFast(next.agentKind, next.providerId, next.model) ?? false
: false;
return {
model: next.model,
effort: next.effort,
providerId: next.providerId,
// fast 按 (agent, 来源, 模型) 记忆恢复,无记忆置 false;恢复前过与手动选行
// 同款的 fastEditable 门控(codex review P2:目录/能力变化后不得恢复出
// UI 显示关、实际发 true 的矛盾态)。agent 级门控只认目标 agent 的缓存
// 能力表(codex review P1:此刻闭包里的 capabilities 属于切换前 agent 或
// 为 null);目标 caps 未就绪 → false,由延迟恢复 effect 就绪后补评。
fastMode: next.providerId
&& isFastRestorable(next.agentKind, next.providerId, next.model, rowsNow, targetAgentHasFast(selectedDeviceId, next.agentKind), rememberedFast)
? rememberedFast
: false,
};
};
// Stored-engine restoration and the generic default effect consume the same
// snapshot; only a later host refresh may seed the untouched draft again.
const previousAutoDefaultSnapshot = autoDefaultSnapshotRef.current;
autoDefaultSnapshotRef.current = hostDraftDefaults;
if (step === 'model') {
// agent 与权限已在第一步恢复;只补模型,不动 agent 与权限(期间用户改过权限/计划模式不被覆盖)。
setDraft((current) => (current.agentKind === storedAgentKind
? { ...current, ...resolveStoredRuntime(current.effort) }
: current));
settleRuntime('stored-agent-model', selectedDeviceId);
return;
}
// 该路径同时负责恢复 agent 权限,下面的通用权限记忆 effect 不再重复弹框。
appliedPermissionMemoryRef.current = true;
const previousAutoDefaultDevice = autoDefaultDeviceRef.current;
if (selectedDeviceId) autoDefaultDeviceRef.current = selectedDeviceId;
let applied = false;
const storedPermissionMode = newSessionPreferences?.permissionModeByAgent[storedAgentKind];
const nextPermissionMode =
storedPermissionMode ??
defaultPermissionModeForNewSessionAgent(storedAgentKind);
let cancelled = false;
const deviceAtTrigger = selectedDeviceId;
const seqAtTrigger = ++runtimeActionSeqRef.current;
void (async () => {
const confirmed = await confirmFullAccessChange(draft.permissionMode, nextPermissionMode, {
restoringRememberedChoice: storedPermissionMode !== undefined,
});
if (cancelled) return;
// 确认期间设备已切换 → 放弃本次写入,新设备自己的恢复/自动默认 effect 会接管。
if (deviceAtTrigger !== selectedDeviceRef.current) return;
// 确认期间用户又切了 agent / 手动选了模型 → 旧回调不得覆盖新选择。
if (seqAtTrigger !== runtimeActionSeqRef.current) return;
applied = true;
setDraft((current) => ({
...current,
...resolveStoredRuntime(current.effort),
agentKind: storedAgentKind,
// 上次明确选择过的权限直接沿用;内置默认若升级到 Full access 仍需确认。
permissionMode: confirmed ? nextPermissionMode : current.permissionMode,
}));
// 'agent' 只恢复了 agent,模型仍是占位,等数据到了由 'model' 落定。
if (step === 'full') settleRuntime('stored-agent', deviceAtTrigger);
})();
return () => {
cancelled = true;
// 写入前依赖已变(effect 重跑):撤回「已恢复」与设备锁,让重跑的 effect 重新恢复。
// 否则标记已落、草稿却没写,两条默认路径都不再处理,页面停在占位模型。
if (applied) return;
if (storedAgentRestoreRef.current === restoreState) storedAgentRestoreRef.current = previousRestore;
if (autoDefaultDeviceRef.current === selectedDeviceId) {
autoDefaultDeviceRef.current = previousAutoDefaultDevice;
autoDefaultSnapshotRef.current = previousAutoDefaultSnapshot;
}
};
}, [
draft.permissionMode,
deviceProviders.ready,
deviceProviders.unsupported,
deviceProviders.providers,
deviceProviders.modelVisibilityOverrides,
hostDefaultsSettled,
hostDraftDefaults,
hostRuntimeFor,
newSessionPreferences,
newSessionPreferences?.agentKind,
newSessionPreferencesLoaded,
preferredDefaultDevice?.deviceId,
selectedDeviceId,
]);
// 权限记忆恢复:偏好加载后按当前 agent 恢复上次选过的档(一次;对齐桌面 lastByVendor)。
// storedAgentKind 路径由上面的 effect 覆盖;这里兜住「没存过 agent 但存过权限」的场景。
useEffect(() => {
if (!newSessionPreferencesLoaded || appliedPermissionMemoryRef.current) return;
appliedPermissionMemoryRef.current = true;
// 有存储的 agent 时由上面的 agent 恢复 effect 统一处理,避免同一轮出现两个确认框。
if (newSessionPreferences?.agentKind) return;
const remembered = newSessionPreferences?.permissionModeByAgent[draft.agentKind];
if (!remembered || remembered === draft.permissionMode) return;
let cancelled = false;
const seqAtTrigger = runtimeActionSeqRef.current;
void confirmFullAccessChange(draft.permissionMode, remembered, {
restoringRememberedChoice: true,
}).then((confirmed) => {
if (cancelled || !confirmed || seqAtTrigger !== runtimeActionSeqRef.current) return;
setDraft((current) => ({ ...current, permissionMode: remembered }));
});
return () => {
cancelled = true;
};
}, [draft.agentKind, draft.permissionMode, newSessionPreferences, newSessionPreferencesLoaded]);
// 新建任务默认运行配置 = 被控电脑记住的当前 agent 新建任务默认(model+effort+来源,与桌面远程新建同源);
// 没有则优先区域默认、再用模型列表最上面那个。一旦用户手动选过模型即不再覆盖;切设备(未手动选过)按新设备重算。
// 决策逻辑全在纯函数 resolveNewSessionAutoDefault 里(便于单测);此 effect 只负责"调纯函数 → setDraft + 更新 ref"。
// 被控电脑默认与 providers 都是异步到达,任一就绪后此 effect 再触发。
useEffect(() => {
if (!newSessionPreferencesLoaded) return;
const result = resolveNewSessionAutoDefault({
userTouched: userTouchedRuntimeRef.current,
appliedDeviceId: autoDefaultSnapshotRef.current === hostDraftDefaults ? autoDefaultDeviceRef.current : null,
selectedDeviceId,
hostDefaultsSettled,
hostRuntime: hostRuntimeFor(draft.agentKind),
modelRows,
providers: deviceProviders.providers,
rowsAgentKind: draft.agentKind,
catalogReady: deviceProviders.ready,
visibilityOverrides: deviceProviders.modelVisibilityOverrides,
providersUnsupported: deviceProviders.unsupported,
// provider-aware 模式只用经过可见性过滤的 rows;目录确实不可用时才回退
// capabilities(上游 main 移植,merge 2026-08-07)。
availableModels: deviceProviders.unsupported
? capabilities?.availableModels
: undefined,
currentEffort: draft.effort,
});
if (!result) return;
const previousAutoDefaultDevice = autoDefaultDeviceRef.current;
const previousAutoDefaultSnapshot = autoDefaultSnapshotRef.current;
autoDefaultDeviceRef.current = result.appliedDeviceId;
autoDefaultSnapshotRef.current = hostDraftDefaults;
let applied = false;
const nextAgentKind = result.patch.agentKind ?? draft.agentKind;
const storedPermissionMode = appliedPermissionMemoryRef.current
? undefined
: newSessionPreferences?.permissionModeByAgent[nextAgentKind];
const nextPermissionMode = appliedPermissionMemoryRef.current
? draft.permissionMode
: storedPermissionMode ?? defaultPermissionModeForNewSessionAgent(nextAgentKind);
let cancelled = false;
void confirmFullAccessChange(draft.permissionMode, nextPermissionMode, {
restoringRememberedChoice: storedPermissionMode !== undefined,
}).then((confirmed) => {
if (cancelled || userTouchedRuntimeRef.current) return;
applied = true;
settleRuntime(result.source, result.appliedDeviceId);
setDraft((current) => {
// 自动默认重算(设备切换/最近会话变化)改了 (agent, model, providerId) 组合 →
// fastMode 按新组合重验(Codex review P2):A 设备记忆恢复的 fastMode:true 不得
// 随 `...current` 带进 B 的组合(若 B 的模型行不支持 Fast,终检/延迟恢复/能力
// 协调三条路径都不会处理它)。组合变化时保守关闭,由延迟恢复 effect 在 B 的
// 组合 + 能力就绪后按记忆重评(手动关过 → 记忆为 false,不会重新打开)。
const nextModel = result.patch.model ?? current.model;
// providerId 用 `!== undefined` 而非 `??`:patch 显式带 providerId:null(来源
// 切回默认路由)是真实的组合变化,`??` 会取回旧值抹掉该变化(Codex review P2)。
const nextProviderId = result.patch.providerId !== undefined
? result.patch.providerId
: current.providerId;
const nextAgentKind = result.patch.agentKind ?? current.agentKind;
const comboChanged = nextModel !== current.model
|| nextProviderId !== current.providerId
|| nextAgentKind !== current.agentKind;
return {
...current,
...result.patch,
...(comboChanged ? { fastMode: false } : {}),
// 自动恢复上次明确选择的权限不再重复确认;内置默认仍按升级规则确认。
permissionMode: confirmed ? nextPermissionMode : current.permissionMode,
};
});
});
return () => {
cancelled = true;
// 写入前 effect 重跑:撤回设备锁,重跑时按最新数据重新应用,不把这台设备误记为已应用。
if (!applied && autoDefaultDeviceRef.current === result.appliedDeviceId) {
autoDefaultDeviceRef.current = previousAutoDefaultDevice;
autoDefaultSnapshotRef.current = previousAutoDefaultSnapshot;
}
};
}, [capabilities?.availableModels, deviceProviders.providers, deviceProviders.loading, draft.effort, draft.permissionMode, draft.agentKind, modelRows, deviceProviders.ready, deviceProviders.modelVisibilityOverrides, deviceProviders.unsupported, modelSections.connected.length, newSessionPreferences, newSessionPreferencesLoaded, selectedDeviceId, hostDefaultsSettled, hostDraftDefaults, hostRuntimeFor]);
}