Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* 草稿默认模型的可用性校准。
*
* 回归的是「全新用户首屏就撞墙」:种子默认模型写死在产品默认里(cc → Opus),与本机
* 连了哪些来源无关;可连来源不提供那个 id 时,Send 直接禁用、只能弹「当前模型没有已
* 连接的来源」。校准只作用于**没被显式选过**的默认值。
*/
import { describe, expect, it, vi } from 'vitest';
import type { AgentKind, CatalogModel, ProviderView } from '@cindy/model-providers';
import { resolveNewMakerDefaultTuple } from '../lib/newMakerDefaultTuple';
import { getDraft, getDraftForPreferenceSync, setNewMakerDraftOwner } from '../state/newMakerDraft';
import {
calibrateDraftModel,
pickConnectedModelForAgent,
pickFirstConnectedModelForAgent,
resolveDraftEffectiveProviderId,
resolveDraftSessionProviderId,
resolveNewTaskDefaultRoute,
type DraftModelCalibrationInput,
} from '../lib/draftModelCalibration';
/**
* 两个只取 model id 的薄壳 —— 校准现在同时给出 (模型, 来源),而绝大多数用例只关心挑中了
* 哪个模型。来源那一维由本文件末尾的「校准结果要带上供应商」一组用例直接断言原函数。
*/
const pickId = (
...args: Parameters<typeof pickConnectedModelForAgent>
): string | null => pickConnectedModelForAgent(...args)?.model ?? null;
const calibratedId = (input: DraftModelCalibrationInput): string =>
calibrateDraftModel(input).model;
function model(id: string, over: Partial<CatalogModel> = {}): CatalogModel {
return {
id,
name: id,
group: 'test',
sortOrder: 0,
contextWindow: 200_000,
efforts: [],
defaultEffort: null,
supportsFastMode: false,
status: 'active',
...over,
} as CatalogModel;
}
function provider(
id: string,
connected: boolean,
models: Record<string, CatalogModel[]>,
/** 供应商准入类型;'subscription' 参与「优先订阅」排序(见 providersByPreference)。 */
access: 'subscription' | 'managed' | 'api' = 'managed',
): ProviderView {
const agents = Object.keys(models);
return {
id,
name: id,
source: 'builtin',
agents,
models,
// Provider availability now requires an enabled runtime, not only an entry in `agents`.
routing: Object.fromEntries(
agents.map((agent) => [
agent,
{ upstream: 'https://provider.test', authStrategy: 'none' },
]),
),
auth: { method: 'oauth' },
access: access === 'subscription' ? { kind: 'subscription', product: id } : { kind: access },
connected,
} as unknown as ProviderView;
}
const gatewayWithoutOpus = provider('xd', true, {
'claude-code': [model('claude-sonnet-5'), model('claude-haiku-4-5')],
});
const disconnectedAnthropic = provider('anthropic', false, {
'claude-code': [model('claude-opus-4-8')],
});
/** 已连接但零模型 —— 正是动态发现失败的 anthropic 的形态。 */
const connectedButEmpty = provider('anthropic', true, { 'claude-code': [] });
describe('pickConnectedModelForAgent', () => {
it('默认模型本身可用时原样保留,不无谓换模型', () => {
const providers = [provider('xd', true, { 'claude-code': [model('claude-opus-4-8')] })];
expect(pickId(providers, 'claude-code', 'claude-opus-4-8')).toBe(
'claude-opus-4-8',
);
});
it('默认模型没有已连接来源时落到已连接来源的第一个模型', () => {
expect(
pickId(
[gatewayWithoutOpus, disconnectedAnthropic],
'claude-code',
'claude-opus-4-8',
),
).toBe('claude-sonnet-5');
});
it('已连接但零模型的来源不算数(动态发现失败的 anthropic)', () => {
expect(
pickId([connectedButEmpty], 'claude-code', 'claude-opus-4-8'),
).toBeNull();
// 同时存在一个真有模型的来源时,挑那个。
expect(
pickId(
[connectedButEmpty, gatewayWithoutOpus],
'claude-code',
'claude-opus-4-8',
),
).toBe('claude-sonnet-5');
});
it('一个已连接来源都没有时返回 null,交给零来源空态', () => {
expect(
pickId([disconnectedAnthropic], 'claude-code', 'claude-opus-4-8'),
).toBeNull();
});
it('跳过非聊天模型(issue #882 第 3 点,2026-07 review):唯一调用方已预先过滤,但本函数是导出的公共工具,自己也要防', () => {
const withNonChat = provider('xd', true, {
'claude-code': [
{ ...model('gpt-image-2'), mode: 'image_generation' },
model('claude-sonnet-5'),
],
});
// preferredModelId 本身就是非聊天模型 → 不接受,落到第一个聊天模型
expect(pickId([withNonChat], 'claude-code', 'gpt-image-2')).toBe('claude-sonnet-5');
// 首个可用模型兜底同样跳过非聊天模型
expect(pickId([withNonChat], 'claude-code', 'claude-opus-4-8')).toBe('claude-sonnet-5');
});
it('用户自定义供应商显式配置的模型不被 id 启发式误杀(2026-07 review 第 25 轮)', () => {
// flux-image-x 的 id 撞上 /image/ 启发式,但它来自 source:'user' 的自定义供应商且
// group 是未知的 custom:*,isAgentSelectableModel 有意放行 —— 校准不得把它当能力模型跳过。
const userProvider = {
...provider('custom-p', true, {
'claude-code': [model('flux-image-x', { group: 'custom:custom-p' })],
}),
source: 'user',
} as unknown as ProviderView;
expect(pickId([userProvider], 'claude-code', 'flux-image-x')).toBe('flux-image-x');
expect(pickId([userProvider], 'claude-code', 'claude-opus-4-8')).toBe('flux-image-x');
});
it('取该供应商模型里排序第一个,而不是清单里排前面的那个', () => {
// 产品定稿:「可用的里面选第一个」= 目录排序第一,不是数组顺序第一。
const gateway = provider('xd', true, {
'claude-code': [
model('claude-haiku-4-5', { sortOrder: 9 }),
model('claude-opus-5', { sortOrder: 0 }),
model('claude-sonnet-5', { sortOrder: 6 }),
],
});
expect(pickId([gateway], 'claude-code', 'claude-opus-4-8')).toBe(
'claude-opus-5',
);
});
it('供应商优先订阅的 —— 网关折扣路由排得再靠前也不当默认', () => {
// 折扣路由(codex/ 前缀)在目录里 sortOrder 比官方原版小。拍平所有模型排序会让默认
// 落到它:那要网关已连接才可用,计费也走网关而不是用户已经付过钱的订阅额度。
const subscription = provider(
'openai',
true,
{ codex: [model('gpt-5.6-sol', { sortOrder: 18 }), model('gpt-5.6-luna', { sortOrder: 17 })] },
'subscription',
);
const gateway = provider('xd', true, {
codex: [model('codex/gpt-5.6-sol', { sortOrder: 8, group: 'gpt-budget' })],
});
expect(pickId([gateway, subscription], 'codex', 'gpt-nonexistent')).toBe(
'gpt-5.6-luna',
);
});
it('多个订阅供应商时按目录序 —— Claude 订阅在场时 cc tab 落 Claude 系', () => {
const anthropic = provider(
'anthropic',
true,
{ 'claude-code': [model('claude-opus-5', { sortOrder: 0 })] },
'subscription',
);
const openai = provider(
'openai',
true,
{ 'claude-code': [model('chatgpt/gpt-5.6-sol', { sortOrder: 18 })] },
'subscription',
);
// 目录序 anthropic → openai,两家都是订阅 → 取 anthropic。
expect(
pickId([anthropic, openai], 'claude-code', 'claude-opus-4-8'),
).toBe('claude-opus-5');
});
it('没有订阅供应商时才落到网关等非订阅来源', () => {
const gateway = provider('xd', true, {
codex: [model('codex/gpt-5.6-sol', { sortOrder: 8 }), model('gpt-5.6-sol', { sortOrder: 18 })],
});
expect(pickId([gateway], 'codex', 'gpt-nonexistent')).toBe(
'codex/gpt-5.6-sol',
);
});
it('默认收起的模型不当默认 —— 用户在清单里看不到它', () => {
// 这正是旧代码写死 gpt-5.5 / gpt-5.4 的实际后果:两个值不一致,且都是目录里
// defaultEnabled:false 的条目,于是种子默认模型压根不在选择器里。
const gateway = provider('xd', true, {
codex: [
model('gpt-5.4', { sortOrder: 1, defaultEnabled: false }),
model('gpt-5.6-sol', { sortOrder: 18 }),
],
});
expect(pickId([gateway], 'codex', 'gpt-nonexistent')).toBe('gpt-5.6-sol');
});
it('整组都默认收起时退回纯排序第一,不让该供应商落空', () => {
const gateway = provider('xd', true, {
codex: [
model('gpt-5.4-mini', { sortOrder: 22, defaultEnabled: false }),
model('gpt-5.4', { sortOrder: 21, defaultEnabled: false }),
],
});
expect(pickId([gateway], 'codex', 'gpt-nonexistent')).toBe('gpt-5.4');
});
it('默认模型可用时,排序与订阅优先都不得抢走它', () => {
// 第 1 步的优先级不能被择优逻辑破坏 —— 否则首屏会莫名换模型。
const gateway = provider('xd', true, {
'claude-code': [
model('claude-opus-4-8', { sortOrder: 2 }),
model('claude-opus-5', { sortOrder: 0 }),
],
});
expect(pickId([gateway], 'claude-code', 'claude-opus-4-8')).toBe(
'claude-opus-4-8',
);
});
it('不修改传入 provider 的清单顺序(排序必须走副本)', () => {
const models = [model('b', { sortOrder: 9 }), model('a', { sortOrder: 0 })];
const gateway = provider('xd', true, { codex: models });
pickId([gateway], 'codex', 'nonexistent');
// 展示层依赖 ProviderView 里的原始顺序,原地 sort 会把选择器的分组顺序搅乱。
expect(models.map((m) => m.id)).toEqual(['b', 'a']);
});
});
describe('pickFirstConnectedModelForAgent', () => {
it('忽略 newSessionDefault marker,严格返回当前可选顺序的第一项', () => {
const first = provider(
'openai',
true,
{ pi: [model('chatgpt/gpt-first', { sortOrder: 0 })] },
'subscription',
);
const marked = provider('xd', true, {
pi: [
model('deepseek/marked', {
sortOrder: 0,
newSessionDefault: ['pi'],
}),
],
});
expect(pickFirstConnectedModelForAgent([first, marked], 'pi')).toEqual({
model: 'chatgpt/gpt-first',
providerId: 'openai',
});
});
});
describe('pickConnectedModelForAgent — newSessionDefault 标记优先(步骤 0)', () => {
it('被标记为新对话默认的模型优先,即便种子模型本身可用', () => {
const providers = [
provider('xd', true, {
'claude-code': [
model('claude-opus-5', { sortOrder: 0 }),
model('deepseek', { sortOrder: 44, newSessionDefault: ['claude-code'] }),
],
}),
];
// 种子是可用的 opus-5,但目录/服务端把 deepseek 标为新对话默认 → 落到 deepseek。
expect(pickId(providers, 'claude-code', 'claude-opus-5')).toBe('deepseek');
});
it('没有标记时行为不变:种子可用则保留', () => {
const providers = [
provider('xd', true, {
'claude-code': [model('claude-opus-5'), model('claude-sonnet-5')],
}),
];
expect(pickId(providers, 'claude-code', 'claude-opus-5')).toBe('claude-opus-5');
});
it('标记只在 XD 条目上时,同 ID 来源仍按订阅优先', () => {
const gateway = provider('xd', true, {
'claude-code': [model('deepseek', { newSessionDefault: ['claude-code'] })],
});
const sub = provider(
'anthropic',
true,
{ 'claude-code': [model('deepseek')] },
'subscription',
);
const picked = pickConnectedModelForAgent([gateway, sub], 'claude-code', 'seed');
expect(picked?.model).toBe('deepseek');
expect(picked?.providerId).toBe('anthropic');
});
it('pi accepts its explicit v3 marker', () => {
const providers = [
provider('xd', true, {
pi: [
model('claude-sonnet-5', { sortOrder: 0 }),
model('deepseek', { sortOrder: 44, newSessionDefault: ['pi'] }),
],
}),
];
expect(pickId(providers, 'pi', 'claude-sonnet-5')).toBe('deepseek');
});
it('pi does not borrow a claude-code default marker', () => {
const providers = [
provider('anthropic', true, {
pi: [
model('claude-sonnet-5', { sortOrder: 0 }),
model('claude-opus-5', { sortOrder: 44, newSessionDefault: ['claude-code'] }),
],
}),
];
expect(pickId(providers, 'pi', 'claude-sonnet-5')).toBe('claude-sonnet-5');
});
it('被标记但默认收起(defaultEnabled:false)时不选', () => {
const providers = [
provider('xd', true, {
'claude-code': [
model('visible', { sortOrder: 5 }),
model('hidden', {
sortOrder: 0,
defaultEnabled: false,
newSessionDefault: ['claude-code'],
}),
],
}),
];
expect(pickId(providers, 'claude-code', 'visible')).toBe('visible');
});
it('用户显式选过时,标记不覆盖用户选择', () => {
const providers = [
provider('xd', true, {
'claude-code': [model('my-pick'), model('deepseek', { newSessionDefault: ['claude-code'] })],
}),
];
expect(
calibratedId({
providers,
agent: 'claude-code',
model: 'my-pick',
chosenByUser: true,
providersLoading: false,
}),
).toBe('my-pick');
});
it('当前来源有偏好时,区域默认只在该来源内部校准,不会静默丢来源', () => {
const providers = [
provider(
'anthropic',
true,
{
'claude-code': [model('my-pick')],
},
'subscription',
),
provider('xd', true, {
'claude-code': [model('deepseek', { newSessionDefault: ['claude-code'] })],
}),
];
expect(
calibrateDraftModel({
providers,
agent: 'claude-code',
model: 'my-pick',
chosenByUser: false,
preferredProviderId: 'anthropic',
providersLoading: false,
}),
).toEqual({ model: 'my-pick', providerId: 'anthropic' });
});
it('区域 marker 只在 XD 声明时,选定来源仍可承接其提供的同 ID 模型', () => {
const providers = [
provider(
'anthropic',
true,
{
'claude-code': [model('deepseek')],
},
'subscription',
),
provider('xd', true, {
'claude-code': [
model('deepseek', { newSessionDefault: ['claude-code'] }),
model('old-default'),
],
}),
];
expect(
calibrateDraftModel({
providers,
agent: 'claude-code',
model: 'old-default',
chosenByUser: false,
preferredProviderId: 'anthropic',
providersLoading: false,
}),
).toEqual({ model: 'deepseek', providerId: 'anthropic' });
});
it('陈旧的来源偏好不阻塞区域默认,回退完整的已连接候选', () => {
const providers = [
provider('xd', true, {
'claude-code': [model('deepseek', { newSessionDefault: ['claude-code'] })],
}),
];
expect(
calibrateDraftModel({
providers,
agent: 'claude-code',
model: 'old-model',
chosenByUser: false,
preferredProviderId: 'disconnected-provider',
providersLoading: false,
}),
).toEqual({ model: 'deepseek', providerId: 'xd' });
});
});
describe('calibrateDraftModel', () => {
const base = {
providers: [gatewayWithoutOpus, disconnectedAnthropic],
agent: 'claude-code' as const,
model: 'claude-opus-4-8',
providersLoading: false,
};
it('校准从未被显式选过的种子默认', () => {
expect(calibratedId({ ...base, chosenByUser: false })).toBe('claude-sonnet-5');
});
it('绝不改写用户显式选过的模型', () => {
expect(calibratedId({ ...base, chosenByUser: true })).toBe('claude-opus-4-8');
});
it('供应商清单加载期不校准,避免首帧闪模型', () => {
expect(calibratedId({ ...base, chosenByUser: false, providersLoading: true })).toBe(
'claude-opus-4-8',
);
});
it('没有任何可用来源时原样返回,不返回空', () => {
expect(
calibratedId({ ...base, providers: [disconnectedAnthropic], chosenByUser: false }),
).toBe('claude-opus-4-8');
});
it('候选来源由调用方先过滤 —— SSH 草稿不该被推荐仅本地可桥接的来源', () => {
// 调用方(NewMakerDraftRoute)按 filterChatBridgedCodexProviders 先剔除 chat-bridged
// codex 来源;校准只在剩下的候选里挑,不会把远端根本路由不出去的模型选成默认。
const localOnlyBridge = provider('chatgpt', true, {
codex: [model('gpt-5.5-bridge')],
});
const routableEverywhere = provider('xd', true, { codex: [model('gpt-5.5')] });
// 未过滤(本地草稿):bridge 来源可用。
expect(
calibratedId({
providers: [localOnlyBridge, routableEverywhere],
agent: 'codex',
model: 'gpt-nonexistent',
chosenByUser: false,
providersLoading: false,
}),
).toBe('gpt-5.5-bridge');
// 已过滤(SSH 草稿):只会落到远端也能路由的来源。
expect(
calibratedId({
providers: [routableEverywhere],
agent: 'codex',
model: 'gpt-nonexistent',
chosenByUser: false,
providersLoading: false,
}),
).toBe('gpt-5.5');
});
it('候选须由调用方逐模型预过滤 —— 供应商级过滤盖不住同一供应商里的混合清单', () => {
// 同一个已连接供应商里既有订阅直连模型(远端 bridge 不可达)又有可路由模型。
// 过滤放在候选构造上而不是这里:同一份候选还要喂给来源解析,只在挑模型时过滤会让
// 来源解析仍看见被剔除的条目,从而选中一个用户已排除掉该模型的来源。
const models = [model('chatgpt/gpt-5.5'), model('claude-sonnet-5')];
const input = {
agent: 'claude-code' as const,
model: 'claude-opus-4-8',
chosenByUser: false,
providersLoading: false,
};
// 本地草稿:候选未剔除,取清单里的第一个。
expect(
calibratedId({
...input,
providers: [provider('xd', true, { 'claude-code': models })],
}),
).toBe('chatgpt/gpt-5.5');
// SSH 草稿:候选已剔除订阅直连,落到真正可路由的模型。
expect(
calibratedId({
...input,
providers: [
provider('xd', true, {
'claude-code': models.filter((m) => !m.id.startsWith('chatgpt/')),
}),
],
}),
).toBe('claude-sonnet-5');
});
it('候选里剔掉用户隐藏的条目后就不会被选成默认(与选择器可见性同口径)', () => {
const visibleOnly = [model('claude-sonnet-5')];
expect(
calibratedId({
providers: [provider('xd', true, { 'claude-code': visibleOnly })],
agent: 'claude-code',
model: 'claude-opus-4-8',
chosenByUser: false,
providersLoading: false,
}),
).toBe('claude-sonnet-5');
});
it('某来源的模型被剔光后整条来源不再是候选,不会被解析成生效来源', () => {
// 调用方会把「过滤后零模型」的来源整条丢掉;这里断言即便传进来也不会被选中。
const emptied = provider('xd', true, { 'claude-code': [] });
const usable = provider('anthropic', true, { 'claude-code': [model('claude-sonnet-5')] });
expect(
calibratedId({
providers: [emptied, usable],
agent: 'claude-code',
model: 'claude-opus-4-8',
chosenByUser: false,
providersLoading: false,
}),
).toBe('claude-sonnet-5');
});
});
describe('校准结果要带上供应商', () => {
// 回归 PR #1076 review:只交出 model id 时,下游 nativeDefaultSourceId 对 claude-code
// 无条件优先 XD 网关 —— 校准好的「anthropic 订阅提供的模型」会被重新指回网关,计费落
// 网关而不是用户已付费的订阅额度,「订阅优先」在最后一步被推翻。
const anthropicSub = provider(
'anthropic',
true,
{ 'claude-code': [model('claude-opus-5', { sortOrder: 0 })] },
'subscription',
);
const gatewaySameModel = provider('xd', true, {
'claude-code': [model('claude-opus-5', { sortOrder: 0 })],
});
it('两家都提供同一个模型时,来源给的是订阅那家', () => {
const picked = pickConnectedModelForAgent(
[gatewaySameModel, anthropicSub],
'claude-code',
'claude-opus-4-8',
);
expect(picked).toEqual({ model: 'claude-opus-5', providerId: 'anthropic' });
});
it('默认值本身可用时也给出订阅来源(第 1 步不该丢掉来源维度)', () => {
const picked = pickConnectedModelForAgent(
[gatewaySameModel, anthropicSub],
'claude-code',
'claude-opus-5',
);
expect(picked).toEqual({ model: 'claude-opus-5', providerId: 'anthropic' });
});
it('用户已显式选过 / 清单在加载 / 无可用来源时不给来源结论', () => {
const base = {
providers: [anthropicSub],
agent: 'claude-code' as const,
model: 'claude-opus-5',
chosenByUser: false,
providersLoading: false,
};
expect(calibrateDraftModel({ ...base, chosenByUser: true }).providerId).toBeNull();
expect(calibrateDraftModel({ ...base, providersLoading: true }).providerId).toBeNull();
expect(
calibrateDraftModel({ ...base, providers: [disconnectedAnthropic] }).providerId,
).toBeNull();
});
it('存量草稿里持久化的隐藏默认模型要被校准掉,而不是因「有来源提供」就留下', () => {
// 回归 PR #1076 review 第三轮:存量用户的草稿存着旧代码写死的 gpt-5.4 / gpt-5.5,
// 而这两个 id 在目录里都是 defaultEnabled:false。modelChosenByVendor 仍为 false,
// 正是这套校准要迁移的那批;只判「某来源提供它」会把它们原样留下,用户继续用一个
// 在默认选择器里看不到的模型。
const gateway = provider('xd', true, {
codex: [
model('gpt-5.4', { sortOrder: 21, defaultEnabled: false }),
model('gpt-5.6-sol', { sortOrder: 18 }),
],
});
expect(pickId([gateway], 'codex', 'gpt-5.4')).toBe('gpt-5.6-sol');
expect(
calibratedId({
providers: [gateway],
agent: 'codex',
model: 'gpt-5.4',
chosenByUser: false,
providersLoading: false,
}),
).toBe('gpt-5.6-sol');
});
it('用户真选过的模型即便默认收起也一律不动', () => {
// chosenByUser 在 calibrateDraftModel 里更早短路 —— 上一条的收紧不能连坐到它。
const gateway = provider('xd', true, {
codex: [
model('gpt-5.4', { sortOrder: 21, defaultEnabled: false }),
model('gpt-5.6-sol', { sortOrder: 18 }),
],
});
expect(
calibratedId({
providers: [gateway],
agent: 'codex',
model: 'gpt-5.4',
chosenByUser: true,
providersLoading: false,
}),
).toBe('gpt-5.4');
});
it('校准出结论时 model 与 providerId 成对给出', () => {
const result = calibrateDraftModel({
providers: [gatewaySameModel, anthropicSub],
agent: 'claude-code',
model: 'claude-opus-4-8',
chosenByUser: false,
providersLoading: false,
});
expect(result).toEqual({ model: 'claude-opus-5', providerId: 'anthropic' });
});
});
describe('resolveDraftSessionProviderId', () => {
it('唯一已连接来源是用户 Provider 时仍显式保留,避免 Claude 回退 Cindy gateway', () => {
const codingPlan = {
...provider('coding-plan', true, {
'claude-code': [model('ark-code-latest')],
}),
source: 'user',
} as ProviderView;
expect(
resolveDraftSessionProviderId({
providers: [codingPlan],
agent: 'claude-code',
model: 'ark-code-latest',
explicitProviderId: null,
effectiveProviderId: 'coding-plan',
}),
).toBe('coding-plan');
});
it('XD 已连接但不提供当前模型时,不能省略校准选中的 Anthropic 来源(issue #1196)', () => {
const gateway = provider('xd', true, {
'claude-code': [model('claude-sonnet-5')],
});
const anthropic = provider(
'anthropic',
true,
{ 'claude-code': [model('claude-opus-5')] },
'subscription',
);
expect(
resolveDraftSessionProviderId({
providers: [gateway, anthropic],
agent: 'claude-code',
model: 'claude-opus-5',
explicitProviderId: null,
effectiveProviderId: 'anthropic',
}),
).toBe('anthropic');
});
it('只有 Anthropic 已连接时仍可省略来源,保留默认路由语义', () => {
const anthropic = provider(
'anthropic',
true,
{ 'claude-code': [model('claude-opus-5')] },
'subscription',
);
expect(
resolveDraftSessionProviderId({
providers: [anthropic],
agent: 'claude-code',
model: 'claude-opus-5',
explicitProviderId: null,
effectiveProviderId: 'anthropic',
}),
).toBeNull();
});
it('XD 被停用时仍按 main 的 spawn 默认语义保留 Anthropic 来源', () => {
const suspendedGateway = {
...provider('xd', true, {
'claude-code': [model('claude-opus-5')],
}),
suspended: true,
} as ProviderView;
const anthropic = provider(
'anthropic',
true,
{ 'claude-code': [model('claude-opus-5')] },
'subscription',
);
expect(
resolveDraftSessionProviderId({
providers: [suspendedGateway, anthropic],
agent: 'claude-code',
model: 'claude-opus-5',
explicitProviderId: null,
effectiveProviderId: 'anthropic',
}),
).toBe('anthropic');
});
it('Codex 折扣模型只由 XD 提供时显式保留 XD,锁定既有实际落点', () => {
const openai = provider(
'openai',
true,
{ codex: [model('gpt-5.6-sol')] },
'subscription',
);
const gateway = provider('xd', true, {
codex: [model('codex/gpt-5.6-sol')],
});
expect(
resolveDraftSessionProviderId({
providers: [openai, gateway],
agent: 'codex',
model: 'codex/gpt-5.6-sol',
explicitProviderId: null,
effectiveProviderId: 'xd',
}),
).toBe('xd');
});
it('用户显式选择且仍有效时始终保留该来源', () => {
const gateway = provider('xd', true, {
'claude-code': [model('claude-opus-5')],
});
expect(
resolveDraftSessionProviderId({
providers: [gateway],
agent: 'claude-code',
model: 'claude-opus-5',
explicitProviderId: 'xd',
effectiveProviderId: 'xd',
}),
).toBe('xd');
});
it.each([null, 'account-b'])('不会把失效的显式账号替换成 %s', (effectiveProviderId) => {
const other = provider('account-b', true, {
'claude-code': [model('same-model')],
});
expect(resolveDraftSessionProviderId({
providers: [other], agent: 'claude-code', model: 'same-model',
explicitProviderId: 'account-a', effectiveProviderId,
})).toBe('account-a');
});
});
describe('resolveNewTaskDefaultRoute(无人值守入口的新建任务默认)', () => {
const subscription = provider(
'anthropic',
true,
{ 'claude-code': [model('claude-opus-5-5')] },
'subscription',
);
const providers = [gatewayWithoutOpus, subscription];
it('用户没选过模型:与新建任务同口径,订阅优先', () => {
expect(resolveNewTaskDefaultRoute({ providers, agent: 'claude-code' })).toEqual({
model: 'claude-opus-5-5',
providerId: 'anthropic',
});
});
it('用户显式选过且仍可用的模型优先,来源跟着草稿记的来源', () => {
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'claude-code',
draft: { model: 'claude-haiku-4-5', providerId: 'xd', chosenByUser: true },
}),
).toEqual({ model: 'claude-haiku-4-5', providerId: 'xd' });
});
it('显式选过的模型已没有可用来源时,退回新建任务默认而不是落空', () => {
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'claude-code',
draft: { model: 'claude-opus-4-8', providerId: null, chosenByUser: true },
}),
).toEqual({ model: 'claude-opus-5-5', providerId: 'anthropic' });
});
it('指定来源时只在该来源内挑', () => {
expect(
resolveNewTaskDefaultRoute({ providers, agent: 'claude-code', requiredProviderId: 'xd' }),
).toEqual({ model: 'claude-sonnet-5', providerId: 'xd' });
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'claude-code',
requiredProviderId: 'not-connected',
}),
).toBeNull();
});
it('草稿记的来源挑不出模型时换别的来源', () => {
expect(
resolveNewTaskDefaultRoute({
providers: [gatewayWithoutOpus, connectedButEmpty],
agent: 'claude-code',
draft: { model: '', providerId: 'anthropic', chosenByUser: false },
}),
).toEqual({ model: 'claude-sonnet-5', providerId: 'xd' });
});
it('清单发现失败的来源:没有偏好时跳过,草稿记着该来源时保留', () => {
const failing = {
...provider('anthropic', true, { 'claude-code': [model('claude-opus-5-5')] }, 'subscription'),
modelDiscoveryFailure: { kind: 'unauthorized' },
} as unknown as ProviderView;
expect(
resolveNewTaskDefaultRoute({ providers: [gatewayWithoutOpus, failing], agent: 'claude-code' }),
).toEqual({ model: 'claude-sonnet-5', providerId: 'xd' });
expect(
resolveNewTaskDefaultRoute({
providers: [gatewayWithoutOpus, failing],
agent: 'claude-code',
draft: { providerId: 'anthropic', chosenByUser: false },
}),
).toEqual({ model: 'claude-opus-5-5', providerId: 'anthropic' });
});
it('一个可用来源都没有 → null,不编造型号', () => {
expect(
resolveNewTaskDefaultRoute({ providers: [disconnectedAnthropic], agent: 'claude-code' }),
).toBeNull();
});
});
describe('factory defaults survive send-time calibration', () => {
it('keeps unattended Codex defaults on visible OpenAI fallback before xAI', () => {
const oldSol = model('gpt-6-sol');
const openai = provider('openai', true, { codex: [oldSol] }, 'subscription');
const xai = provider('xai', true, { codex: [model('xai/grok-4.6')] }, 'subscription');
const providers = [xai, openai];
const startup = resolveNewMakerDefaultTuple({ providers, providersLoading: false,
availableAgents: new Set(['codex']), availableAgentsLoaded: true,
isModelEnabled: (_agent, _id, m) => m.defaultEnabled !== false });
expect(startup).toMatchObject({ model: 'gpt-6-sol', providerId: 'openai' });
expect(resolveNewTaskDefaultRoute({ providers, agent: 'codex' }))
.toEqual({ model: 'gpt-6-sol', providerId: 'openai' });
expect(resolveNewTaskDefaultRoute({ providers, agent: 'codex',
draft: { model: 'xai/grok-4.6', providerId: 'xai', chosenByUser: true } }))
.toEqual({ model: 'xai/grok-4.6', providerId: 'xai' });
oldSol.defaultEnabled = false;
expect(resolveNewTaskDefaultRoute({ providers, agent: 'codex' }))
.toEqual({ model: 'xai/grok-4.6', providerId: 'xai' });
});
it.each([null, 'openai'])('keeps startup visibility switches during calibration (source %s)', preferredProviderId => {
const openai = provider('openai', true, { codex: [model('gpt-6.1-sol'), model('gpt-6-astra')] }, 'subscription');
const isModelEnabled = (agent: AgentKind, providerId: string, candidate: { id: string }) =>
!(agent === 'codex' && providerId === 'openai' && candidate.id === 'gpt-6.1-sol');
const startup = resolveNewMakerDefaultTuple({ providers: [openai], providersLoading: false,
availableAgents: new Set(['codex']), availableAgentsLoaded: true, isModelEnabled });
expect(startup).toMatchObject({ model: 'gpt-6-astra', providerId: 'openai' });
const input = { providers: [openai], agent: 'codex' as const, model: startup!.model,
chosenByUser: false, preferredProviderId, providersLoading: false };
expect(calibrateDraftModel({ ...input, isModelEnabled }))
.toEqual({ model: 'gpt-6-astra', providerId: 'openai' });
// Reopening the switch makes the factory recommendation eligible again.
expect(calibrateDraftModel({ ...input, isModelEnabled: () => true }))
.toEqual({ model: 'gpt-6.1-sol', providerId: 'openai' });
// A hidden model explicitly selected by the user still wins.
expect(calibrateDraftModel({ ...input, model: 'gpt-6.1-sol', chosenByUser: true, isModelEnabled }))
.toEqual({ model: 'gpt-6.1-sol', providerId: null });
// Hiding every model must not disable the existing usable-route fallback.
expect(calibrateDraftModel({ ...input, isModelEnabled: () => false }))
.toEqual({ model: 'gpt-6-astra', providerId: 'openai' });
});
const gateway = provider('xd', true, { pi: [
model('z-ai/glm-5.3-flash', { newSessionDefault: ['pi'] }), model('auto'),
] });
it.each([null, 'xd'])('keeps Cindy Auto despite old default markers (source %s)', preferredProviderId => {
expect(calibrateDraftModel({ providers: [gateway], agent: 'pi', model: 'auto',
chosenByUser: false, preferredProviderId, providersLoading: false }))
.toEqual({ model: 'auto', providerId: 'xd' });
expect(resolveNewTaskDefaultRoute({ providers: [gateway], agent: 'pi',
draft: { model: 'auto', providerId: preferredProviderId, chosenByUser: false } }))
.toEqual({ model: 'auto', providerId: 'xd' });
});
it('preserves explicit user models and follows Auto without a renderer snapshot', () => {
expect(calibrateDraftModel({ providers: [gateway], agent: 'pi', model: 'z-ai/glm-5.3-flash',
chosenByUser: true, preferredProviderId: 'xd', providersLoading: false }))
.toEqual({ model: 'z-ai/glm-5.3-flash', providerId: null });
expect(resolveNewTaskDefaultRoute({ providers: [gateway], agent: 'pi' }))
.toEqual({ model: 'auto', providerId: 'xd' });
});
});
describe('模型组 Auto:服务端决定默认与来源', () => {
const pool = (
id: string,
models: CatalogModel[],
source: ProviderView['source'] = 'organization',
) => ({ ...provider(id, true, { pi: models }), source }) as ProviderView;
const groupAuto = (marked: boolean) =>
model('auto/group-1', marked ? { newSessionDefault: ['pi'] } : {});
// unit:旧服务端下的普通号池草稿不能被跨来源校准改成平台计费。
// 既有用例只覆盖组 Auto 搬迁,未覆盖没有合格组默认的普通草稿。
const oldPoolDraft = { model: 'pool-model', providerId: 'org-pool', chosenByUser: false };
const expectedPoolRoute = { model: 'pool-model', providerId: 'org-pool' };
const routesForDraft = (providers: ProviderView[], draft = oldPoolDraft) => ({
calibration: calibrateDraftModel({
providers,
agent: 'pi',
model: draft.model,
chosenByUser: draft.chosenByUser,
preferredProviderId: draft.providerId,
providersLoading: false,
}),
unattended: resolveNewTaskDefaultRoute({ providers, agent: 'pi', draft }),
});
it('旧目录只有预设 auto 时,两个入口都保留未手选的号池草稿来源', () => {
const providers = [
provider('xd', true, { pi: [model('auto', { newSessionDefault: ['pi'] })] }),
pool('org-pool', [model('pool-model')]),
];
expect(routesForDraft(providers)).toEqual({
calibration: expectedPoolRoute,
unattended: expectedPoolRoute,
});
});
it.each([
['未标默认', {}, {}],
['只标其它引擎', { newSessionDefault: ['codex'] }, {}],
['模型停用', { newSessionDefault: ['pi'], disabled: true }, {}],
['模型退役', { newSessionDefault: ['pi'], status: 'retired' }, {}],
['默认不可见', { newSessionDefault: ['pi'], defaultEnabled: false }, {}],
['不可用于聊天', { newSessionDefault: ['pi'], mode: 'image_generation' }, {}],
['需要付费', { newSessionDefault: ['pi'], availability: 'requires_payment' }, {}],
['来源未连接', { newSessionDefault: ['pi'] }, { connected: false }],
['来源停用', { newSessionDefault: ['pi'] }, { suspended: true }],
] satisfies Array<[string, Partial<CatalogModel>, Partial<ProviderView>]>)(
'%s的组 Auto 不授权跨来源校准',
(_label, modelPatch, providerPatch) => {
const providers = [
provider('xd', true, { pi: [model('auto')] }),
pool('org-pool', [model('pool-model')]),
{ ...pool('org-other', [model('auto/group-1', modelPatch)]), ...providerPatch },
];
expect(routesForDraft(providers)).toEqual({
calibration: expectedPoolRoute,
unattended: expectedPoolRoute,
});
},
);
it('本地隐藏的组 Auto 不授权校准,用户重新显示后才跟随其默认', () => {
const providers = [
provider('xd', true, { pi: [model('auto'), groupAuto(true)] }),
pool('org-pool', [model('pool-model')]),
];
for (const visible of [false, true]) {
expect(
calibrateDraftModel({
providers,
agent: 'pi',
...oldPoolDraft,
preferredProviderId: 'org-pool',
providersLoading: false,
isModelEnabled: (_agent, _provider, candidate) =>
candidate.id !== 'auto/group-1' || visible,
}),
).toEqual(visible ? { model: 'auto/group-1', providerId: 'xd' } : expectedPoolRoute);
}
});
it.each([false, true])(
'平台组默认生效,双来源标记=%s 时仍按平台与 sortOrder 取舍',
(poolMarked) => {
const providers = [
pool('org-pool', [model('pool-model'), ...(poolMarked ? [groupAuto(true)] : [])]),
provider('xd', true, {
pi: [
model('auto/platform-later', { newSessionDefault: ['pi'], sortOrder: 20 }),
model('auto/platform-first', { newSessionDefault: ['pi'], sortOrder: 10 }),
model('auto'),
],
}),
];
const expected = { model: 'auto/platform-first', providerId: 'xd' };
expect(routesForDraft(providers)).toEqual({ calibration: expected, unattended: expected });
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'pi',
draft: oldPoolDraft,
requiredProviderId: 'org-pool',
}),
).toEqual(poolMarked ? { model: 'auto/group-1', providerId: 'org-pool' } : expectedPoolRoute);
},
);
it('草稿已记着组 Auto 时,撤销组默认仍能跨来源回退到预设 auto', () => {
const providers = [
provider('xd', true, { pi: [model('auto')] }),
pool('org-pool', [model('pool-model')]),
];
const expected = { model: 'auto', providerId: 'xd' };
expect(routesForDraft(providers, { ...oldPoolDraft, model: 'auto/group-removed' })).toEqual({
calibration: expected,
unattended: expected,
});
});
it.each(['缺少手选标记', '空手选标记'])(
'旧版持久化草稿(%s)经过真实读取和规范化后仍保留号池',
(snapshotKind) => {
// 使用账号命名空间切换触发 loadFromStorage/sanitize;同一模块只加载一次。
const owner = `legacy-pool-${snapshotKind}`;
const key = `xdt:newMakerDraft:v1:${encodeURIComponent(owner)}`;
const raw = JSON.stringify({
vendor: 'pi',
lastByVendor: { pi: { model: 'pool-model', providerId: 'org-pool' } },
...(snapshotKind === '空手选标记' ? { modelChosenByVendor: {} } : {}),
});
vi.stubGlobal('window', {
localStorage: { getItem: (name: string) => (name === key ? raw : null) },
});
try {
setNewMakerDraftOwner(owner);
const providers = [
provider('xd', true, { pi: [model('auto')] }),
pool('org-pool', [model('pool-model')]),
];
for (const stored of [getDraft(), getDraftForPreferenceSync()]) {
expect(stored.modelChosenByVendor.pi).toBeUndefined();
expect(
routesForDraft(providers, {
model: stored.lastByVendor.pi.model,
providerId: stored.lastByVendor.pi.providerId!,
chosenByUser: stored.modelChosenByVendor.pi === true,
}),
).toEqual({ calibration: expectedPoolRoute, unattended: expectedPoolRoute });
}
} finally {
setNewMakerDraftOwner(null);
vi.unstubAllGlobals();
}
},
);
it('上次自动落点不钉住默认:服务端改标号池里的组 Auto 后,校准与无人值守入口同步跟随', () => {
const gateway = provider('xd', true, { pi: [model('auto')] });
const byok = pool('org-pool', [model('pool-model'), groupAuto(true)]);
const providers = [gateway, byok];
const expected = { model: 'auto/group-1', providerId: 'org-pool' };
expect(
calibrateDraftModel({
providers,
agent: 'pi',
model: 'auto',
chosenByUser: false,
preferredProviderId: 'xd',
providersLoading: false,
}),
).toEqual(expected);
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'pi',
draft: { model: 'auto', providerId: 'xd', chosenByUser: false },
}),
).toEqual(expected);
expect(resolveNewTaskDefaultRoute({ providers, agent: 'pi' })).toEqual(expected);
});
it('组 Auto 从号池挪到 Cindy AI 后,按新来源继续,不退成号池里的其它模型', () => {
const gateway = provider('xd', true, { pi: [model('auto'), groupAuto(true)] });
const byok = pool('org-pool', [model('pool-model')]);
const providers = [gateway, byok];
const expected = { model: 'auto/group-1', providerId: 'xd' };
expect(
calibrateDraftModel({
providers,
agent: 'pi',
model: 'auto/group-1',
chosenByUser: false,
preferredProviderId: 'org-pool',
providersLoading: false,
}),
).toEqual(expected);
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'pi',
draft: { model: 'auto/group-1', providerId: 'org-pool', chosenByUser: false },
}),
).toEqual(expected);
// 用户手动选的 Auto 同样按 ID 认:记住的号池已不提供它,改用当前提供它的 Cindy AI。
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'pi',
draft: { model: 'auto/group-1', providerId: 'org-pool', chosenByUser: true },
}),
).toEqual(expected);
});
it('用户自己接的供应商不参与 Cindy 来源之间的改道', () => {
const gateway = provider('xd', true, { pi: [model('auto'), groupAuto(true)] });
const custom = pool('custom-litellm', [model('custom-model')], 'user');
expect(
calibrateDraftModel({
providers: [gateway, custom],
agent: 'pi',
model: 'custom-model',
chosenByUser: false,
preferredProviderId: 'custom-litellm',
providersLoading: false,
}),
).toEqual({ model: 'custom-model', providerId: 'custom-litellm' });
});
it('用户手动选过的模型不被服务端默认覆盖', () => {
const gateway = provider('xd', true, { pi: [model('auto'), groupAuto(true)] });
const byok = pool('org-pool', [model('pool-model')]);
const providers = [gateway, byok];
expect(
calibrateDraftModel({
providers,
agent: 'pi',
model: 'pool-model',
chosenByUser: true,
preferredProviderId: 'org-pool',
providersLoading: false,
}),
).toEqual({ model: 'pool-model', providerId: null });
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'pi',
draft: { model: 'pool-model', providerId: 'org-pool', chosenByUser: true },
}),
).toEqual({ model: 'pool-model', providerId: 'org-pool' });
});
it('Auto 从两份目录都消失:不崩,落到记着的来源里仍可用的模型', () => {
const gateway = provider('xd', true, { pi: [model('z-ai/glm-5.3-flash')] });
const byok = pool('org-pool', [model('pool-model')]);
const providers = [gateway, byok];
for (const chosenByUser of [false, true]) {
expect(
resolveNewTaskDefaultRoute({
providers,
agent: 'pi',
draft: { model: 'auto/group-1', providerId: 'org-pool', chosenByUser },
}),
).toEqual({ model: 'pool-model', providerId: 'org-pool' });
}
expect(
calibrateDraftModel({
providers,
agent: 'pi',
model: 'auto/group-1',
chosenByUser: false,
preferredProviderId: 'org-pool',
providersLoading: false,
}),
).toEqual({ model: 'pool-model', providerId: 'org-pool' });
});
it('回归:订阅、自定义供应商、个人用户与预设 auto 的默认不变', () => {
// 个人用户:目录标的是 GLM,默认仍是预设 auto,来源 Cindy AI。
const personal = provider('xd', true, {
pi: [model('z-ai/glm-5.3-flash', { newSessionDefault: ['pi'] }), model('auto')],
});
expect(resolveNewTaskDefaultRoute({ providers: [personal], agent: 'pi' })).toEqual({
model: 'auto',
providerId: 'xd',
});
// 订阅:Codex 订阅在场时 Codex 默认仍是订阅里的 Sol,不受 Pi 侧 Auto 规则影响。
const openai = provider('openai', true, { codex: [model('gpt-6.1-sol')] }, 'subscription');
expect(resolveNewTaskDefaultRoute({ providers: [openai, personal], agent: 'codex' })).toEqual({
model: 'gpt-6.1-sol',
providerId: 'openai',
});
// 自定义供应商:记着的自定义来源与模型原样保留。
const custom = pool('custom-litellm', [model('custom-model')], 'user');
expect(
resolveNewTaskDefaultRoute({
providers: [personal, custom],
agent: 'pi',
draft: { model: 'custom-model', providerId: 'custom-litellm', chosenByUser: true },
}),
).toEqual({ model: 'custom-model', providerId: 'custom-litellm' });
});
it('新建任务提交时,Auto 已挪走的旧来源换成解析出的新来源;其它显式来源原样提交', () => {
const gateway = provider('xd', true, { pi: [model('auto'), groupAuto(true)] });
const byok = pool('org-pool', [model('pool-model')]);
const custom = pool('custom-litellm', [model('custom-model')], 'user');
const providers = [gateway, byok, custom];
expect(
resolveDraftSessionProviderId({
providers,
agent: 'pi',
model: 'auto/group-1',
explicitProviderId: 'org-pool',
effectiveProviderId: 'xd',
}),
).toBe('xd');
expect(
resolveDraftSessionProviderId({
providers,
agent: 'pi',
model: 'auto/group-1',
explicitProviderId: 'org-pool',
effectiveProviderId: null,
}),
).toBe('org-pool');
expect(
resolveDraftSessionProviderId({
providers,
agent: 'pi',
model: 'auto/group-1',
explicitProviderId: 'custom-litellm',
effectiveProviderId: 'xd',
}),
).toBe('custom-litellm');
});
});
describe('resolveDraftEffectiveProviderId', () => {
const sonnet = model('claude-sonnet-5-5');
const anthropic = provider('anthropic', true, { 'claude-code': [sonnet] }, 'subscription');
const xd = provider('xd', true, { 'claude-code': [sonnet] }, 'managed');
it('草稿没存来源时按校准结果(订阅优先)解析,而不是按模型 id 直接取原生默认的 XD', () => {
const args = {
providers: [xd, anthropic],
agent: 'claude-code' as AgentKind,
model: 'claude-sonnet-5-5',
providerId: null,
chosenByUser: false,
};
expect(resolveDraftEffectiveProviderId(args)).toBe('anthropic');
});
it('草稿存了仍然可用的来源时原样返回', () => {
expect(
resolveDraftEffectiveProviderId({
providers: [xd, anthropic],
agent: 'claude-code',
model: 'claude-sonnet-5-5',
providerId: 'xd',
chosenByUser: true,
}),
).toBe('xd');
});
it('用户隐藏了出厂推荐模型时跟随新建页的可见性谓词,落到下一个可用来源', () => {
const base = {
providers: [
provider('anthropic', true, { 'claude-code': [model('claude-opus-5-5')] }, 'subscription'),
provider('xai', true, { 'claude-code': [model('grok-4.6')] }, 'subscription'),
],
agent: 'claude-code' as AgentKind,
model: 'claude-opus-5-5',
providerId: null,
chosenByUser: false,
};
const hideOpus = (_agent: AgentKind, _providerId: string, m: { id: string }) =>
m.id !== 'claude-opus-5-5';
expect(resolveDraftEffectiveProviderId(base)).toBe('anthropic');
expect(resolveDraftEffectiveProviderId({ ...base, isModelEnabled: hideOpus })).toBe('xai');
});
it('没有任何来源提供该模型时返回 null', () => {
expect(
resolveDraftEffectiveProviderId({
providers: [],
agent: 'claude-code',
model: 'claude-sonnet-5-5',
providerId: null,
chosenByUser: false,
}),
).toBeNull();
});
});