Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* 统一模型选择器(模型优先)M3 / M4 的**纯逻辑锁**:行生效配置合成、收藏副本语义、
* 收藏 / 最近置顶 + 分组陈列、rail 派生、浮层定位、档位绝对色。
*
* 为什么这些必须有测试:行右侧的三元组与浮层里的每个控件显示的是**同一份合成结果**,
* 一旦两边规则漂移,用户会看到「行上写着 high、浮层滑杆停在 medium」这种自相矛盾;
* 而档位色按「第几档」相对取值(而不是按档位 key 绝对取值)是最容易犯、也最难目检出来的
* 错误 —— 封顶 high 的模型会假装自己是顶档紫。
*/
import { describe, expect, it } from 'vitest';
import type {
UnifiedAgentCapability,
UnifiedModelEntry,
} from '@cindy/model-providers';
import {
UNIFIED_FLYOUT_GAP,
UNIFIED_RECENT_MODELS_LIMIT,
buildUnifiedListSections,
engineOfAgentKind,
entryMatchesModelId,
favoriteMatchesSelection,
wireModelIdOf,
buildUnifiedRail,
computeFlyoutPlacement,
computeSelectedRowScrollTop,
isRecommendedFavoriteConfig,
resolveFavoriteRowConfig,
resolveUnifiedRowConfig,
} from '@/components/new-chat/unifiedModelSelection';
import type { ModelConfigCopy } from '@/state/modelConfigCopy';
import type { ModelFavoriteItem } from '@/state/modelFavorites';
import type { RecentModelItem } from '@/state/recentModels';
import {
EFFORT_TIER_COLORS,
effortTierColor,
effortTierColorAt,
hexLerp,
} from '@/themes/effortTierColors';
function capability(
agent: UnifiedAgentCapability['agent'],
over: Partial<UnifiedAgentCapability> = {},
): UnifiedAgentCapability {
return {
agent,
// 上游把行改成「归一化 id + 每引擎 wire id」后,wireModelId 是必填:测试夹具给一个
// 与 agent 相关的假 id 即可,本层逻辑不解释它(发请求才用)。
wireModelId: `wire-${agent}`,
efforts: ['low', 'medium', 'high'],
defaultEffort: 'medium',
defaultEffortSource: 'catalog',
supportsFastMode: false,
contextWindow: 200_000,
contextWindowVerified: false,
...over,
};
}
function entryOf(over: Partial<UnifiedModelEntry> = {}): UnifiedModelEntry {
return {
providerId: 'anthropic',
modelId: 'claude-opus-5',
displayName: 'Claude Opus 5',
candidates: ['claude-code'],
recommended: 'claude-code',
nativeAgent: 'claude-code',
capabilities: { 'claude-code': capability('claude-code') },
...over,
};
}
function favoriteOf(over: Partial<ModelFavoriteItem> = {}): ModelFavoriteItem {
return {
uid: 'fav-1',
providerId: 'anthropic',
modelId: 'claude-opus-5',
agent: 'cc',
...over,
};
}
function recentOf(over: Partial<RecentModelItem> = {}): RecentModelItem {
return {
providerId: 'anthropic',
modelId: 'claude-opus-5',
agent: 'cc',
usedAt: 1,
...over,
};
}
describe('resolveUnifiedRowConfig', () => {
it('无 override 时落推荐引擎与目录默认档', () => {
const config = resolveUnifiedRowConfig({ entry: entryOf() });
expect(config.engine).toBe('cc');
expect(config.agent).toBe('claude-code');
expect(config.effort).toBe('medium');
expect(config.fast).toBe(false);
expect(config.customized).toBe(false);
});
it('override 命中候选时采用它,并标记为已自定义', () => {
const entry = entryOf({
candidates: ['claude-code', 'codex'],
capabilities: {
'claude-code': capability('claude-code'),
codex: capability('codex', { efforts: ['low', 'high', 'xhigh'], defaultEffort: 'high' }),
},
});
const config = resolveUnifiedRowConfig({ entry, engineOverride: 'codex' });
expect(config.engine).toBe('codex');
expect(config.efforts).toEqual(['low', 'high', 'xhigh']);
expect(config.effort).toBe('high');
expect(config.customized).toBe(true);
});
it('override 不在候选里 → 静默回落推荐(不造假按钮)', () => {
const config = resolveUnifiedRowConfig({ entry: entryOf(), engineOverride: 'codex' });
expect(config.engine).toBe('cc');
expect(config.customized).toBe(false);
});
it('记忆档位不被该 (模型, 引擎) 支持时回落目录默认', () => {
const config = resolveUnifiedRowConfig({
entry: entryOf(),
memoryEffort: () => 'xhigh',
});
expect(config.effort).toBe('medium');
expect(config.customized).toBe(false);
});
it('记忆档位被支持时采用它并计为自定义', () => {
const config = resolveUnifiedRowConfig({ entry: entryOf(), memoryEffort: () => 'high' });
expect(config.effort).toBe('high');
expect(config.customized).toBe(true);
});
it('Fast 需要目录能力 × agent 运行时能力都为真', () => {
const fastEntry = entryOf({
capabilities: { 'claude-code': capability('claude-code', { supportsFastMode: true }) },
});
const both = resolveUnifiedRowConfig({
entry: fastEntry,
memoryFast: () => true,
agentFastModeCapable: () => true,
});
expect(both.fastCapable).toBe(true);
expect(both.fast).toBe(true);
expect(both.customized).toBe(true);
const runtimeOff = resolveUnifiedRowConfig({
entry: fastEntry,
memoryFast: () => true,
agentFastModeCapable: () => false,
});
expect(runtimeOff.fastCapable).toBe(false);
expect(runtimeOff.fast).toBe(false);
const catalogOff = resolveUnifiedRowConfig({
entry: entryOf(),
memoryFast: () => true,
agentFastModeCapable: () => true,
});
expect(catalogOff.fastCapable).toBe(false);
expect(catalogOff.fast).toBe(false);
});
it('无档位的模型 → effort 为 null(不可调,滑杆不画)', () => {
const config = resolveUnifiedRowConfig({
entry: entryOf({
capabilities: {
'claude-code': capability('claude-code', { efforts: [], defaultEffort: null }),
},
}),
});
expect(config.efforts).toEqual([]);
expect(config.effort).toBeNull();
});
it('深度 / Fast 记忆按**生效引擎**取,不串到另一个引擎的槽', () => {
const entry = entryOf({
candidates: ['claude-code', 'codex'],
capabilities: {
'claude-code': capability('claude-code'),
codex: capability('codex', { efforts: ['low', 'medium', 'high'], defaultEffort: 'low' }),
},
});
const asked: string[] = [];
const config = resolveUnifiedRowConfig({
entry,
engineOverride: 'codex',
memoryEffort: (agent) => {
asked.push(agent);
return agent === 'codex' ? 'high' : 'low';
},
});
expect(asked).toEqual(['codex']);
expect(config.effort).toBe('high');
});
});
describe('收藏 = 配置副本', () => {
it('收藏条目只读自己存的配置,不读模型 override / 记忆', () => {
const entry = entryOf({
candidates: ['claude-code', 'codex'],
capabilities: {
'claude-code': capability('claude-code'),
codex: capability('codex'),
},
});
const config = resolveFavoriteRowConfig({
entry,
item: favoriteOf({ agent: 'codex', effort: 'high' }),
});
expect(config.engine).toBe('codex');
expect(config.effort).toBe('high');
// 收藏行不参与「已自定义」语义(底栏是第三态「收藏配置」)。
expect(config.customized).toBe(false);
});
it('条目里的引擎 / 档位已不被目录支持时按同一套规则收敛', () => {
const config = resolveFavoriteRowConfig({
entry: entryOf(),
item: favoriteOf({ agent: 'codex', effort: 'ultra' }),
});
expect(config.engine).toBe('cc');
expect(config.effort).toBe('medium');
});
it('isRecommendedFavoriteConfig 区分「就是推荐配置」与「非默认副本」', () => {
const entry = entryOf({
candidates: ['claude-code', 'codex'],
capabilities: {
'claude-code': capability('claude-code', { supportsFastMode: true }),
codex: capability('codex'),
},
});
const plain = resolveFavoriteRowConfig({ entry, item: favoriteOf({ effort: 'medium' }) });
expect(isRecommendedFavoriteConfig(entry, plain)).toBe(true);
const otherEffort = resolveFavoriteRowConfig({ entry, item: favoriteOf({ effort: 'high' }) });
expect(isRecommendedFavoriteConfig(entry, otherEffort)).toBe(false);
const otherEngine = resolveFavoriteRowConfig({ entry, item: favoriteOf({ agent: 'codex' }) });
expect(isRecommendedFavoriteConfig(entry, otherEngine)).toBe(false);
const withFast = resolveFavoriteRowConfig({
entry,
item: favoriteOf({ effort: 'medium', fast: true }),
agentFastModeCapable: () => true,
});
expect(isRecommendedFavoriteConfig(entry, withFast)).toBe(false);
});
});
describe('buildUnifiedListSections', () => {
const opus = entryOf({ group: 'anthropic', sortOrder: 1 });
const gpt = entryOf({
providerId: 'openai',
modelId: 'gpt-5.5',
displayName: 'GPT-5.5',
group: 'gpt',
sortOrder: 2,
candidates: ['codex'],
recommended: 'codex',
capabilities: { codex: capability('codex') },
});
it('收藏区置顶,且不把模型本体从供应商组里移走', () => {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [favoriteOf()],
query: '',
rail: { kind: 'all' },
});
expect(sections[0].kind).toBe('favorites');
expect(sections[0].rows[0].anchor).toEqual({
kind: 'fav',
uid: 'fav-1',
providerId: 'anthropic',
modelId: 'claude-opus-5',
});
const modelRows = sections.slice(1).flatMap((section) => section.rows);
expect(modelRows.map((row) => row.entry.modelId)).toEqual(['claude-opus-5', 'gpt-5.5']);
});
it('分组按供应商:每家各自成组,组名 = providerLabel(2026-08-16 裁决,废除「授权登录」合并组)', () => {
const xdModel = entryOf({
providerId: 'xd',
modelId: 'deepseek-v4-pro',
displayName: 'DeepSeek V4 Pro',
sortOrder: 1,
});
const customModel = entryOf({ providerId: 'custom-a', modelId: 'my-model' });
const sections = buildUnifiedListSections({
entries: [opus, gpt, xdModel, customModel],
favorites: [],
query: '',
rail: { kind: 'all' },
});
// 供应商决定价格:每家一组、与模型设置页同一套名字,不引入「授权登录」这种第二套口径。
expect(sections.map((section) => section.group)).toEqual([
{ type: 'provider', providerId: 'anthropic' },
{ type: 'provider', providerId: 'openai' },
{ type: 'provider', providerId: 'xd' },
{ type: 'provider', providerId: 'custom-a' },
]);
});
it('供应商簇内按 sortOrder 排,簇间保持首见序(不做全局 sortOrder 混排)', () => {
const opusLate = entryOf({ modelId: 'claude-sonnet-5', sortOrder: 9 });
const opusEarly = entryOf({ sortOrder: 1 });
const sections = buildUnifiedListSections({
// openai 条目先出现 → openai 簇在前;anthropic 簇内 9/1 倒序入参。
entries: [gpt, opusLate, opusEarly],
favorites: [],
query: '',
rail: { kind: 'all' },
});
// openai 先出现 → openai 组在前;anthropic 组内 9/1 入参按 sortOrder 回正。
expect(sections[0].rows.map((row) => row.entry.modelId)).toEqual(['gpt-5.5']);
expect(sections[1].rows.map((row) => row.entry.modelId)).toEqual([
'claude-opus-5',
'claude-sonnet-5',
]);
});
it('传 providerOrder 时组间按设置页拖动序排,未收录供应商按首见序追加', () => {
const xdModel = entryOf({
providerId: 'xd',
modelId: 'deepseek-v4-pro',
displayName: 'DeepSeek V4 Pro',
});
const sections = buildUnifiedListSections({
entries: [opus, gpt, xdModel],
favorites: [],
query: '',
rail: { kind: 'all' },
// 目录首见序 = anthropic → openai → xd;拖动序点名 openai 提前,
// 未收录的 xd 按首见序追加,顺序表里的未知 id 直接忽略。
providerOrder: ['unknown-provider', 'openai', 'anthropic'],
});
expect(sections.map((section) => section.group?.providerId)).toEqual([
'openai',
'anthropic',
'xd',
]);
});
it('搜索命中名称 / id / 描述', () => {
const described = entryOf({ description: '擅长长上下文推理' });
for (const query of ['opus', 'CLAUDE-OPUS', '长上下文']) {
const sections = buildUnifiedListSections({
entries: [described, gpt],
favorites: [],
query,
rail: { kind: 'all' },
});
const ids = sections.flatMap((section) => section.rows.map((row) => row.entry.modelId));
expect(ids).toEqual(['claude-opus-5']);
}
});
it('rail 按供应商筛选时,收藏区也只留该来源', () => {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [favoriteOf()],
query: '',
rail: { kind: 'provider', providerId: 'openai' },
});
expect(sections.every((section) => section.kind !== 'favorites')).toBe(true);
expect(sections.flatMap((s) => s.rows.map((r) => r.entry.providerId))).toEqual(['openai']);
});
it('rail = 收藏时只出收藏区', () => {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [favoriteOf()],
query: '',
rail: { kind: 'favorites' },
});
expect(sections).toHaveLength(1);
expect(sections[0].kind).toBe('favorites');
});
it('收藏指向的模型当前不可路由时该条不显示(但不删条目)', () => {
const sections = buildUnifiedListSections({
entries: [gpt],
favorites: [favoriteOf()],
query: '',
rail: { kind: 'all' },
});
expect(sections.every((section) => section.kind !== 'favorites')).toBe(true);
});
it('同模型多条收藏各占一行、锚点互不相同', () => {
const sections = buildUnifiedListSections({
entries: [opus],
favorites: [
favoriteOf({ uid: 'fav-1', effort: 'high' }),
favoriteOf({ uid: 'fav-2', effort: 'low' }),
],
query: '',
rail: { kind: 'favorites' },
});
expect(sections[0].rows.map((row) => row.favorite?.uid)).toEqual(['fav-1', 'fav-2']);
});
describe('最近视图(仅侧栏「最近」格)', () => {
it('常规视图(全部 / 供应商 / 同引擎)不陈列最近区 —— 即使 store 里有记录', () => {
for (const rail of [
{ kind: 'all' } as const,
{ kind: 'provider', providerId: 'anthropic' } as const,
{ kind: 'engine', agent: 'claude-code' } as const,
]) {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [favoriteOf()],
recentModels: [recentOf()],
query: '',
rail,
});
expect(sections.some((section) => section.kind === 'recent')).toBe(false);
// 收藏区照旧置顶。
expect(sections[0].kind).toBe('favorites');
}
});
it('rail = 最近时只出最近区,行锚点是副本身份(带 recent 条目)', () => {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [favoriteOf()],
recentModels: [recentOf({ providerId: 'openai', modelId: 'gpt-5.5' })],
query: '',
rail: { kind: 'recent' },
recommendation: { agent: 'codex', providerId: 'openai', modelId: 'gpt-5.5' },
});
expect(sections.map((section) => section.kind)).toEqual(['recent']);
// 锚点是**副本身份**(同一模型不同配置各占一行);key 由 store 的去重身份算得。
expect(sections[0].rows[0].anchor).toEqual({
kind: 'recent',
key: expect.any(String),
providerId: 'openai',
modelId: 'gpt-5.5',
});
expect(sections[0].rows[0].favorite).toBeUndefined();
expect(sections[0].rows[0].recent).toMatchObject({
providerId: 'openai',
modelId: 'gpt-5.5',
agent: 'cc',
});
});
it(`最多陈列 ${UNIFIED_RECENT_MODELS_LIMIT} 条,按传入的最近顺序取`, () => {
const entries = [
opus,
gpt,
entryOf({ modelId: 'm-3' }),
entryOf({ modelId: 'm-4' }),
entryOf({ modelId: 'm-5' }),
entryOf({ modelId: 'm-6' }),
entryOf({ modelId: 'm-7' }),
];
const sections = buildUnifiedListSections({
entries,
favorites: [],
recentModels: entries.map((entry, index) =>
recentOf({ providerId: entry.providerId, modelId: entry.modelId, usedAt: 100 - index }),
),
query: '',
rail: { kind: 'recent' },
});
expect(sections[0].kind).toBe('recent');
expect(sections[0].rows.map((row) => row.entry.modelId)).toEqual([
'claude-opus-5',
'gpt-5.5',
'm-3',
'm-4',
'm-5',
]);
});
it('不可路由的条目跳过,并从更早的历史里补足', () => {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [],
// 最新三条里两条已下架 → 展示仍然是最近可用的 2 条,不多也不少。
recentModels: [
recentOf({ modelId: 'gone-1', usedAt: 300 }),
recentOf({ modelId: 'gone-2', usedAt: 200 }),
recentOf({ providerId: 'openai', modelId: 'gpt-5.5', usedAt: 100 }),
recentOf({ usedAt: 50 }),
],
query: '',
rail: { kind: 'recent' },
});
expect(sections[0].kind).toBe('recent');
expect(sections[0].rows.map((row) => row.entry.modelId)).toEqual([
'gpt-5.5',
'claude-opus-5',
]);
});
it('老数据存的 wire id 也能解析回行身份', () => {
const bridged = entryOf({
providerId: 'openai',
modelId: 'gpt-5.6',
displayName: 'GPT-5.6',
candidates: ['claude-code'],
capabilities: {
'claude-code': capability('claude-code', { wireModelId: 'chatgpt/gpt-5.6' }),
},
});
const sections = buildUnifiedListSections({
entries: [bridged],
favorites: [],
recentModels: [recentOf({ providerId: 'openai', modelId: 'chatgpt/gpt-5.6' })],
query: '',
rail: { kind: 'recent' },
});
expect(sections[0].rows[0].entry.modelId).toBe('gpt-5.6');
expect(sections[0].rows[0].anchor).toEqual({
kind: 'recent',
key: expect.any(String),
providerId: 'openai',
modelId: 'gpt-5.6',
});
});
it('搜索词生效时回落「全部」视图(rail 被搜索接管,最近不再是当前视图)', () => {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [],
recentModels: [recentOf({ usedAt: 200 }), recentOf({ providerId: 'openai', modelId: 'gpt-5.5', usedAt: 100 })],
query: 'gpt',
rail: { kind: 'recent' },
});
expect(sections.some((section) => section.kind === 'recent')).toBe(false);
expect(sections.flatMap((section) => section.rows.map((row) => row.entry.modelId))).toEqual([
'gpt-5.5',
]);
});
it('rail = 收藏时不出最近区(收藏轨只陈列收藏)', () => {
const sections = buildUnifiedListSections({
entries: [opus],
favorites: [favoriteOf()],
recentModels: [recentOf()],
query: '',
rail: { kind: 'favorites' },
});
expect(sections.map((section) => section.kind)).toEqual(['favorites']);
});
it('空列表 / 全部不可路由时最近视图为空', () => {
expect(
buildUnifiedListSections({
entries: [opus],
favorites: [],
recentModels: [],
query: '',
rail: { kind: 'recent' },
}),
).toEqual([]);
expect(
buildUnifiedListSections({
entries: [opus],
favorites: [],
recentModels: [recentOf({ modelId: 'gone' })],
query: '',
rail: { kind: 'recent' },
}),
).toEqual([]);
});
});
});
describe('会话内形态(同引擎过滤 / pinnedEngine)', () => {
// pinned 的适用面是**无主场**(nativeAgent=null)的行:grok / 国产 / BYOM 这类
// 全场平等的模型,会话内默认落在当前引擎上才是无损直切。
const dual = entryOf({
providerId: 'xd',
modelId: 'deepseek/deepseek-v4-pro',
displayName: 'DeepSeek V4 Pro',
candidates: ['claude-code', 'codex'],
recommended: 'claude-code',
nativeAgent: null,
capabilities: {
'claude-code': capability('claude-code'),
codex: capability('codex', { efforts: ['low', 'high'], defaultEffort: 'high' }),
},
});
const codexOnly = entryOf({
providerId: 'xd',
modelId: 'codex/gpt-5.5',
displayName: 'GPT-5.5 折扣',
candidates: ['codex'],
recommended: 'codex',
nativeAgent: 'codex',
capabilities: { codex: capability('codex') },
});
it('pinnedEngine 顶替推荐作为缺省,但让位于用户显式 override', () => {
const pinned = resolveUnifiedRowConfig({ entry: dual, pinnedEngine: 'codex' });
expect(pinned.engine).toBe('codex');
// 落在会话引擎上是缺省而不是自定义 —— 否则会话里几乎每行都被提亮。
expect(pinned.customized).toBe(false);
expect(pinned.effort).toBe('high');
const overridden = resolveUnifiedRowConfig({
entry: dual,
pinnedEngine: 'codex',
engineOverride: 'cc',
});
expect(overridden.engine).toBe('cc');
expect(overridden.customized).toBe(true);
});
it('pinnedEngine 不在候选时忽略,回落推荐', () => {
const config = resolveUnifiedRowConfig({ entry: codexOnly, pinnedEngine: 'cc' });
expect(config.engine).toBe('codex');
expect(config.customized).toBe(false);
});
it('主场在别处的行**不跟随** pinned:codex 会话里 Claude 行仍显示 claude-code 主场', () => {
// Chris 2026-08-14 实测:codex 会话打开面板,Claude 模型整列被标成 Codex,「像被
// 批量改了配置」,且选中会静默骑 bridge。主场明确的行保持主场,选中走跨引擎切换。
const claude = entryOf({
providerId: 'xd',
candidates: ['claude-code', 'codex'],
recommended: 'claude-code',
nativeAgent: 'claude-code',
capabilities: { 'claude-code': capability('claude-code'), codex: capability('codex') },
});
const config = resolveUnifiedRowConfig({ entry: claude, pinnedEngine: 'codex' });
expect(config.engine).toBe('cc');
// 主场就是会话引擎的行照常 pinned(等价于推荐,行为不变)。
const gpt = entryOf({
providerId: 'xd',
modelId: 'gpt-5.5',
candidates: ['claude-code', 'codex'],
recommended: 'codex',
nativeAgent: 'codex',
capabilities: { 'claude-code': capability('claude-code'), codex: capability('codex') },
});
expect(resolveUnifiedRowConfig({ entry: gpt, pinnedEngine: 'codex' }).engine).toBe('codex');
// 显式 override 仍是最高优先:确要「Claude 骑 codex」的,浮层里点过胶囊就照显示。
expect(
resolveUnifiedRowConfig({ entry: claude, pinnedEngine: 'codex', engineOverride: 'codex' })
.engine,
).toBe('codex');
});
it('forceEngine(选中行)压过 override 与 pinned:显示与正在跑的事实一致', () => {
const forced = resolveUnifiedRowConfig({
entry: dual,
engineOverride: 'codex',
pinnedEngine: 'codex',
forceEngine: 'cc',
});
expect(forced.engine).toBe('cc');
// 不在候选内的 forceEngine 忽略(防御脏数据),回落正常链。
const ignored = resolveUnifiedRowConfig({ entry: codexOnly, forceEngine: 'pi' });
expect(ignored.engine).toBe('codex');
});
it('同引擎视图按**候选**过滤模型(不注入解析器时维持旧行为)', () => {
const sections = buildUnifiedListSections({
entries: [dual, codexOnly],
favorites: [],
query: '',
rail: { kind: 'engine', agent: 'claude-code' },
});
const ids = sections.flatMap((s) => s.rows.map((r) => r.entry.modelId));
expect(ids).toEqual(['deepseek/deepseek-v4-pro']);
});
// Chris 2026-08-23:同引擎视图的准入是候选,生效引擎只做排序优先级 —— 默认 / 用户选过
// 本引擎的在前,仅兼容的在后;不再把后者藏掉。
describe('同引擎视图:生效引擎是排序优先级,不是隐藏条件', () => {
/** 注入侧的真实形态:调用方给的是 resolveUnifiedRowConfig / resolveFavoriteRowConfig 的 engine。 */
const engineOfRow = (
overrides: Record<string, 'cc' | 'codex' | 'pi'> = {},
pinnedEngine: 'cc' | 'codex' | 'pi' = 'cc',
) => (entry: UnifiedModelEntry, favorite?: ModelConfigCopy) =>
favorite
? resolveFavoriteRowConfig({ entry, item: favorite }).engine
: resolveUnifiedRowConfig({
entry,
pinnedEngine,
...(overrides[entry.modelId] ? { engineOverride: overrides[entry.modelId] } : {}),
}).engine;
const idsOf = (
entries: UnifiedModelEntry[],
effectiveEngineOf: ReturnType<typeof engineOfRow>,
): string[] =>
buildUnifiedListSections({
entries,
favorites: [],
query: '',
rail: { kind: 'engine', agent: 'claude-code' },
effectiveEngineOf,
})
.flatMap((s) => s.rows)
.map((row) => row.entry.modelId);
it('override 指到别的引擎 → 仍显示,排在优先行后面', () => {
// dual 候选含 cc,用户把它的引擎 override 到了 codex → 兼容段,不是消失。
expect(idsOf([dual], engineOfRow({ 'deepseek/deepseek-v4-pro': 'codex' }))).toEqual([
'deepseek/deepseek-v4-pro',
]);
expect(idsOf([dual], engineOfRow())).toEqual(['deepseek/deepseek-v4-pro']);
});
it('override 指到当前引擎 → 即使主场在别处也排进优先段', () => {
const gptDual = entryOf({
providerId: 'xd',
modelId: 'gpt-5.5',
candidates: ['claude-code', 'codex'],
recommended: 'codex',
nativeAgent: 'codex',
capabilities: { 'claude-code': capability('claude-code'), codex: capability('codex') },
});
const guest = entryOf({
providerId: 'xd',
modelId: 'gpt-5.6',
candidates: ['claude-code', 'codex'],
recommended: 'codex',
nativeAgent: 'codex',
capabilities: { 'claude-code': capability('claude-code'), codex: capability('codex') },
});
expect(idsOf([guest, gptDual], engineOfRow({ 'gpt-5.5': 'cc' }))).toEqual([
'gpt-5.5',
'gpt-5.6',
]);
});
it('主场在别处的行排在生效引擎=当前引擎的行后面', () => {
const gptDual = entryOf({
providerId: 'xd',
modelId: 'gpt-5.5',
candidates: ['claude-code', 'codex'],
recommended: 'codex',
nativeAgent: 'codex',
capabilities: { 'claude-code': capability('claude-code'), codex: capability('codex') },
});
// cc 会话里:dual 无主场被 pinned 到 cc(优先),gpt 主场在 codex(兼容)。
expect(idsOf([gptDual, dual], engineOfRow())).toEqual([
'deepseek/deepseek-v4-pro',
'gpt-5.5',
]);
});
it('含优先行的供应商组排在纯兼容供应商组前面,即使 providerOrder 相反', () => {
const opus = entryOf({
providerId: 'anthropic',
modelId: 'claude-opus-5',
candidates: ['claude-code', 'pi'],
recommended: 'claude-code',
nativeAgent: 'claude-code',
capabilities: {
'claude-code': capability('claude-code'),
pi: capability('pi'),
},
});
const grok = entryOf({
providerId: 'xai',
modelId: 'grok-4.6',
candidates: ['pi'],
recommended: 'pi',
nativeAgent: null,
capabilities: { pi: capability('pi') },
});
const sections = buildUnifiedListSections({
entries: [opus, grok],
favorites: [],
query: '',
rail: { kind: 'engine', agent: 'pi' },
effectiveEngineOf: (entry) => engineOfAgentKind(entry.recommended),
providerOrder: ['anthropic', 'xai'],
});
expect(sections.flatMap((s) => s.rows.map((row) => row.entry.modelId))).toEqual([
'grok-4.6',
'claude-opus-5',
]);
});
it('无主场的行照常跟随 pinnedEngine 通过过滤(§2.1 例外不受影响)', () => {
expect(dual.nativeAgent).toBeNull();
expect(idsOf([dual], engineOfRow({}, 'cc'))).toEqual(['deepseek/deepseek-v4-pro']);
});
it('收藏解析回落到别家(条目存的引擎掉出候选)→ 该收藏行同样不显示', () => {
// 条目存 cc,但这个模型只在 codex 有条目 → resolveFavoriteRowConfig 回落 codex。
const staleFav = favoriteOf({
uid: 'fav-9',
providerId: 'xd',
modelId: 'codex/gpt-5.5',
agent: 'cc',
});
const withResolver = buildUnifiedListSections({
entries: [codexOnly],
favorites: [staleFav],
query: '',
rail: { kind: 'engine', agent: 'claude-code' },
effectiveEngineOf: engineOfRow(),
});
expect(withResolver.some((s) => s.kind === 'favorites')).toBe(false);
// 不注入解析器时维持旧行为(只看条目自己存的引擎)—— 旧断言不被本次改动掀翻。
const withoutResolver = buildUnifiedListSections({
entries: [codexOnly],
favorites: [staleFav],
query: '',
rail: { kind: 'engine', agent: 'claude-code' },
});
expect(withoutResolver[0]?.kind).toBe('favorites');
});
it('收藏解析回落到**当前引擎**(条目存的引擎掉出候选)→ 该收藏行必须显示', () => {
// 2026-08-19 review P2:此前先按 item.agent 硬排除,会把这条错杀出「无损」视图 ——
// 它存的 codex 已不在候选里,解析回落到 cc(= 当前会话引擎),点它无损、画出来也是
// cc。注入解析器时判据只有「解析后的生效引擎」这一个,与模型行同构。
const ccOnly = entryOf({
providerId: 'xd',
modelId: 'claude-opus-5',
candidates: ['claude-code'],
recommended: 'claude-code',
nativeAgent: 'claude-code',
capabilities: { 'claude-code': capability('claude-code') },
});
const staleCodexFav = favoriteOf({
uid: 'fav-10',
providerId: 'xd',
modelId: 'claude-opus-5',
agent: 'codex',
});
const sections = buildUnifiedListSections({
entries: [ccOnly],
favorites: [staleCodexFav],
query: '',
rail: { kind: 'engine', agent: 'claude-code' },
effectiveEngineOf: engineOfRow(),
});
expect(sections[0]?.kind).toBe('favorites');
expect(sections[0]?.rows.map((row) => row.favorite?.uid)).toEqual(['fav-10']);
});
it('「全部」视图不受生效引擎影响(跨引擎是显式入口)', () => {
const sections = buildUnifiedListSections({
entries: [dual, codexOnly],
favorites: [],
query: '',
rail: { kind: 'all' },
effectiveEngineOf: engineOfRow({ 'deepseek/deepseek-v4-pro': 'codex' }),
});
expect(sections.flatMap((s) => s.rows).map((r) => r.entry.modelId)).toEqual([
'deepseek/deepseek-v4-pro',
'codex/gpt-5.5',
]);
});
});
it('同引擎视图里收藏按**条目自己存的引擎**过滤', () => {
const favCc = favoriteOf({
uid: 'fav-1',
providerId: 'xd',
modelId: 'deepseek/deepseek-v4-pro',
agent: 'cc',
});
const favCodex = favoriteOf({
uid: 'fav-2',
providerId: 'xd',
modelId: 'deepseek/deepseek-v4-pro',
agent: 'codex',
});
const sections = buildUnifiedListSections({
entries: [dual],
favorites: [favCc, favCodex],
query: '',
rail: { kind: 'engine', agent: 'claude-code' },
});
expect(sections[0].kind).toBe('favorites');
expect(sections[0].rows.map((row) => row.favorite?.uid)).toEqual(['fav-1']);
});
it('「全部」视图不做引擎过滤(跨引擎是显式入口)', () => {
const sections = buildUnifiedListSections({
entries: [dual, codexOnly],
favorites: [],
query: '',
rail: { kind: 'all' },
});
const ids = sections.flatMap((s) => s.rows.map((r) => r.entry.modelId));
expect(ids).toEqual(['deepseek/deepseek-v4-pro', 'codex/gpt-5.5']);
});
});
describe('buildUnifiedRail', () => {
it('最近 / ★ 常驻,最近在上;供应商按行首次出现序排列', () => {
const entries = [
entryOf({ providerId: 'xd', modelId: 'a' }),
entryOf({ providerId: 'anthropic', modelId: 'b' }),
entryOf({ providerId: 'xd', modelId: 'c' }),
];
// 两格常驻(2026-08-13 ★ 裁决 / 2026-09-16 最近裁决:空列表也显示,点进去看引导空态)。
expect(buildUnifiedRail(entries)).toEqual([
{ kind: 'recent' },
{ kind: 'favorites' },
{ kind: 'all' },
{ kind: 'provider', providerId: 'xd' },
{ kind: 'provider', providerId: 'anthropic' },
]);
// 最近在收藏之上(2026-09-16 实测反馈)。
expect(buildUnifiedRail(entries)[0]).toEqual({ kind: 'recent' });
expect(buildUnifiedRail(entries)[1]).toEqual({ kind: 'favorites' });
});
it('会话内多一格「同引擎」,位置在 ★ 之下、全部之上', () => {
const entries = [entryOf({ providerId: 'xd', modelId: 'a' })];
expect(buildUnifiedRail(entries, 'codex')).toEqual([
{ kind: 'recent' },
{ kind: 'favorites' },
{ kind: 'engine', agent: 'codex' },
{ kind: 'all' },
{ kind: 'provider', providerId: 'xd' },
]);
// 草稿场景不出现这一格。
expect(buildUnifiedRail(entries).some((item) => item.kind === 'engine')).toBe(false);
});
it('传 providerOrder 时供应商图标按设置页拖动序排,未收录供应商按首见序追加', () => {
const entries = [
entryOf({ providerId: 'xd', modelId: 'a' }),
entryOf({ providerId: 'anthropic', modelId: 'b' }),
entryOf({ providerId: 'openai', modelId: 'c' }),
];
expect(buildUnifiedRail(entries, undefined, ['openai', 'xd'])).toEqual([
{ kind: 'recent' },
{ kind: 'favorites' },
{ kind: 'all' },
{ kind: 'provider', providerId: 'openai' },
{ kind: 'provider', providerId: 'xd' },
{ kind: 'provider', providerId: 'anthropic' },
]);
});
});
describe('computeSelectedRowScrollTop(选中行位于 35% 高度)', () => {
const base = { scrollTop: 0, clientHeight: 400, scrollHeight: 2000, headerInset: 0 };
it('把选中行的中心对齐到可视区 35%', () => {
// 行 [1000,1044] → 中心 1022;可视区高 400 → 目标 scrollTop = 1022 - 140 = 882。
expect(
computeSelectedRowScrollTop({ ...base, rowTop: 1000, rowBottom: 1044 }),
).toEqual({ scrollTop: 882, oversized: false });
});
it('列表头部的行夹到 0(不能负滚),尾部的行夹到 scrollHeight - clientHeight', () => {
expect(computeSelectedRowScrollTop({ ...base, rowTop: 8, rowBottom: 52 }).scrollTop).toBe(0);
expect(
computeSelectedRowScrollTop({ ...base, rowTop: 1950, rowBottom: 1994 }).scrollTop,
).toBe(1600);
});
it('题头实底从可视高度里扣掉:居中位置随之下移半条题头', () => {
// badge 题头盖住顶部 38px:可视区 [scrollTop+38, +400),中心比无题头时低 (38+38/2)?
// 目标 = 中心 - inset - (clientHeight - inset)/2 = 1022 - 38 - 181 = 803。
expect(
computeSelectedRowScrollTop({ ...base, headerInset: 38, rowTop: 1000, rowBottom: 1044 })
.scrollTop,
).toBe(857);
});
it('行比可视区还高 → 顶对齐并标 oversized(调用方据此一次收工,防振荡)', () => {
const result = computeSelectedRowScrollTop({
...base,
clientHeight: 40,
rowTop: 1000,
rowBottom: 1080,
});
expect(result.oversized).toBe(true);
expect(result.scrollTop).toBe(1000);
});
it('内容不足以滚动时恒返回 0(morph 首帧的极矮容器不会算出负值)', () => {
expect(
computeSelectedRowScrollTop({
scrollTop: 0,
clientHeight: 12,
scrollHeight: 12,
headerInset: 0,
rowTop: 0,
rowBottom: 44,
}).scrollTop,
).toBe(0);
});
});
describe('computeFlyoutPlacement', () => {
const panel = { top: 100, bottom: 500, left: 400, right: 800 };
const size = { width: 264, height: 300 };
const viewport = { width: 1440, height: 900 };
it('默认贴面板左外侧,顶端跟随锚点行', () => {
const placement = computeFlyoutPlacement({
anchor: { top: 150, bottom: 190, left: 410, right: 780 },
panel,
size,
viewport,
});
expect(placement.side).toBe('left');
expect(placement.left).toBe(400 - UNIFIED_FLYOUT_GAP - 264);
expect(placement.top).toBe(150 - 12);
});
it('左边放不下时翻到右侧', () => {
const placement = computeFlyoutPlacement({
anchor: { top: 240, bottom: 280, left: 20, right: 380 },
panel: { ...panel, left: 20, right: 380 },
size,
viewport,
});
expect(placement.side).toBe('right');
expect(placement.left).toBe(380 + UNIFIED_FLYOUT_GAP);
});
it('垂直钳制在面板内:底部行 → 与面板底对齐,顶部行不高过面板顶(设计稿 flyFinish)', () => {
// 锚点在面板底部附近:浮层底不越过面板底(500),top = 500 - 300 = 200。
const low = computeFlyoutPlacement({
anchor: { top: 470, bottom: 500, left: 410, right: 780 },
panel,
size,
viewport,
});
expect(low.top).toBe(500 - 300);
// 锚点在面板顶(带 rowOffset 会高过面板顶):钳回面板顶(100)。
const high = computeFlyoutPlacement({
anchor: { top: 100, bottom: 140, left: 410, right: 780 },
panel,
size,
viewport,
});
expect(high.top).toBe(100);
});
it('面板贴近屏幕边缘时视口安全区仍兜底', () => {
// 面板底伸到视口外:面板钳制想给 top=880-300=580… 视口钳制把它压回 900-300-8。
const placement = computeFlyoutPlacement({
anchor: { top: 860, bottom: 880, left: 410, right: 780 },
panel: { ...panel, top: 400, bottom: 1000 },
size,
viewport,
});
expect(placement.top).toBe(900 - 300 - 8);
});
it('两侧都放不下时仍留在视口内', () => {
const placement = computeFlyoutPlacement({
anchor: { top: 240, bottom: 280, left: 10, right: 590 },
panel: { ...panel, left: 10, right: 590 },
size,
viewport: { width: 600, height: 900 },
});
expect(placement.left).toBeGreaterThanOrEqual(8);
expect(placement.left + size.width).toBeLessThanOrEqual(600 - 8 + 1);
});
});
describe('档位绝对色', () => {
it('色映射按档位 key 绝对取值 —— 封顶 high 的模型拉满仍是蓝,不是紫', () => {
expect(effortTierColor('high')).toBe('#3B82F6');
expect(effortTierColor('max')).toBe('#8B5CF6');
// 只有真正支持 max / ultra 的模型才会出现顶档紫。
const cappedTop = ['low', 'medium', 'high'].at(-1) as string;
expect(effortTierColor(cappedTop)).not.toBe(EFFORT_TIER_COLORS.max);
});
it('minimal 与 low 同绿、ultra 与 max 同紫(规格 §1.3)', () => {
expect(effortTierColor('minimal')).toBe(effortTierColor('low'));
expect(effortTierColor('ultra')).toBe(effortTierColor('max'));
});
it('未知档位回落中间档色,不谎报顶档', () => {
expect(effortTierColor('brand-new-tier')).toBe(EFFORT_TIER_COLORS.medium);
expect(effortTierColor(null)).toBe(EFFORT_TIER_COLORS.medium);
});
it('hexLerp 端点精确、中点插值(输出统一大写,与常量表同形)', () => {
expect(hexLerp('#000000', '#ffffff', 0)).toBe('#000000');
expect(hexLerp('#000000', '#ffffff', 1)).toBe('#FFFFFF');
expect(hexLerp('#000000', '#ffffff', 0.5)).toBe('#808080');
// 越界钳制,不产生非法色值。
expect(hexLerp('#000000', '#ffffff', 5)).toBe('#FFFFFF');
});
it('拖动中的条色在相邻档色之间连续过渡', () => {
const stops = ['low', 'medium', 'high'];
expect(effortTierColorAt(stops, 0)).toBe(effortTierColor('low'));
expect(effortTierColorAt(stops, 1)).toBe(effortTierColor('medium'));
expect(effortTierColorAt(stops, 0.5)).toBe(
hexLerp(effortTierColor('low'), effortTierColor('medium'), 0.5),
);
// 越界坐标钳制到首 / 末档色。
expect(effortTierColorAt(stops, 9)).toBe(effortTierColor('high'));
expect(effortTierColorAt([], 0)).toBe(EFFORT_TIER_COLORS.medium);
});
});
/**
* 合并行(归一化行身份 + 每引擎 wire id)。这一层最容易做错的是**两个 id 的分工**:
* 行身份用来「记住这一行」(anchor / override / 收藏),wire id 用来「发出去 / 读写既有
* 按 wire id 索引的表」。混用不会立刻崩,而是悄悄写出一份谁也读不到的记忆、或者让选中的
* 模型在列表里不高亮。
*/
describe('合并行:行身份 vs wire id', () => {
const merged = entryOf({
providerId: 'openai',
modelId: 'gpt-5.6',
displayName: 'GPT-5.6',
candidates: ['claude-code', 'codex'],
recommended: 'codex',
nativeAgent: 'codex',
capabilities: {
// 同一逻辑模型:codex 上是 root 条目,cc 上是 bridge 壳 —— wire id 不同。
codex: capability('codex', { wireModelId: 'gpt-5.6' }),
'claude-code': capability('claude-code', { wireModelId: 'chatgpt/gpt-5.6' }),
},
});
it('wireModelIdOf 按引擎取真实要发的 id,缺失回落行身份', () => {
expect(wireModelIdOf(merged, 'codex')).toBe('gpt-5.6');
expect(wireModelIdOf(merged, 'claude-code')).toBe('chatgpt/gpt-5.6');
// pi 不在候选 → 没有能力条目 → 回落行身份(调用方不该拿它发请求,但不能崩)。
expect(wireModelIdOf(merged, 'pi')).toBe('gpt-5.6');
});
it('entryMatchesModelId 同时认行身份与任一引擎的 wire id', () => {
expect(entryMatchesModelId(merged, 'gpt-5.6')).toBe(true);
expect(entryMatchesModelId(merged, 'chatgpt/gpt-5.6')).toBe(true);
expect(entryMatchesModelId(merged, 'gpt-5.5')).toBe(false);
expect(entryMatchesModelId(merged, null)).toBe(false);
});
it('生效配置带上该引擎的 wireModelId(切引擎即换 wire id)', () => {
expect(resolveUnifiedRowConfig({ entry: merged }).wireModelId).toBe('gpt-5.6');
expect(
resolveUnifiedRowConfig({ entry: merged, engineOverride: 'cc' }).wireModelId,
).toBe('chatgpt/gpt-5.6');
expect(
resolveFavoriteRowConfig({ entry: merged, item: favoriteOf({ agent: 'cc' }) }).wireModelId,
).toBe('chatgpt/gpt-5.6');
});
it('老收藏存的是某引擎的 wire id 时仍能认出这一行(升级不丢收藏)', () => {
const legacy = favoriteOf({
uid: 'fav-legacy',
providerId: 'openai',
modelId: 'chatgpt/gpt-5.6',
agent: 'cc',
});
const sections = buildUnifiedListSections({
entries: [merged],
favorites: [legacy],
query: '',
rail: { kind: 'all' },
});
expect(sections[0].kind).toBe('favorites');
expect(sections[0].rows[0].entry.modelId).toBe('gpt-5.6');
});
});
describe('默认种子置顶与原生底座排序', () => {
const seed = entryOf({
providerId: 'xd',
modelId: 'deepseek-v4-pro',
displayName: 'DeepSeek V4 Pro',
group: 'china',
sortOrder: 9,
});
const opus = entryOf({ group: 'anthropic', sortOrder: 1 });
const gpt = entryOf({
providerId: 'xd',
modelId: 'gpt-5.5',
displayName: 'GPT-5.5',
group: 'gpt',
sortOrder: 2,
candidates: ['claude-code', 'codex'],
recommended: 'claude-code',
nativeAgent: 'codex',
capabilities: {
'claude-code': capability('claude-code'),
codex: capability('codex'),
},
});
it('没有「默认」小节:默认推荐改以种子收藏交付,列表只有收藏与供应商分组', () => {
// Chris 2026-08-16 裁决:去掉默认小节;seed 行留在自己的供应商组里。
const sections = buildUnifiedListSections({
entries: [opus, gpt, seed],
favorites: [favoriteOf()],
query: '',
rail: { kind: 'all' },
});
expect(sections.every((section) => section.kind === 'favorites' || section.kind === 'group')).toBe(true);
const grouped = sections.filter((s) => s.kind === 'group').flatMap((s) => s.rows.map((r) => r.entry.modelId));
expect(grouped).toContain('deepseek-v4-pro');
});
it('同引擎视图把原生底座 == 该引擎的行排在仅兼容的行前面', () => {
const sections = buildUnifiedListSections({
// 入参顺序:opus(native cc)在前,gpt(native codex)在后。
entries: [opus, gpt],
favorites: [],
query: '',
rail: { kind: 'engine', agent: 'codex' },
});
// codex 视图:native=codex 的 GPT 组先出现;opus 的 cc 原生行仅兼容 → 排在后面。
// (opus 只有 cc 候选,在 codex 视图里会被准入过滤掉,故这里只剩 GPT 一组。)
expect(sections.flatMap((s) => s.rows.map((r) => r.entry.modelId))).toEqual(['gpt-5.5']);
const bothCandidates = entryOf({
providerId: 'xd',
modelId: 'claude-opus-5',
displayName: 'Opus 5',
group: 'anthropic',
sortOrder: 1,
candidates: ['claude-code', 'codex'],
recommended: 'claude-code',
nativeAgent: 'claude-code',
capabilities: {
'claude-code': capability('claude-code'),
codex: capability('codex'),
},
});
const mixed = buildUnifiedListSections({
entries: [bothCandidates, gpt],
favorites: [],
query: '',
rail: { kind: 'engine', agent: 'codex' },
});
// sortOrder 上 Opus(1)在 GPT(2)之前,但 codex 会话里原生 codex 的 GPT 该排前面。
expect(mixed.flatMap((s) => s.rows.map((r) => r.entry.modelId))).toEqual([
'gpt-5.5',
'claude-opus-5',
]);
});
it('新会话全量视图不按原生底座重排(服务端编排说了算)', () => {
const sections = buildUnifiedListSections({
entries: [opus, gpt],
favorites: [],
query: '',
rail: { kind: 'all' },
});
expect(sections.flatMap((s) => s.rows.map((r) => r.entry.modelId))).toEqual([
'claude-opus-5',
'gpt-5.5',
]);
});
});
describe('收藏锚点只代表当前完整配置', () => {
const entry = entryOf({
providerId: 'openai',
modelId: 'gpt-6',
candidates: ['codex'],
recommended: 'codex',
capabilities: { codex: capability('codex', { wireModelId: 'gpt-6', supportsFastMode: true }) },
});
const item = favoriteOf({
providerId: 'openai',
modelId: 'gpt-6',
agent: 'codex',
effort: 'high',
fast: true,
});
const selected = { providerId: 'openai', modelId: 'gpt-6' };
const base = { entry, item, selected, agent: 'codex' as const, effort: 'high', fast: true };
it('同一组合保持选中,关 Fast / 换档 / 换来源 / 换模型 / 换引擎都不冒充收藏', () => {
expect(favoriteMatchesSelection(base)).toBe(true);
for (const changed of [
{ fast: false },
{ effort: 'low' },
{ effort: '' },
{ agent: 'claude-code' as const },
{ agent: null },
{ selected: { ...selected, providerId: 'xd' } },
{ selected: { ...selected, providerId: null } },
{ selected: { ...selected, modelId: 'other' } },
])
expect(favoriteMatchesSelection({ ...base, ...changed })).toBe(false);
});
it('收藏不支持的引擎不能静默回落后冒充当前收藏', () => {
expect(favoriteMatchesSelection({ ...base, item: { ...item, agent: 'cc' } })).toBe(false);
});
it('同一个归一化模型的 wire id 可以匹配,Fast 仍按该来源能力判断', () => {
const aliased = { ...entry, modelId: 'normalized-gpt-6' };
expect(favoriteMatchesSelection({ ...base, entry: aliased })).toBe(true);
expect(favoriteMatchesSelection({ ...base, agentFastModeCapable: () => false })).toBe(false);
});
});