Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* 调用合成标准(invocation.ts)+ effort 新语义(effortResolution.ts 扩充部分)的行为锁。
*
* effort 三个新函数的用例放本文件而非 effortResolution.test.ts —— 该文件保持**零修改**,
* 作为「P1 不动既有语义」的证明之一。
*
* nearestSupportedEffort 的级联全分支与
* apps/desktop/src/main/maker-ipc/orcaWorkerCreationService.ts 的 normalizeResolvedEffort
* 非显式分支逐字节对齐(P4 切换时那边的既有测试是第二道锁)。
*/
import { describe, expect, it } from 'vitest';
import {
EFFORT_VALUES,
effortRank,
lowestEffort,
nearestSupportedEffort,
reconcileInvocationEffort,
} from '../effortResolution.js';
import { resolveModelInvocation, type InvocationCatalogContext } from '../invocation.js';
import type { AgentKind, CatalogModel } from '../types.js';
import type { ProviderView } from '../registry.js';
// ── effort 扩充 ──────────────────────────────────────────────────────────────
describe('EFFORT_VALUES / effortRank / lowestEffort', () => {
it('七档强弱序单一来源', () => {
expect(EFFORT_VALUES).toEqual(['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
});
it('未知档排最高之上(保守不上调,与 clamp 的历史行为一致)', () => {
expect(effortRank('nonsense')).toBe(EFFORT_VALUES.length);
expect(effortRank('ultra')).toBeLessThan(effortRank('nonsense'));
});
it('lowestEffort: 最低档;空 → null(title-one-shot 语义)', () => {
expect(lowestEffort(['high', 'low', 'max'])).toBe('low');
expect(lowestEffort([])).toBeNull();
});
});
describe('nearestSupportedEffort — Orca 跨引擎词表翻译(双向就近,全分支)', () => {
it('支持 → 原样', () => {
expect(nearestSupportedEffort('high', ['low', 'high'])).toBe('high');
});
it('minimal → low', () => {
expect(nearestSupportedEffort('minimal', ['low', 'medium', 'high'])).toBe('low');
});
it('ultra → max(Claude 词表)', () => {
expect(nearestSupportedEffort('ultra', ['low', 'high', 'max'])).toBe('max');
});
it('ultra → xhigh(模型无 max,级联到最高兼容档而不是丢回默认)', () => {
expect(nearestSupportedEffort('ultra', ['low', 'high', 'xhigh'])).toBe('xhigh');
});
it('max → xhigh(Claude 意图落 GPT 词表)', () => {
expect(nearestSupportedEffort('max', ['low', 'high', 'xhigh'])).toBe('xhigh');
});
it('xhigh → max(GPT 意图落 Claude 词表 —— 这是**上调**,在翻译语义里正确)', () => {
expect(nearestSupportedEffort('xhigh', ['low', 'high', 'max'])).toBe('max');
});
it('命不中级联映射 → null(由调用方决定回落默认还是报错)', () => {
expect(nearestSupportedEffort('medium', ['xhigh'])).toBeNull();
expect(nearestSupportedEffort('ultra', ['low', 'medium'])).toBeNull();
});
});
describe('reconcileInvocationEffort — 无人值守统一回落链', () => {
const MODEL = { efforts: ['low', 'high'] as const, defaultEffort: 'high' as string | null };
it('requested ∈ 支持档 → 先于 override(用户显式选择不被运营表压过;IM resolveEffort 语义)', () => {
expect(
reconcileInvocationEffort({
requested: 'low',
model: MODEL,
overrides: { 'm-1': 'high' },
modelId: 'm-1',
noEffortFallback: 'high',
}),
).toBe('low');
});
it('requested 非法时 override 作为回落生效', () => {
expect(
reconcileInvocationEffort({
requested: 'ultra',
model: MODEL,
overrides: { 'm-1': 'high' },
modelId: 'm-1',
noEffortFallback: 'high',
}),
).toBe('high');
});
it('模型未知/无档的三种历史语义按 noEffortsBehavior 显式选择', () => {
const base = {
requested: 'low' as const,
model: undefined,
overrides: { 'm-1': 'xhigh' } as const,
modelId: 'm-1',
noEffortFallback: 'high' as const,
};
// hook 语义(默认): 无档就不看 requested/override,恒 fallback
expect(reconcileInvocationEffort(base)).toBe('high');
// IM resolveEffort 语义: requested || fallback
expect(reconcileInvocationEffort({ ...base, noEffortsBehavior: 'requested-first' })).toBe('low');
expect(
reconcileInvocationEffort({ ...base, requested: null, noEffortsBehavior: 'requested-first' }),
).toBe('high');
// getImDefaultEffortFor 语义: override || fallback(该场景 requested 恒空)
expect(
reconcileInvocationEffort({ ...base, requested: null, noEffortsBehavior: 'override-first' }),
).toBe('xhigh');
});
it('overrides 表不受原型链污染(model id 为 constructor 等原型键时不取 Object 原型)', () => {
expect(
reconcileInvocationEffort({
requested: null,
model: undefined,
overrides: {},
modelId: 'constructor',
noEffortFallback: 'high',
noEffortsBehavior: 'override-first',
}),
).toBe('high');
});
it('override 不被支持档接受 → 跳过,走后续链', () => {
expect(
reconcileInvocationEffort({
requested: 'low',
model: MODEL,
overrides: { 'm-1': 'ultra' },
modelId: 'm-1',
noEffortFallback: 'high',
}),
).toBe('low');
});
it('无 effort 档 → noEffortFallback 参数化(IM=high / hook=undefined / mobile=空串)', () => {
const noEfforts = { efforts: [] as const, defaultEffort: null };
expect(
reconcileInvocationEffort({ requested: 'high', model: noEfforts, noEffortFallback: 'high' }),
).toBe('high');
expect(
reconcileInvocationEffort({
requested: 'high',
model: noEfforts,
noEffortFallback: undefined,
}),
).toBeUndefined();
expect(
reconcileInvocationEffort({ requested: 'high', model: noEfforts, noEffortFallback: '' }),
).toBe('');
});
it('requested ∈ 支持档 → requested;否则模型默认;默认非法 → 首档', () => {
expect(reconcileInvocationEffort({ requested: 'low', model: MODEL, noEffortFallback: undefined })).toBe('low');
expect(reconcileInvocationEffort({ requested: 'ultra', model: MODEL, noEffortFallback: undefined })).toBe('high');
expect(
reconcileInvocationEffort({
requested: 'ultra',
model: { efforts: ['low', 'medium'], defaultEffort: 'xhigh' },
noEffortFallback: undefined,
}),
).toBe('low');
});
});
// ── resolveModelInvocation ───────────────────────────────────────────────────
function model(id: string, extra: Partial<CatalogModel> = {}): CatalogModel {
return {
id,
name: id,
contextWindow: 200_000,
efforts: ['low', 'high'],
defaultEffort: 'high',
...extra,
} as CatalogModel;
}
function providers(): ProviderView[] {
return [
{
id: 'anthropic',
name: 'anthropic',
agents: ['claude-code'],
routing: { 'claude-code': {} },
models: { 'claude-code': [model('claude-opus-5')] },
connected: true,
access: { kind: 'subscription', product: 'Claude.ai' },
},
{
id: 'xd',
name: 'xd',
agents: ['claude-code', 'codex'],
routing: { 'claude-code': {}, codex: {} },
models: {
'claude-code': [model('claude-opus-5'), model('claude-sonnet-4-6')],
codex: [model('gpt-5.5', { efforts: ['low', 'medium', 'high', 'xhigh'] })],
},
connected: true,
access: { kind: 'managed' },
},
{
id: 'openai',
name: 'openai',
agents: ['codex'],
routing: { codex: {} },
models: { codex: [model('gpt-5.5')] },
connected: false,
},
{
id: 'pi-native',
name: 'pi-native',
agents: ['pi'],
routing: { pi: {} },
models: { pi: [model('pi-model')] },
connected: true,
access: { kind: 'api' },
},
] as ProviderView[];
}
const SCENARIO = {
agentKind: 'claude-code' as AgentKind,
modelFor: (agent: AgentKind) =>
agent === 'codex' ? 'gpt-5.5' : agent === 'pi' ? 'pi-model' : 'claude-sonnet-4-6',
noEffortFallback: undefined,
permissionMode: 'bypassPermissions',
};
const PERM_MODES = (agent: AgentKind): readonly string[] =>
agent === 'claude-code'
? ['ask', 'acceptEdits', 'auto', 'bypassPermissions']
: ['ask', 'auto', 'bypassPermissions'];
function ctx(over: Partial<InvocationCatalogContext> = {}): InvocationCatalogContext {
return { providers: providers(), getPermissionModes: PERM_MODES, ...over };
}
describe('resolveModelInvocation — 六元组回落链', () => {
it('keeps an explicit Pi invocation instead of falling back to the scenario agent', () => {
const r = resolveModelInvocation(
{ agentKind: 'pi', model: 'pi-model', permissionMode: 'auto' },
SCENARIO,
ctx(),
);
expect(r).toMatchObject({
agentKind: 'pi',
model: 'pi-model',
providerId: null,
permissionMode: 'auto',
});
expect(r.fallbacksApplied).not.toContain('agent:scenario-default');
});
it('全显式且全可用 → 原样直传,零回落', () => {
const r = resolveModelInvocation(
{
agentKind: 'claude-code',
model: 'claude-opus-5',
effort: 'low',
providerId: 'anthropic',
permissionMode: 'acceptEdits',
fastMode: true,
},
SCENARIO,
ctx(),
);
expect(r).toMatchObject({
agentKind: 'claude-code',
model: 'claude-opus-5',
effort: 'low',
providerId: 'anthropic',
permissionMode: 'acceptEdits',
fastMode: true,
});
expect(r.fallbacksApplied).toEqual([]);
});
it('全空 → 场景默认(model 过可用性校验;permission 落场景默认;effort 落模型默认)', () => {
const r = resolveModelInvocation({}, SCENARIO, ctx());
expect(r).toMatchObject({
agentKind: 'claude-code',
model: 'claude-sonnet-4-6',
effort: 'high',
providerId: null,
permissionMode: 'bypassPermissions',
fastMode: false,
});
});
it('agent 非法 → 场景默认 agent,并记录回落轨迹', () => {
const r = resolveModelInvocation({ agentKind: 'weird' }, SCENARIO, ctx());
expect(r.agentKind).toBe('claude-code');
expect(r.fallbacksApplied).toContain('agent:scenario-default');
});
it('显式 model 不可用 → 场景默认;场景默认也不可用 → 该 agent 首个可用', () => {
const r1 = resolveModelInvocation({ model: 'gone-model' }, SCENARIO, ctx());
expect(r1.model).toBe('claude-sonnet-4-6');
expect(r1.fallbacksApplied).toContain('model:scenario-default');
const r2 = resolveModelInvocation(
{ model: 'gone-model' },
{ ...SCENARIO, modelFor: () => 'also-gone' },
ctx(),
);
expect(r2.model).toBe('claude-opus-5'); // anthropic 段首个
expect(r2.fallbacksApplied).toContain('model:first-available');
});
it('retired 模型不参与显式选择、场景默认或首个可用 fallback', () => {
const retiredOpus = providers().map((provider) => ({
...provider,
models: {
...provider.models,
'claude-code': (provider.models['claude-code'] ?? []).map((entry) =>
entry.id === 'claude-opus-5' ? { ...entry, status: 'retired' as const } : entry,
),
},
})) as ProviderView[];
const explicit = resolveModelInvocation(
{ model: 'claude-opus-5' },
SCENARIO,
ctx({ providers: retiredOpus }),
);
expect(explicit.model).toBe('claude-sonnet-4-6');
const retiredDefaults = retiredOpus.map((provider) => ({
...provider,
models: {
...provider.models,
'claude-code': (provider.models['claude-code'] ?? []).map((entry) =>
entry.id === 'claude-sonnet-4-6' ? { ...entry, status: 'retired' as const } : entry,
),
},
})) as ProviderView[];
const noFallback = resolveModelInvocation(
{ model: 'gone-model' },
SCENARIO,
ctx({ providers: retiredDefaults }),
);
expect(noFallback.fallbacksApplied).toContain('model:no-available-models');
});
it('目录与 caps 全不可用 → 场景默认裸值(宁发可能非法的 id 不发空串,历史降级)', () => {
const r = resolveModelInvocation({}, SCENARIO, ctx({ providers: null }));
expect(r.model).toBe('claude-sonnet-4-6');
expect(r.fallbacksApplied).toContain('model:scenario-default-unverified');
});
it('目录不可用但有 caps → caps 兜底清单参与校验', () => {
const r = resolveModelInvocation(
{ model: 'caps-model' },
SCENARIO,
ctx({
providers: null,
getCapabilityModels: () => [{ id: 'caps-model', efforts: ['medium'], defaultEffort: 'medium' }],
}),
);
expect(r.model).toBe('caps-model');
expect(r.effort).toBe('medium');
});
it('providerId: 已连接且提供最终模型 → 保留;不提供 → 收敛到可见替代源', () => {
const keep = resolveModelInvocation(
{ model: 'claude-opus-5', providerId: 'anthropic' },
SCENARIO,
ctx(),
);
expect(keep.providerId).toBe('anthropic');
// anthropic 不提供 sonnet → 不再回 null(下游默认路由不看可见性),直接收敛到
// 提供该模型的可见替代源(2026-07 codex review 行为升级)
const drop = resolveModelInvocation(
{ model: 'claude-sonnet-4-6', providerId: 'anthropic' },
SCENARIO,
ctx(),
);
expect(drop.providerId).toBe('xd');
expect(drop.fallbacksApplied).toContain('provider:visible-fallback');
});
it('providerId: 断开的来源不算可用,收敛到提供该模型的可见替代源', () => {
const r = resolveModelInvocation(
{ agentKind: 'codex', model: 'gpt-5.5', providerId: 'openai' },
{ ...SCENARIO, agentKind: 'codex' },
ctx(),
);
// openai 断开 → xd(已连接且提供 gpt-5.5)顶上,不回 null
expect(r.providerId).toBe('xd');
expect(r.fallbacksApplied).toContain('provider:visible-fallback');
});
it('providerId: 点名来源这份具体条目是非聊天 mode → 不算「真实提供」,收敛到聊天可用的替代源(issue #882 第 3 点,2026-07 review 第 18 轮)', () => {
// anthropic 的 claude-opus-5 被网关标成非聊天(如 embedding);xd 上同 id 仍是正常
// 聊天模型 —— 只看 id 存在(旧 providerOffersModel)会误留在 anthropic 上,必须
// 收敛到 xd。故意不传 ctx.isVisible,复现修复前「无可见性回调时直接放行」的路径。
const withNonChatCopy: ProviderView[] = providers().map((p) =>
p.id === 'anthropic'
? { ...p, models: { 'claude-code': [model('claude-opus-5', { mode: 'embedding' })] } }
: p,
) as ProviderView[];
const r = resolveModelInvocation(
{ model: 'claude-opus-5', providerId: 'anthropic' },
SCENARIO,
ctx({ providers: withNonChatCopy }),
);
expect(r.providerId).toBe('xd');
expect(r.fallbacksApplied).toContain('provider:visible-fallback');
});
it('providerId: 目录不可用 → 透传原值(路由层兜底,与 IM/hook 历史降级一致)', () => {
const r = resolveModelInvocation(
{ providerId: 'anthropic' },
SCENARIO,
ctx({ providers: null }),
);
expect(r.providerId).toBe('anthropic');
expect(r.fallbacksApplied).toContain('provider:unverified-passthrough');
});
it('permissionMode: 显式档不被支持 → 该 agent **最严**档,绝不落场景默认 bypass', () => {
const r = resolveModelInvocation(
{ agentKind: 'codex', permissionMode: 'acceptEdits' },
{ ...SCENARIO, agentKind: 'codex' },
ctx(),
);
expect(r.permissionMode).toBe('ask');
expect(r.permissionMode).not.toBe('bypassPermissions');
expect(r.fallbacksApplied).toContain('permission:strictest-fallback');
});
it('permissionMode: 未注入档位表时显式值原样放行(无从校验,不瞎猜)', () => {
const r = resolveModelInvocation(
{ permissionMode: 'acceptEdits' },
SCENARIO,
ctx({ getPermissionModes: undefined }),
);
expect(r.permissionMode).toBe('acceptEdits');
});
it('isVisible 注入时,隐藏模型不算「可用」(与选择器口径一致)', () => {
const r = resolveModelInvocation(
{ model: 'claude-opus-5' },
SCENARIO,
ctx({ isVisible: (_pid, m) => m.id !== 'claude-opus-5' }),
);
expect(r.model).toBe('claude-sonnet-4-6');
});
it('场景 effort(effortFor)在显式 effort 缺失时参与回落', () => {
const r = resolveModelInvocation(
{ model: 'claude-opus-5' },
{ ...SCENARIO, effortFor: () => 'low' },
ctx(),
);
expect(r.effort).toBe('low');
});
it('effortOverrides 只在显式档非法时生效(用户显式选择优先于运营表)', () => {
const keep = resolveModelInvocation(
{ model: 'claude-opus-5', effort: 'low' },
{ ...SCENARIO, effortOverrides: { 'claude-opus-5': 'high' } },
ctx(),
);
expect(keep.effort).toBe('low');
const fall = resolveModelInvocation(
{ model: 'claude-opus-5', effort: 'ultra' },
{ ...SCENARIO, effortOverrides: { 'claude-opus-5': 'high' } },
ctx(),
);
expect(fall.effort).toBe('high');
});
it('显式 effort 非法时先试场景默认档,再落模型默认(hook 的显式>草稿>默认链)', () => {
const r = resolveModelInvocation(
{ model: 'claude-opus-5', effort: 'ultra' },
{ ...SCENARIO, effortFor: () => 'low' },
ctx(),
);
expect(r.effort).toBe('low');
});
});
// ── 2026-07 review 修正的行为锁(#433 第二轮) ─────────────────────────────────
describe('resolveModelInvocation — 空权限档位表不放宽(Greptile P2 + codex P1 同点)', () => {
it('显式档 + 空档位表 → 原样保留,绝不落场景默认 bypass', () => {
const r = resolveModelInvocation(
{ permissionMode: 'acceptEdits' },
SCENARIO,
ctx({ getPermissionModes: () => [] }),
);
expect(r.permissionMode).toBe('acceptEdits');
expect(r.fallbacksApplied).toContain('permission:modes-unavailable');
});
it('无显式档 + 空档位表 → 场景默认(该分支语义不变)', () => {
const r = resolveModelInvocation({}, SCENARIO, ctx({ getPermissionModes: () => [] }));
expect(r.permissionMode).toBe('bypassPermissions');
});
});
describe('resolveModelInvocation — explicitModelPolicy(Orca 严格拒绝语义)', () => {
const STRICT = { ...SCENARIO, explicitModelPolicy: 'reject' as const };
it('显式模型经校验不可用 → rejected 置位;其余字段仍按回落链合成(纯诊断)', () => {
const r = resolveModelInvocation({ model: 'gone-model' }, STRICT, ctx());
expect(r.rejected).toEqual({
field: 'model',
value: 'gone-model',
reason: 'explicit-model-unavailable',
});
expect(r.fallbacksApplied).toContain('model:explicit-rejected');
expect(r.model).toBe('claude-sonnet-4-6');
});
it('显式模型可用 → 不触发 rejected', () => {
const r = resolveModelInvocation({ model: 'claude-opus-5' }, STRICT, ctx());
expect(r.rejected).toBeUndefined();
});
it('目录与 caps 全不可用 → 未经校验采纳显式值,不触发 rejected', () => {
const r = resolveModelInvocation({ model: 'gone-model' }, STRICT, ctx({ providers: null }));
expect(r.rejected).toBeUndefined();
expect(r.model).toBe('gone-model');
expect(r.fallbacksApplied).toContain('model:explicit-unverified');
});
it("缺省策略('fallback')下不可用显式模型静默落场景默认(IM/hook 历史语义,不变)", () => {
const r = resolveModelInvocation({ model: 'gone-model' }, SCENARIO, ctx());
expect(r.rejected).toBeUndefined();
expect(r.model).toBe('claude-sonnet-4-6');
});
});
describe('resolveModelInvocation — 显式 agent 无可用模型时回落能跑的 agent(IM pickModel 语义)', () => {
it('显式 codex 零可用模型、场景默认 claude-code 有 → 回落并记录', () => {
// isVisible 把 codex 模型全部藏掉 → codex available=[](非 null)
const r = resolveModelInvocation(
{ agentKind: 'codex' },
SCENARIO,
ctx({ isVisible: (_pid, m) => !m.id.startsWith('gpt') && !m.id.startsWith('codex/') }),
);
expect(r.agentKind).toBe('claude-code');
expect(r.fallbacksApplied).toContain('agent:model-less-fallback');
expect(r.model).toBe('claude-sonnet-4-6');
});
it('场景默认 agent 同样无模型 → 保持显式选择(回落无意义)', () => {
const r = resolveModelInvocation(
{ agentKind: 'codex' },
SCENARIO,
ctx({ isVisible: () => false }),
);
expect(r.agentKind).toBe('codex');
expect(r.fallbacksApplied).not.toContain('agent:model-less-fallback');
});
it('能力数据不可用(available=null)→ 不猜,维持显式 agent', () => {
const r = resolveModelInvocation(
{ agentKind: 'codex' },
SCENARIO,
ctx({ providers: null }),
);
expect(r.agentKind).toBe('codex');
expect(r.fallbacksApplied).not.toContain('agent:model-less-fallback');
});
});
describe('resolveModelInvocation — providerId 校验含 per-provider 可见性(codex review)', () => {
it('模型经他源可用、点名来源被 isVisible 排除 → 收敛到可见替代源,不绕过来源级契约', () => {
// claude-opus-5 在 anthropic 可见、在 xd 被隐藏;显式点名 xd 不能放行。
// 也不能回 null:下游默认路由(nativeDefaultSourceId,claude-code 优先 xd)不看可见性,
// 会又选回被隐藏的 xd —— 必须显式收敛到可见的 anthropic(codex review 二轮)。
const r = resolveModelInvocation(
{ model: 'claude-opus-5', providerId: 'xd' },
SCENARIO,
ctx({ isVisible: (pid, m) => !(pid === 'xd' && m.id === 'claude-opus-5') }),
);
expect(r.model).toBe('claude-opus-5');
expect(r.providerId).toBe('anthropic');
expect(r.fallbacksApplied).toContain('provider:visible-fallback');
});
it('点名来源可见 → 照常保留(既有语义不变)', () => {
const r = resolveModelInvocation(
{ model: 'claude-opus-5', providerId: 'xd' },
SCENARIO,
ctx({ isVisible: () => true }),
);
expect(r.providerId).toBe('xd');
});
});
describe('resolveModelInvocation — 诊断标记区分 unverified 与零可选(Copilot review)', () => {
it('清单可用但为空 → model:no-available-models,不再误标 unverified', () => {
const r = resolveModelInvocation({}, SCENARIO, ctx({ isVisible: () => false }));
expect(r.model).toBe('claude-sonnet-4-6');
expect(r.fallbacksApplied).toContain('model:no-available-models');
expect(r.fallbacksApplied).not.toContain('model:scenario-default-unverified');
});
});
describe('resolveModelInvocation — codex review 三轮:回落保真度', () => {
it('agent 回落后,原 agent 的 model/effort 配对偏好作废(不跨 agent 采纳同名 id)', () => {
// pa(codex)零模型 → 回落 claude-code;显式 'gpt-5.5' 在 pb 的 claude-code 目录恰好
// 也存在 —— 修复前会被当作新 agent 的显式选择采纳(拿原 agent 的偏好跑新 agent,
// 还能绕过 reject 策略),修复后作废,落场景默认链。
const provs = [
{
id: 'pa',
name: 'pa',
agents: ['codex'],
routing: { codex: {} },
models: { codex: [] },
connected: true,
},
{
id: 'pb',
name: 'pb',
agents: ['claude-code'],
routing: { 'claude-code': {} },
models: { 'claude-code': [model('claude-sonnet-4-6'), model('gpt-5.5')] },
connected: true,
},
] as unknown as ProviderView[];
const r = resolveModelInvocation(
{ agentKind: 'codex', model: 'gpt-5.5', effort: 'low' },
SCENARIO,
{ providers: provs, getPermissionModes: PERM_MODES },
);
expect(r.agentKind).toBe('claude-code');
expect(r.fallbacksApplied).toContain('agent:model-less-fallback');
expect(r.model).toBe('claude-sonnet-4-6');
expect(r.effort).not.toBe('low');
});
it('first-available 兜底优先 native 默认源(claude-code 优先 xd),不用 rail 序首个', () => {
// rail 序 anthropic 在前(首见 'a-first'),但 native 源是 xd —— 兜底必须取 xd 目录序
// 首个可用('xd-first'),与 IM 现行 nativeDefaultSourceId 口径一致,否则换来源/计费路由。
const provs = [
{
id: 'anthropic',
name: 'anthropic',
agents: ['claude-code'],
routing: { 'claude-code': {} },
models: { 'claude-code': [model('a-first')] },
connected: true,
},
{
id: 'xd',
name: 'xd',
agents: ['claude-code'],
routing: { 'claude-code': {} },
models: { 'claude-code': [model('xd-first'), model('a-first')] },
connected: true,
},
] as unknown as ProviderView[];
const r = resolveModelInvocation(
{ model: 'gone' },
{ ...SCENARIO, modelFor: () => 'also-gone' },
{ providers: provs, getPermissionModes: PERM_MODES },
);
expect(r.model).toBe('xd-first');
expect(r.fallbacksApplied).toContain('model:first-available');
});
});
describe('resolveModelInvocation — codex review 四轮:无点名路径与 provider 偏好作废', () => {
it('无点名 + native 源上模型被隐藏、他源可见 → 显式收敛到可见源(null 会被下游路由进隐藏源)', () => {
// claude-code 的 native 默认源是 xd;(xd, claude-opus-5) 被隐藏,anthropic 可见。
// 下游 effectiveSourceIdForModel(null) 不看可见性会选回 xd —— 必须显式定到 anthropic。
const r = resolveModelInvocation(
{ model: 'claude-opus-5' },
SCENARIO,
ctx({ isVisible: (pid, m) => !(pid === 'xd' && m.id === 'claude-opus-5') }),
);
expect(r.model).toBe('claude-opus-5');
expect(r.providerId).toBe('anthropic');
expect(r.fallbacksApplied).toContain('provider:visible-fallback');
});
it('无点名 + 下游默认落点本就可见 → 维持 null(「null=默认路由」契约不变)', () => {
const r = resolveModelInvocation(
{ model: 'claude-opus-5' },
SCENARIO,
ctx({ isVisible: (pid, m) => !(pid === 'anthropic' && m.id === 'claude-sonnet-4-6') }),
);
expect(r.providerId).toBeNull();
expect(r.fallbacksApplied).not.toContain('provider:visible-fallback');
});
it('无点名 + 未注入可见性 → 维持 null(既有契约)', () => {
const r = resolveModelInvocation({ model: 'claude-opus-5' }, SCENARIO, ctx());
expect(r.providerId).toBeNull();
});
it('agent 回落时 providerId 偏好一并作废,不把原 agent 的路由强加给回落 agent', () => {
const provs = [
{
id: 'pa',
name: 'pa',
agents: ['codex'],
routing: { codex: {} },
models: { codex: [] },
connected: true,
},
{
id: 'pb',
name: 'pb',
agents: ['claude-code'],
routing: { 'claude-code': {} },
models: { 'claude-code': [model('claude-sonnet-4-6')] },
connected: true,
},
] as unknown as ProviderView[];
const r = resolveModelInvocation(
{ agentKind: 'codex', providerId: 'pb' },
SCENARIO,
{ providers: provs, getPermissionModes: PERM_MODES },
);
expect(r.agentKind).toBe('claude-code');
expect(r.fallbacksApplied).toContain('agent:model-less-fallback');
// 原 agent 的 providerId 偏好作废;无 scenario.providerIdFor → null 默认路由
expect(r.providerId).toBeNull();
});
});
describe('resolveModelInvocation — codex review 五轮:native 兜底行级可见性 + 场景权限档校验', () => {
it('native 源上首模型被隐藏 → 跳到该源下一个可见模型,不经他源路由漂移', () => {
// xd(native)目录 [opus, sonnet]:opus 在 xd 被隐藏(anthropic 可见)。兜底必须选
// xd 的 sonnet —— 选 opus 会被 provider 步骤路由去 anthropic,换掉订阅/计费路由。
const r = resolveModelInvocation(
{ model: 'gone' },
{ ...SCENARIO, modelFor: () => 'also-gone' },
ctx({ isVisible: (pid, m) => !(pid === 'xd' && m.id === 'claude-opus-5') }),
);
expect(r.model).toBe('claude-sonnet-4-6');
expect(r.fallbacksApplied).toContain('model:first-available');
});
it('无显式权限档时,场景默认档不被最终 agent 支持 → 回落该 agent 最严档', () => {
const r = resolveModelInvocation(
{ agentKind: 'codex' },
{ ...SCENARIO, agentKind: 'codex', permissionMode: 'acceptEdits' },
ctx(),
);
// codex 不支持 acceptEdits(PERM_MODES) → 最严档 ask,不裸透传
expect(r.permissionMode).toBe('ask');
expect(r.fallbacksApplied).toContain('permission:scenario-strictest-fallback');
});
it('场景默认档被支持 → 原样(既有语义不变)', () => {
const r = resolveModelInvocation({}, SCENARIO, ctx());
expect(r.permissionMode).toBe('bypassPermissions');
expect(r.fallbacksApplied).not.toContain('permission:scenario-strictest-fallback');
});
});
describe('resolveModelInvocation — model 候选清单本身先过 chat 准入(issue #882 第 3 点,2026-07 review 第 20 轮)', () => {
it('native 源上首模型是非聊天类型 → 跳过它,兜底选该源下一个聊天模型,不是裸 available[0]', () => {
// xd(native)目录 [opus(非聊天), sonnet]:旧实现的 availableModelsFor 不过滤 mode,
// has()/fromNative/available[0] 都可能选中 opus;providerId 步骤只能校验"选中的
// 来源",无法撤销已经选错的模型。
const provs = providers().map((p) =>
p.id === 'xd'
? {
...p,
models: {
...p.models,
'claude-code': [
model('claude-opus-5', { mode: 'embedding' }),
model('claude-sonnet-4-6'),
],
},
}
: p,
) as ProviderView[];
const r = resolveModelInvocation(
{ model: 'gone' },
{ ...SCENARIO, modelFor: () => 'also-gone' },
{ providers: provs, getPermissionModes: PERM_MODES },
);
expect(r.model).toBe('claude-sonnet-4-6');
expect(r.fallbacksApplied).toContain('model:first-available');
});
it('显式偏好的模型 id 在所有来源都只以非聊天类型存在 → 不算「可用」,回落场景默认', () => {
// 两个来源的 claude-opus-5 都改成非聊天,确保没有任何一份聊天可用的同 id 条目
// 能让 has() 误放行。
const provs = providers().map((p) => {
if (p.id === 'anthropic') {
return { ...p, models: { 'claude-code': [model('claude-opus-5', { mode: 'embedding' })] } };
}
if (p.id === 'xd') {
return {
...p,
models: {
...p.models,
'claude-code': [
model('claude-opus-5', { mode: 'embedding' }),
model('claude-sonnet-4-6'),
],
},
};
}
return p;
}) as ProviderView[];
const r = resolveModelInvocation(
{ model: 'claude-opus-5' },
SCENARIO,
{ providers: provs, getPermissionModes: PERM_MODES },
);
expect(r.model).toBe('claude-sonnet-4-6');
expect(r.fallbacksApplied).toContain('model:scenario-default');
});
});