Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* providerModelSections 单测:守住手机 provider-aware 下拉的派生口径与桌面/IM 一致——
* 只列已连接供应商、同 id 多来源各出一行、可见性按被控端 override + 目录 defaultEnabled
* 过滤(旧被控端无 overrides → 不过滤降级)、activeSourceId 按当前模型收窄(共享
* effectiveSourceIdForModel,桌面 0f75dd560 同口径;未传 selectedModelId 保持旧口径)、
* effort reconcile 口径、resolveRowSelection 选行落点。
* 纯逻辑,node env,不 import react-native。
*/
import { describe, expect, it } from 'vitest';
import type { ProviderView } from '@cindy/model-providers/registry';
import type { SectionModel } from '@cindy/model-providers/sections';
import type { MobileModelMemoryAccessors } from '@/session/draftModelMemory';
import {
buildMobileModelSections,
flattenProviderSections,
isFastRestorable,
isSelectedSourceDisconnected,
reconcileEffortForModel,
resolveRowSelection,
type ProviderModelRow,
} from '@/session/providerModelSections';
function model(id: string, patch: Partial<{ defaultEnabled: boolean; efforts: string[]; defaultEffort: string | null }> = {}) {
return {
id,
name: id.toUpperCase(),
contextWindow: 200000,
efforts: patch.efforts ?? [],
defaultEffort: patch.defaultEffort ?? null,
...(patch.defaultEnabled !== undefined ? { defaultEnabled: patch.defaultEnabled } : {}),
};
}
function provider(
id: string,
opts: { connected?: boolean; agents?: Array<'claude-code' | 'codex'>; codex?: unknown[]; cc?: unknown[] },
): ProviderView {
return {
id,
name: id,
agents: opts.agents ?? ['codex'],
routing: Object.fromEntries((opts.agents ?? ['codex']).map((agent) => [agent, {}])),
connected: opts.connected ?? true,
models: { codex: opts.codex, 'claude-code': opts.cc },
} as unknown as ProviderView;
}
describe('buildMobileModelSections', () => {
it('只列已连接供应商;同 id 多来源各出一行', () => {
const providers = [
provider('openai', { codex: [model('gpt-5.5'), model('gpt-5.4')] }),
provider('xd', { codex: [model('gpt-5.5')] }),
provider('offline', { connected: false, codex: [model('gpt-5.5')] }),
];
const { sections, connected } = buildMobileModelSections({ providers, agentKind: 'codex' });
expect(connected.map((p) => p.id)).toEqual(['openai', 'xd']);
const rows = flattenProviderSections(sections);
expect(rows.map((r) => `${r.provider.id}:${r.model.id}`)).toEqual([
'openai:gpt-5.5',
'openai:gpt-5.4',
'xd:gpt-5.5',
]);
});
it('旧被控端(无 visibilityOverrides)→ 不过滤:defaultEnabled=false 的模型也显示', () => {
const providers = [
provider('openai', { codex: [model('gpt-5.5'), model('longtail', { defaultEnabled: false })] }),
];
const visible = flattenProviderSections(
buildMobileModelSections({ providers, agentKind: 'codex' }).sections,
);
expect(visible.map((r) => r.model.id)).toEqual(['gpt-5.5', 'longtail']);
});
it('有 visibilityOverrides → 按被控端开关过滤:override 优先,缺省跟 defaultEnabled', () => {
const providers = [
provider('openai', {
codex: [
model('gpt-5.5'), // 无 override,defaultEnabled 缺省 → 显示
model('gpt-5.4'), // override=false → 隐藏
model('longtail', { defaultEnabled: false }), // 无 override,defaultEnabled=false → 隐藏
model('revived', { defaultEnabled: false }), // override=true 压过 defaultEnabled=false → 显示
],
}),
];
const visible = flattenProviderSections(
buildMobileModelSections({
providers,
agentKind: 'codex',
visibilityOverrides: {
'codex:openai:gpt-5.4': false,
'codex:openai:revived': true,
},
}).sections,
);
expect(visible.map((r) => r.model.id)).toEqual(['gpt-5.5', 'revived']);
});
it('当前选中行即使被隐藏也保留(buildProviderSections 内建豁免,与桌面一致)', () => {
const providers = [
provider('openai', { codex: [model('gpt-5.5'), model('gpt-5.4')] }),
];
const visible = flattenProviderSections(
buildMobileModelSections({
providers,
agentKind: 'codex',
selectedModelId: 'gpt-5.4',
selectedProviderId: 'openai',
visibilityOverrides: { 'codex:openai:gpt-5.4': false },
}).sections,
);
expect(visible.map((r) => r.model.id)).toEqual(['gpt-5.5', 'gpt-5.4']);
});
it('搜索 query 过滤 name / id(大小写不敏感,共享 buildProviderSections 口径)', () => {
const providers = [
provider('openai', { codex: [model('gpt-5.5'), model('gpt-5.4')] }),
];
const rows = flattenProviderSections(
buildMobileModelSections({ providers, agentKind: 'codex', query: '5.4' }).sections,
);
expect(rows.map((r) => r.model.id)).toEqual(['gpt-5.4']);
});
it('activeSourceId:显式来源失效时不替换账号;未指定时选择原生默认', () => {
const providers = [
provider('xd', { codex: [model('gpt-5.5')] }),
provider('openai', { codex: [model('gpt-5.5')] }),
];
expect(buildMobileModelSections({ providers, agentKind: 'codex' }).activeSourceId).toBe('openai');
expect(
buildMobileModelSections({ providers, agentKind: 'codex', selectedProviderId: 'xd' }).activeSourceId,
).toBe('xd');
// 选了未连接/不存在的来源,不回退另一个账号。
expect(
buildMobileModelSections({ providers, agentKind: 'codex', selectedProviderId: 'ghost' }).activeSourceId,
).toBeNull();
});
it('cc agent 的 nativeDefault 优先 xd', () => {
const providers = [
provider('anthropic', { agents: ['claude-code'], cc: [model('claude-opus-4-8')] }),
provider('xd', { agents: ['claude-code'], cc: [model('claude-opus-4-8')] }),
];
expect(buildMobileModelSections({ providers, agentKind: 'claude-code' }).activeSourceId).toBe('xd');
});
it('activeSourceId:显式来源不提供该模型时不改用另一账号', () => {
// 会话粘着 providerId=anthropic(仍连接),但当前模型只有 xd 提供
// 不能将显式账号改为 xd。
const providers = [
provider('anthropic', { agents: ['claude-code'], cc: [model('claude-opus-4-8')] }),
provider('xd', { agents: ['claude-code'], cc: [model('claude-opus-4-8'), model('claude-fable-5')] }),
];
expect(
buildMobileModelSections({
providers,
agentKind: 'claude-code',
selectedModelId: 'claude-fable-5',
selectedProviderId: 'anthropic',
}).activeSourceId,
).toBeNull();
// 显式来源确实提供该模型 → 尊重显式选择。
expect(
buildMobileModelSections({
providers,
agentKind: 'claude-code',
selectedModelId: 'claude-opus-4-8',
selectedProviderId: 'anthropic',
}).activeSourceId,
).toBe('anthropic');
});
it('activeSourceId:没有任何已连接来源提供当前模型 → null(不拼不存在的路由)', () => {
// cc 会话选了 Opus,但只有 ChatGPT 订阅(openai)连接且它不提供 Opus
// —— 修复前兜底到 openai(「OpenAI 图标 + Opus」事故形态),修复后返回 null。
const providers = [
provider('openai', { agents: ['claude-code'], cc: [model('chatgpt/gpt-5.5')] }),
];
expect(
buildMobileModelSections({
providers,
agentKind: 'claude-code',
selectedModelId: 'claude-opus-4-8',
}).activeSourceId,
).toBeNull();
});
it('失效的显式来源不会给另一个账号的同名模型可见性豁免', () => {
// anthropic 不提供这个模型,不能把 xd 的隐藏模型当作当前选择。
const providers = [
provider('anthropic', { agents: ['claude-code'], cc: [model('claude-opus-4-8')] }),
provider('xd', { agents: ['claude-code'], cc: [model('claude-fable-5')] }),
];
const { sections } = buildMobileModelSections({
providers,
agentKind: 'claude-code',
selectedModelId: 'claude-fable-5',
selectedProviderId: 'anthropic',
visibilityOverrides: { 'claude-code:xd:claude-fable-5': false },
});
const rows = flattenProviderSections(sections);
expect(rows.map((r) => `${r.provider.id}:${r.model.id}`)).not.toContain('xd:claude-fable-5');
});
});
describe('isSelectedSourceDisconnected', () => {
const providers = [provider('openai', { codex: [model('gpt-5.5')] })];
it('only reports disconnected from a successful provider snapshot', () => {
const base = {
providers,
providerId: 'missing-provider',
modelId: 'gpt-5.5',
agentKind: 'codex' as const,
};
expect(isSelectedSourceDisconnected({ ...base, loading: false, error: null })).toBe(true);
expect(isSelectedSourceDisconnected({ ...base, loading: true, error: null })).toBe(false);
expect(isSelectedSourceDisconnected({ ...base, loading: false, error: 'fetch failed' })).toBe(false);
});
it('keeps a connected source in the normal state', () => {
expect(isSelectedSourceDisconnected({
providers,
providerId: 'openai',
modelId: 'gpt-5.5',
agentKind: 'codex',
loading: false,
error: null,
})).toBe(false);
});
it('reports disconnected when the selected source\'s copy of the id is non-chat (issue #882, 2026-07 review: same as desktop sourceSwitch.ts)', () => {
const nonChatProviders = [
provider('xd', { codex: [{ ...model('shared-id'), mode: 'image_generation' }] }),
];
expect(isSelectedSourceDisconnected({
providers: nonChatProviders,
providerId: 'xd',
modelId: 'shared-id',
agentKind: 'codex',
loading: false,
error: null,
})).toBe(true);
});
});
describe('resolveRowSelection —— 选行落点(effort 优先级与桌面共享实现同源)', () => {
const providerView = (id: string): ProviderView =>
provider(id, {
codex: [
model('gpt-5.5', { efforts: ['low', 'medium', 'high', 'xhigh'], defaultEffort: 'medium' }),
],
});
const rowOf = (providerId: string): ProviderModelRow => {
const p = providerView(providerId);
return {
provider: p,
model: {
id: 'gpt-5.5',
displayName: 'GPT-5.5',
efforts: ['low', 'medium', 'high', 'xhigh'] as never,
defaultEffort: 'medium' as never,
contextWindow: 272000,
},
};
};
const memoryWith = (effort?: string, fast?: boolean | 'ultrafast'): MobileModelMemoryAccessors => ({
getEffort: () => effort,
setEffort: () => undefined,
getFast: () => fast,
setFast: () => undefined,
});
it('换模型:有 (来源, 模型) 记忆 → 精确恢复', () => {
const next = resolveRowSelection({
row: rowOf('openai'),
agentKind: 'codex',
currentModelId: 'gpt-5.4',
currentProviderId: 'openai',
currentEffort: 'low',
hasFastModeCap: true,
memory: memoryWith('xhigh'),
});
expect(next).toMatchObject({ model: 'gpt-5.5', providerId: 'openai', effort: 'xhigh' });
});
it('换模型:无记忆 → 沿用当前档(仍受支持时)', () => {
const next = resolveRowSelection({
row: rowOf('openai'),
agentKind: 'codex',
currentModelId: 'gpt-5.4',
currentProviderId: 'openai',
currentEffort: 'high',
hasFastModeCap: true,
memory: memoryWith(undefined),
});
expect(next.effort).toBe('high');
});
it('【串档回归】同模型换来源:新来源无记忆 → 落模型默认,绝不沿用当前档', () => {
const next = resolveRowSelection({
row: rowOf('xd'),
agentKind: 'codex',
currentModelId: 'gpt-5.5',
currentProviderId: 'openai',
currentEffort: 'xhigh', // openai 侧当前档,不能被 xd 行继承
hasFastModeCap: true,
memory: memoryWith(undefined),
});
expect(next).toMatchObject({ model: 'gpt-5.5', providerId: 'xd', effort: 'medium' });
});
it('fast:fastEditable(hasFastModeCap × supportsFastMode)门控,恢复记忆,缺省 false', () => {
const p = provider('openai', {
codex: [model('gpt-5.5', { efforts: ['medium'], defaultEffort: 'medium' })],
});
(p.models.codex![0] as { supportsFastMode?: boolean }).supportsFastMode = true;
const row: ProviderModelRow = {
provider: p,
model: {
id: 'gpt-5.5',
displayName: 'GPT-5.5',
efforts: ['medium'] as never,
defaultEffort: 'medium' as never,
supportsFastMode: true,
contextWindow: 272000,
},
};
const base = {
row,
agentKind: 'codex' as const,
currentModelId: 'gpt-5.4',
currentProviderId: 'openai',
currentEffort: 'medium',
};
expect(resolveRowSelection({ ...base, hasFastModeCap: true, memory: memoryWith(undefined, true) }).fastMode).toBe(true);
expect(resolveRowSelection({ ...base, hasFastModeCap: true, memory: memoryWith(undefined) }).fastMode).toBe(false);
// agent 级 gate 关掉 → 即便记忆为 true 也不带 fast。
expect(resolveRowSelection({ ...base, hasFastModeCap: false, memory: memoryWith(undefined, true) }).fastMode).toBe(false);
});
// PR #6559 P1, unit: selection output used by new/switch draft requests.
// Existing cases only restored booleans. Minimal failure: ultrafast memory
// after the target account withdraws that capability (Fast remains enabled).
it('restores Ultrafast only while the target account and engine support it', () => {
const p = provider('openai', { codex: [{ ...model('gpt-5.5'), supportsFastMode: true }] });
const row: ProviderModelRow = {
provider: p,
model: { ...rowOf('openai').model, supportsFastMode: true, supportsUltrafastMode: true },
};
const memory = memoryWith(undefined, 'ultrafast');
const base = { row, agentKind: 'codex' as const, currentModelId: 'gpt-5.4',
currentProviderId: 'openai', currentEffort: 'medium', hasFastModeCap: true, memory };
expect(resolveRowSelection(base).fastMode).toBe('ultrafast');
row.model.supportsUltrafastMode = false;
expect(resolveRowSelection(base).fastMode).toBe(false);
expect(isFastRestorable('codex', 'openai', 'gpt-5.5', [row], true, 'ultrafast')).toBe(false);
row.model.supportsUltrafastMode = true;
expect(resolveRowSelection(base).fastMode).toBe('ultrafast');
expect(isFastRestorable('codex', 'openai', 'gpt-5.5', [row], true, 'ultrafast')).toBe(true);
expect(resolveRowSelection({ ...base, hasFastModeCap: false }).fastMode).toBe(false);
p.agents = ['claude-code'];
p.models['claude-code'] = p.models.codex;
p.routing = { 'claude-code': { upstream: 'https://example.test', authStrategy: 'oauth-passthrough' } };
expect(resolveRowSelection({ ...base, agentKind: 'claude-code' }).fastMode).toBe(false);
});
it('模型无 effort 档 → 空串(手机语义:创建/切换时省略该字段)', () => {
const p = provider('openai', { codex: [model('gpt-mini')] });
const row: ProviderModelRow = {
provider: p,
model: { id: 'gpt-mini', displayName: 'Mini', efforts: [] as never, defaultEffort: null, contextWindow: 1 },
};
const next = resolveRowSelection({
row,
agentKind: 'codex',
currentModelId: 'gpt-5.5',
currentProviderId: 'openai',
currentEffort: 'medium',
hasFastModeCap: false,
});
expect(next.effort).toBe('');
});
});
describe('isFastRestorable —— 记忆 fast 恢复前的重验门控(codex P2)', () => {
const fastRow = (supports: boolean): ProviderModelRow => {
const p = provider('openai', { codex: [model('gpt-5.5')] });
(p.models.codex![0] as { supportsFastMode?: boolean }).supportsFastMode = supports;
return {
provider: p,
model: { id: 'gpt-5.5', displayName: 'GPT-5.5', efforts: [] as never, defaultEffort: null, supportsFastMode: supports, contextWindow: 1 },
};
};
it('行在目录中且支持 Fast 且 agent 有能力 → 可恢复', () => {
expect(isFastRestorable('codex', 'openai', 'gpt-5.5', [fastRow(true)], true, true)).toBe(true);
});
it('目录不再标记 Fast-capable → 不可恢复(防 UI 关 / 实发 true 矛盾态)', () => {
expect(isFastRestorable('codex', 'openai', 'gpt-5.5', [fastRow(false)], true, true)).toBe(false);
});
it('agent 无 Fast 能力(hasFastModeCap=false)→ 不可恢复', () => {
expect(isFastRestorable('codex', 'openai', 'gpt-5.5', [fastRow(true)], false, true)).toBe(false);
});
it('(provider, model) 不在目录中 → 不可恢复', () => {
expect(isFastRestorable('codex', 'openai', 'gpt-5.5', [], true, true)).toBe(false);
expect(isFastRestorable('codex', 'other', 'gpt-5.5', [fastRow(true)], true, true)).toBe(false);
});
});
describe('reconcileEffortForModel', () => {
const m = (efforts: string[], defaultEffort: string | null): SectionModel =>
({ id: 'm', displayName: 'M', efforts: efforts as never, defaultEffort: defaultEffort as never, contextWindow: 1 });
it('当前 effort 受支持 → 保留', () => {
expect(reconcileEffortForModel(m(['low', 'medium', 'high'], 'high'), 'medium')).toBe('medium');
});
it('当前不支持 → 取默认 effort', () => {
expect(reconcileEffortForModel(m(['low', 'high'], 'high'), 'medium')).toBe('high');
});
it('默认也不在支持集 → 取首个支持档', () => {
expect(reconcileEffortForModel(m(['low', 'high'], 'xhigh'), 'medium')).toBe('low');
});
it('模型不支持 effort → 空串', () => {
expect(reconcileEffortForModel(m([], null), 'medium')).toBe('');
});
});