Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(models): 统一启动默认模型并优先使用 Pi 运行 Grok (#5866)

Chris Zhangd2e291c8009a
diff --git a/apps/desktop/src/renderer/__tests__/draftModelCalibration.test.ts b/apps/desktop/src/renderer/__tests__/draftModelCalibration.test.ts
index 3f6abb9744..f44f48b285 100644
--- a/apps/desktop/src/renderer/__tests__/draftModelCalibration.test.ts
+++ b/apps/desktop/src/renderer/__tests__/draftModelCalibration.test.ts
@@ -7,7 +7,9 @@
*/
import { describe, expect, it } from 'vitest';
-import type { CatalogModel, ProviderView } from '@cindy/model-providers';
+import type { AgentKind, CatalogModel, ProviderView } from '@cindy/model-providers';
+
+import { resolveNewMakerDefaultTuple } from '../lib/newMakerDefaultTuple';
import {
calibrateDraftModel,
@@ -881,3 +883,46 @@ describe('resolveNewTaskDefaultRoute(无人值守入口的新建任务默认)',
).toBeNull();
});
});
+
+describe('factory defaults survive send-time calibration', () => {
+ it.each([null, 'openai'])('keeps startup visibility switches during calibration (source %s)', preferredProviderId => {
+ const openai = provider('openai', true, { codex: [model('gpt-6-sol'), model('gpt-6-astra')] }, 'subscription');
+ const isModelEnabled = (agent: AgentKind, providerId: string, candidate: { id: string }) =>
+ !(agent === 'codex' && providerId === 'openai' && candidate.id === 'gpt-6-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-sol', providerId: 'openai' });
+ // A hidden model explicitly selected by the user still wins.
+ expect(calibrateDraftModel({ ...input, model: 'gpt-6-sol', chosenByUser: true, isModelEnabled }))
+ .toEqual({ model: 'gpt-6-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' });
+ });
+});
diff --git a/apps/desktop/src/renderer/__tests__/newMakerDraft.test.ts b/apps/desktop/src/renderer/__tests__/newMakerDraft.test.ts
index eefc4eaa9d..af157d8294 100644
--- a/apps/desktop/src/renderer/__tests__/newMakerDraft.test.ts
+++ b/apps/desktop/src/renderer/__tests__/newMakerDraft.test.ts
@@ -98,24 +98,24 @@ describe('newMakerDraft store', () => {
expect(reloaded.getDraft().defaultTupleCustomized).toBe(false);
});
- it.each([false, true])('Gateway 后到不抢订阅,Claude 后到只更新未自定义草稿(手动选择=%s)', async (customized) => {
+ it.each([false, true])('Gateway 后到不抢订阅,Codex 后到只更新未自定义草稿(手动选择=%s)', async (customized) => {
const { resolveNewMakerDefaultTuple } = await import('@/lib/newMakerDefaultTuple');
const { applySuggestedDefaultTuple, getDraft, markDefaultTupleCustomized } = await loadModule();
const sources: import('@cindy/model-providers').ProviderView[] = [
{
- id: 'openai',
- name: 'OpenAI',
+ id: 'anthropic',
+ name: 'Claude',
source: 'builtin',
connected: true,
- agents: ['codex'],
+ agents: ['claude-code'],
auth: { method: 'oauth' },
- access: { kind: 'subscription', product: 'ChatGPT' },
+ access: { kind: 'subscription', product: 'Claude' },
routing: {},
models: {
- codex: [
+ 'claude-code': [
{
- id: 'gpt-6-astra',
- name: 'Astra',
+ id: 'claude-opus-5-5',
+ name: 'Opus',
contextWindow: 272000,
efforts: ['high'],
defaultEffort: 'high',
@@ -132,7 +132,7 @@ describe('newMakerDraft store', () => {
availableAgentsLoaded: true,
})!;
expect(applySuggestedDefaultTuple(resolve())).toBe(true);
- expect(getDraft().vendor).toBe('codex');
+ expect(getDraft().vendor).toBe('cc');
if (customized) markDefaultTupleCustomized();
sources.push({
id: 'xd',
@@ -146,8 +146,8 @@ describe('newMakerDraft store', () => {
models: {
pi: [
{
- id: 'z-ai/glm-5.3-flash',
- name: 'GLM',
+ id: 'auto',
+ name: 'Auto',
contextWindow: 200000,
efforts: ['high'],
defaultEffort: 'high',
@@ -158,15 +158,15 @@ describe('newMakerDraft store', () => {
},
});
expect(applySuggestedDefaultTuple(resolve())).toBe(false);
- expect(getDraft().vendor).toBe('codex');
- sources.push({ ...sources[0]!, id: 'anthropic', agents: ['claude-code'],
- access: { kind: 'subscription', product: 'Claude' },
- models: { 'claude-code': [{ id: 'claude-opus-5-5', name: 'Opus', contextWindow: 200000, efforts: ['high'], defaultEffort: 'high' }] },
+ expect(getDraft().vendor).toBe('cc');
+ sources.push({ ...sources[0]!, id: 'openai', agents: ['codex'],
+ access: { kind: 'subscription', product: 'ChatGPT' },
+ models: { codex: [{ id: 'gpt-6-sol', name: 'Sol', contextWindow: 272000, efforts: ['high'], defaultEffort: 'high' }] },
});
expect(applySuggestedDefaultTuple(resolve())).toBe(!customized);
const draft = getDraft();
- expect(draft.vendor).toBe(customized ? 'codex' : 'cc');
- expect(draft.lastByVendor[draft.vendor].providerId).toBe(customized ? 'openai' : 'anthropic');
+ expect(draft.vendor).toBe(customized ? 'cc' : 'codex');
+ expect(draft.lastByVendor[draft.vendor].providerId).toBe(customized ? 'anthropic' : 'openai');
expect(draft.defaultTupleCustomized).toBe(customized);
expect(applySuggestedDefaultTuple(resolve())).toBe(false);
});
diff --git a/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx b/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
index c7265f911a..efc157926e 100644
--- a/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
+++ b/apps/desktop/src/renderer/features/cc-agent/NewMakerDraftRoute.tsx
@@ -1386,6 +1386,7 @@ export function NewMakerDraftRoute() {
if (usesDeviceCatalog) return { model: chatPrefs.model, providerId: null };
return calibrateDraftModel({
providers: autoCalibrationProviders,
+ isModelEnabled,
agent: capabilityAgentKind,
model: chatPrefs.model,
chosenByUser: draftModelChosenByUser,
@@ -1400,6 +1401,7 @@ export function NewMakerDraftRoute() {
chatPrefs.providerId,
draftModelChosenByUser,
localProvidersLoading,
+ defaultVisibilityVersion,
]);
const calibratedDraftModel = draftCalibration.model;
diff --git a/apps/desktop/src/renderer/lib/__tests__/newMakerDefaultTuple.test.ts b/apps/desktop/src/renderer/lib/__tests__/newMakerDefaultTuple.test.ts
index 44bb329a4c..d40837e322 100644
--- a/apps/desktop/src/renderer/lib/__tests__/newMakerDefaultTuple.test.ts
+++ b/apps/desktop/src/renderer/lib/__tests__/newMakerDefaultTuple.test.ts
@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
import type { AgentKind, CatalogModel, ProviderView } from '@cindy/model-providers';
-import { resolveNewMakerDefaultTuple } from '@/lib/newMakerDefaultTuple';
+import { resolveNewMakerDefaultTuple, isKnownProductDefaultTupleIdentity } from '@/lib/newMakerDefaultTuple';
function model(
id: string,
@@ -63,9 +63,9 @@ describe('resolveNewMakerDefaultTuple', () => {
{ defaultEffort: 'max', efforts: ['low', 'medium', 'high'], expected: 'high' },
{ defaultEffort: undefined, efforts: [], expected: null },
])('keeps a usable model with incomplete or stale effort metadata: %j', ({ defaultEffort, efforts, expected }) => {
- const candidate = { ...model('gpt-6-astra'), defaultEffort, efforts } as CatalogModel;
+ const candidate = { ...model('gpt-6-sol'), defaultEffort, efforts } as CatalogModel;
expect(resolve([provider({ id: 'openai', access: 'subscription', models: { codex: [candidate] } })]))
- .toMatchObject({ model: 'gpt-6-astra', effort: expected });
+ .toMatchObject({ model: 'gpt-6-sol', effort: expected });
});
it('没有来源或清单仍在加载时不编造默认组合', () => {
@@ -87,13 +87,13 @@ describe('resolveNewMakerDefaultTuple', () => {
id: 'openai',
access: 'subscription',
models: {
- codex: [{ ...model('chatgpt/gpt-6-astra', 'medium'), efforts: ['medium', 'high'] }],
+ codex: [{ ...model('chatgpt/gpt-6-sol', 'medium'), efforts: ['medium', 'high'] }],
},
}),
expected: {
vendor: 'codex',
providerId: 'openai',
- model: 'chatgpt/gpt-6-astra',
+ model: 'chatgpt/gpt-6-sol',
effort: 'medium',
},
},
@@ -126,13 +126,13 @@ describe('resolveNewMakerDefaultTuple', () => {
id: 'xd',
access: 'managed',
models: {
- pi: [model('z-ai/glm-5.3-flash', 'high', ['pi'], ['text', 'image'])],
+ pi: [model('auto', 'high', ['pi'], ['text', 'image'])],
},
}),
expected: {
vendor: 'pi',
providerId: 'xd',
- model: 'z-ai/glm-5.3-flash',
+ model: 'auto',
effort: 'high',
},
},
@@ -140,12 +140,12 @@ describe('resolveNewMakerDefaultTuple', () => {
expect(resolve([source])).toEqual(expected);
});
- it('Opus → Astra → Gateway,与来源清单顺序无关', () => {
+ it('Sol → Opus → Cindy Auto,与来源清单顺序无关', () => {
const gateway = provider({
id: 'xd',
access: 'managed',
models: {
- pi: [model('z-ai/glm-5.3-flash', 'high', ['pi'], ['text', 'image'])],
+ pi: [model('auto', 'high', ['pi'], ['text', 'image'])],
},
});
const anthropic = provider({
@@ -156,15 +156,16 @@ describe('resolveNewMakerDefaultTuple', () => {
const openai = provider({
id: 'openai',
access: 'subscription',
- models: { codex: [model('chatgpt/gpt-6-astra')] },
+ models: { codex: [model('chatgpt/gpt-6-sol')] },
});
for (const sources of [
[gateway, anthropic, openai],
[openai, anthropic, gateway],
]) {
- expect(resolve(sources)).toMatchObject({ vendor: 'cc', providerId: 'anthropic', model: 'claude-opus-5-5' });
+ expect(resolve(sources)).toMatchObject({ vendor: 'codex', providerId: 'openai', model: 'chatgpt/gpt-6-sol' });
}
- expect(resolve([anthropic, openai])).toMatchObject({ providerId: 'anthropic' });
+ expect(resolve([anthropic, openai])).toMatchObject({ providerId: 'openai' });
+ expect(resolve([gateway, anthropic])).toMatchObject({ providerId: 'anthropic' });
expect(resolve([gateway, openai])).toMatchObject({ providerId: 'openai', vendor: 'codex' });
expect(resolve([gateway])).toMatchObject({ providerId: 'xd', vendor: 'pi' });
expect(resolve([anthropic, openai, gateway], new Set(['codex', 'pi']))).toMatchObject({ providerId: 'openai', vendor: 'codex' });
@@ -176,7 +177,7 @@ describe('resolveNewMakerDefaultTuple', () => {
id: 'xd',
access: 'managed',
models: {
- pi: [model('z-ai/glm-5.3-flash', 'high', ['pi'], ['text', 'image'])],
+ pi: [model('auto', 'high', ['pi'], ['text', 'image'])],
},
});
const xai = provider({
@@ -187,7 +188,7 @@ describe('resolveNewMakerDefaultTuple', () => {
expect(resolve([gateway, xai])).toEqual({
vendor: 'pi',
providerId: 'xd',
- model: 'z-ai/glm-5.3-flash',
+ model: 'auto',
effort: 'high',
});
});
@@ -197,24 +198,20 @@ describe('resolveNewMakerDefaultTuple', () => {
'suspended',
'failed',
'hidden',
- 'unmarked',
- 'no-image',
'no-pi',
] as const)('Gateway 不可用(%s)时排除该路由,保留订阅', (reason) => {
- const gatewayModel = model('z-ai/glm-5.3-flash', 'high', ['pi'], ['text', 'image']);
+ const gatewayModel = model('auto', 'high', ['pi'], ['text', 'image']);
const gateway = provider({ id: 'xd', access: 'managed', models: { pi: [gatewayModel] } });
const openai = provider({
id: 'openai',
access: 'subscription',
- models: { codex: [model('gpt-6-astra')] },
+ models: { codex: [model('gpt-6-sol')] },
});
if (reason === 'disconnected') gateway.connected = false;
if (reason === 'suspended') gateway.suspended = true;
if (reason === 'failed')
gateway.modelDiscoveryFailure = { kind: 'upstream', at: '2026-09-05T00:00:00Z' };
if (reason === 'hidden') gatewayModel.defaultEnabled = false;
- if (reason === 'unmarked') gatewayModel.newSessionDefault = undefined;
- if (reason === 'no-image') gatewayModel.modalities = { input: ['text'], output: ['text'] };
const agents = reason === 'no-pi' ? new Set(['cc', 'codex'] as const) : allAgents;
expect(resolve([gateway], agents)).toBeNull();
expect(resolve([gateway, openai], agents)).toMatchObject({
@@ -240,12 +237,12 @@ describe('resolveNewMakerDefaultTuple', () => {
});
});
- it('does not put Opus or Astra on another harness when their native harness is absent', () => {
+ it('does not put Opus or Sol on another harness when their native harness is absent', () => {
const anthropic = provider({ id: 'anthropic', access: 'subscription', models: {
'claude-code': [model('claude-opus-5-5')], pi: [model('claude-opus-5-5')], codex: [model('claude-opus-5-5')],
} });
const openai = provider({ id: 'openai', access: 'subscription', models: {
- codex: [model('gpt-6-astra')], pi: [model('gpt-6-astra')], 'claude-code': [model('gpt-6-astra')],
+ codex: [model('gpt-6-sol')], pi: [model('gpt-6-sol')], 'claude-code': [model('gpt-6-sol')],
} });
expect(resolve([anthropic], new Set(['codex', 'pi']))).toBeNull();
expect(resolve([openai], new Set(['cc', 'pi']))).toBeNull();
@@ -255,14 +252,14 @@ describe('resolveNewMakerDefaultTuple', () => {
const failedOpenai = provider({
id: 'openai',
access: 'subscription',
- models: { codex: [model('chatgpt/gpt-6-astra')] },
+ models: { codex: [model('chatgpt/gpt-6-sol')] },
failed: true,
});
const gateway = provider({
id: 'xd',
access: 'managed',
models: {
- pi: [model('z-ai/glm-5.3-flash', 'high', ['pi'], ['text', 'image'])],
+ pi: [model('auto', 'high', ['pi'], ['text', 'image'])],
},
});
expect(resolve([failedOpenai, gateway])).toMatchObject({
@@ -271,43 +268,78 @@ describe('resolveNewMakerDefaultTuple', () => {
});
});
- it('Gateway 没有服务端默认标记时保持空态', () => {
+ it('Cindy Auto 不依赖旧 GLM 的默认标记', () => {
const gateway = provider({
id: 'xd',
access: 'managed',
models: {
- pi: [model('z-ai/glm-5.3-flash', 'high', undefined, ['text', 'image'])],
+ pi: [model('auto', 'high', undefined, ['text', 'image'])],
},
});
- expect(resolve([gateway])).toBeNull();
+ expect(resolve([gateway])).toMatchObject({ providerId: 'xd', model: 'auto', vendor: 'pi' });
});
- it('Gateway 只有旧 Codex 标记时不把 GLM 默认塞进其它 Harness', () => {
+ it('Cindy Auto 没有 Pi 路由时不伪造 Pi 候选', () => {
const gateway = provider({
id: 'xd',
access: 'managed',
models: {
- codex: [model('z-ai/glm-5.3-flash', 'high', ['codex'], ['text', 'image'])],
+ codex: [model('auto', 'high', ['codex'], ['text', 'image'])],
},
});
expect(resolve([gateway])).toBeNull();
});
- it('Gateway 默认标记误落到纯文本模型时保持空态', () => {
+ it('Cindy Auto 沿用实际下发的输入能力,不靠图片字段决定默认身份', () => {
const gateway = provider({
id: 'xd',
access: 'managed',
- models: { pi: [model('z-ai/glm-5.3-flash', 'high', ['pi'], ['text'])] },
+ models: { pi: [model('auto', 'high', ['pi'], ['text'])] },
});
- expect(resolve([gateway])).toBeNull();
+ expect(resolve([gateway])).toMatchObject({ providerId: 'xd', model: 'auto', vendor: 'pi' });
});
it('新任务沿用模型声明的默认深度,不另写 high', () => {
const openai = provider({
id: 'openai',
access: 'subscription',
- models: { codex: [model('chatgpt/gpt-6-astra', 'medium')] },
+ models: { codex: [model('chatgpt/gpt-6-sol', 'medium')] },
});
expect(resolve([openai])).toMatchObject({ effort: 'medium' });
});
+
+ it.each([false, true])('searches independent accounts before model fallback (visibility callback: %s)', withVisibility => {
+ const stale = provider({ id: 'openai', access: 'subscription', models: { codex: [model('gpt-old')] } });
+ const account = provider({ id: 'openai-account', access: 'subscription', models: { codex: [model('gpt-6-sol')] } });
+ account.auth = { method: 'oauth', native: 'codex' };
+ const args = { providers: [stale, account], providersLoading: false, availableAgents: allAgents,
+ availableAgentsLoaded: true, ...(withVisibility ? { isModelEnabled: () => true } : {}) };
+ expect(resolveNewMakerDefaultTuple(args)).toMatchObject({ providerId: account.id, model: 'gpt-6-sol' });
+ if (withVisibility) {
+ // Once no account has a visible Sol, retain the enabled model fallback.
+ expect(resolveNewMakerDefaultTuple({ ...args, isModelEnabled: (_agent, _providerId, m) => m.id !== 'gpt-6-sol' }))
+ .toMatchObject({ providerId: stale.id, model: 'gpt-old' });
+ }
+ const claude = provider({ id: 'claude-account', access: 'subscription', models: { 'claude-code': [model('claude-opus-5-5')] } });
+ claude.auth = { method: 'oauth', native: 'claude' };
+ expect(resolve([claude])).toMatchObject({ providerId: claude.id, vendor: 'cc' });
+ });
+
+ it('does not replace missing or disabled Auto with a hardcoded gateway model', () => {
+ const glm = model('z-ai/glm-5.3-flash', 'high', ['pi'], ['text', 'image']);
+ const gateway = provider({ id: 'xd', access: 'managed', models: { pi: [glm] } });
+ const args = { providers: [gateway], providersLoading: false, availableAgents: allAgents,
+ availableAgentsLoaded: true, isModelEnabled: (_agent: AgentKind, _id: string, m: { id: string }) => m.id !== 'auto' };
+ expect(resolveNewMakerDefaultTuple(args)).toBeNull();
+ gateway.models.pi!.push(model('auto'));
+ expect(resolveNewMakerDefaultTuple(args)).toBeNull();
+ expect(resolveNewMakerDefaultTuple({ ...args, isModelEnabled: () => true }))
+ .toMatchObject({ providerId: 'xd', model: 'auto' });
+ });
+
+ it('recognizes earlier automatic tuples without declaring them current defaults', () => {
+ expect(isKnownProductDefaultTupleIdentity({ vendor: 'codex', providerId: 'openai', model: 'gpt-6-astra' })).toBe(true);
+ expect(isKnownProductDefaultTupleIdentity({ vendor: 'pi', providerId: 'xd', model: 'z-ai/glm-5.3-flash' })).toBe(true);
+ expect(isKnownProductDefaultTupleIdentity({ vendor: 'pi', providerId: 'xd', model: 'auto' })).toBe(true);
+ });
});
diff --git a/apps/desktop/src/shared/draftModelCalibration.ts b/apps/desktop/src/shared/draftModelCalibration.ts
index 7201e51c3b..337edb3b76 100644
--- a/apps/desktop/src/shared/draftModelCalibration.ts
+++ b/apps/desktop/src/shared/draftModelCalibration.ts
@@ -21,6 +21,22 @@ import {
type CatalogModel,
type ProviderView,
} from '@cindy/model-providers';
+import { resolveNewMakerDefaultTuple } from './newMakerDefaultTuple.js';
+
+type ModelEnabledPredicate = Parameters<typeof resolveNewMakerDefaultTuple>[0]['isModelEnabled'];
+
+/** Keep startup, send-time calibration and headless defaults on one factory policy. */
+function factoryModelForAgent(
+ providers: readonly ProviderView[],
+ agent: AgentKind,
+ isModelEnabled?: ModelEnabledPredicate,
+): PickedConnectedModel | null {
+ const tuple = resolveNewMakerDefaultTuple({
+ providers, providersLoading: false, availableAgentsLoaded: true, isModelEnabled,
+ availableAgents: new Set([agent === 'claude-code' ? 'cc' : agent]),
+ });
+ return tuple ? { model: tuple.model, providerId: tuple.providerId } : null;
+}
/**
* 挑选顺序(2026-07-30 产品定稿):**可用的里面选第一个 —— 供应商优先订阅的,
@@ -128,7 +144,7 @@ function markedDefaultModelIdForAgent(
/**
* 在该 agent 的已连接来源里挑 (模型, 来源):
- * 0. 目录/服务端**显式标记**为新对话默认(`newSessionDefault`)、且可用且默认可见的模型
+ * 0. 同一 Harness 的可用出厂组合优先;没有时才取目录/服务端**显式标记**为新对话默认(`newSessionDefault`)、且可用且默认可见的模型
* 优先 —— 未显式选过模型的用户应跟随它,即便种子恰好是另一个可用模型(种子是
* capabilities 未到位时算的冷启动值,不反映标记)。按订阅优先取第一家提供它的来源,
* 同一来源多个被标记时按 sortOrder 决胜。每个 Agent 只接受自己的标记,不跨 Agent
@@ -154,10 +170,13 @@ export function pickConnectedModelForAgent(
providers: readonly ProviderView[],
agent: AgentKind,
preferredModelId: string,
+ isModelEnabled?: ModelEnabledPredicate,
): PickedConnectedModel | null {
const ranked = providersByPreference(providers, agent);
if (ranked.length === 0) return null;
- // 0. 目录/服务端显式标记的新对话默认(newSessionDefault)优先;每个 Agent 只认自己的标记。
+ const factory = factoryModelForAgent(ranked, agent, isModelEnabled);
+ if (factory) return factory;
+ // 无可用出厂组合时,保留目录/服务端显式标记的回退;每个 Agent 只认自己的标记。
const flaggedModelId = markedDefaultModelIdForAgent(ranked, agent);
if (flaggedModelId !== null) {
// 标记只存在于区域门控后的 XD 条目;来源选择仍必须独立遵守 ranked 的订阅优先。
@@ -203,6 +222,8 @@ export interface DraftModelCalibrationInput {
preferredProviderId?: string | null;
/** 供应商清单是否仍在加载:加载期不校准,避免首帧把默认模型闪成别的。 */
providersLoading: boolean;
+ /** Use the startup model switches for factory recommendations; hidden fallback remains available. */
+ isModelEnabled?: ModelEnabledPredicate;
}
/** 校准结果:草稿应当展示 / 发送的模型,以及(若校准出了结论)它该走哪家来源。 */
@@ -224,6 +245,7 @@ export function calibrateDraftModel({
chosenByUser,
preferredProviderId,
providersLoading,
+ isModelEnabled,
}: DraftModelCalibrationInput): DraftModelCalibrationResult {
if (chosenByUser || providersLoading) return { model, providerId: null };
const connectedPreferred = preferredProviderId
@@ -232,6 +254,8 @@ export function calibrateDraftModel({
)
: undefined;
if (connectedPreferred) {
+ const factory = factoryModelForAgent([connectedPreferred], agent, isModelEnabled);
+ if (factory) return factory;
// marker 只需由策略来源声明一次(当前为 XD),用户选定的来源若也提供同一 ID,仍应由
// 该来源承接;不能因它自己的目录副本没重复 marker 就退回旧模型或偷偷改走 XD。
const markedModelId = markedDefaultModelIdForAgent(providers, agent);
@@ -250,7 +274,7 @@ export function calibrateDraftModel({
}
}
const candidates = connectedPreferred ? [connectedPreferred] : providers;
- const picked = pickConnectedModelForAgent(candidates, agent, model);
+ const picked = pickConnectedModelForAgent(candidates, agent, model, isModelEnabled);
return picked ?? { model, providerId: null };
}
@@ -266,7 +290,7 @@ export interface NewTaskDraftSelection {
* 不由用户当场选模型的入口(定时任务、/learn、IM 新建任务、协同 Worker 兜底等)的默认
* (模型, 来源):与新建任务同一口径,不另写一个固定型号。
* 1. 用户在新建任务里显式选过、且仍有已连接来源可用的模型 → 用它;
- * 2. 否则按新建任务「没选过模型」的校准口径挑(区域标记 → 草稿种子 → 订阅优先的第一项);
+ * 2. 否则按新建任务「没选过模型」的校准口径挑(可用出厂组合 → 区域标记 → 草稿种子 → 订阅优先的第一项);
* 3. 一个可用来源都没有 → null,由调用方明确失败,不编造一个看似可用的模型。
* `requiredProviderId` 给定时只在该来源内挑(任务显式指定了来源)。
*/
diff --git a/apps/desktop/src/shared/newMakerDefaultTuple.ts b/apps/desktop/src/shared/newMakerDefaultTuple.ts
index 37b3453a5d..bc95c72243 100644
--- a/apps/desktop/src/shared/newMakerDefaultTuple.ts
+++ b/apps/desktop/src/shared/newMakerDefaultTuple.ts
@@ -1,5 +1,6 @@
import {
isModelSelectableForNewRoute,
+ providerCatalogId,
defaultEffortForCapabilities,
clampEffortToSupported,
type AgentKind,
@@ -21,37 +22,35 @@ interface ProviderDefaultPolicy {
accessKind: 'subscription' | 'managed';
agents: readonly AgentKind[];
modelIds: readonly string[];
- requireNewSessionDefault?: boolean;
- requireImageInput?: boolean;
+ allowOtherModels?: boolean;
}
/**
* 新用户的产品默认顺序。
*
- * Claude / Codex 订阅优先,再采用 Gateway 推荐组合,最后保留 xAI 回退。
- * 出厂推荐按完整路由选择:Opus 使用 Claude Code,Astra 使用 Codex,Gateway 使用 Pi。
+ * Codex / Claude 订阅优先,再采用服务端提供的 Cindy Auto,最后保留 xAI 回退。
+ * 出厂推荐按完整路由选择:Sol 使用 Codex,Opus 使用 Claude Code,Cindy Auto 使用 Pi。
* 不为了提供默认值把订阅模型静默放到另一个 Harness。
*/
const DEFAULT_POLICIES: readonly ProviderDefaultPolicy[] = [
{
- providerId: 'anthropic',
+ providerId: 'openai',
accessKind: 'subscription',
- agents: ['claude-code'],
- modelIds: ['claude-opus-5-5', 'anthropic/claude-opus-5-5'],
+ agents: ['codex'],
+ modelIds: ['gpt-6-sol', 'chatgpt/gpt-6-sol'],
},
{
- providerId: 'openai',
+ providerId: 'anthropic',
accessKind: 'subscription',
- agents: ['codex'],
- modelIds: ['gpt-6-astra', 'chatgpt/gpt-6-astra'],
+ agents: ['claude-code'],
+ modelIds: ['claude-opus-5-5', 'anthropic/claude-opus-5-5'],
},
{
providerId: 'xd',
accessKind: 'managed',
agents: ['pi'],
- modelIds: ['z-ai/glm-5.3-flash', 'glm-5.3-flash'],
- requireNewSessionDefault: true,
- requireImageInput: true,
+ modelIds: ['auto'],
+ allowOtherModels: false,
},
{
providerId: 'xai',
@@ -76,6 +75,8 @@ export function isKnownProductDefaultTupleIdentity(args: {
}): boolean {
// Old automatic selections remain recognizable after the factory policy changes.
const legacyPolicies: readonly ProviderDefaultPolicy[] = [
+ { providerId: 'openai', accessKind: 'subscription', agents: ['codex'], modelIds: ['gpt-6-astra', 'chatgpt/gpt-6-astra'] },
+ { providerId: 'xd', accessKind: 'managed', agents: ['pi'], modelIds: ['z-ai/glm-5.3-flash', 'glm-5.3-flash'] },
{ providerId: 'openai', accessKind: 'subscription', agents: ['codex', 'claude-code', 'pi'], modelIds: ['chatgpt/gpt-5.6-sol', 'gpt-5.6-sol'] },
{ providerId: 'anthropic', accessKind: 'subscription', agents: ['claude-code', 'codex', 'pi'], modelIds: ['claude-opus-5', 'anthropic/claude-opus-5'] },
];
@@ -87,31 +88,23 @@ export function isKnownProductDefaultTupleIdentity(args: {
);
}
-function supportsImageInput(
- model: NonNullable<ProviderView['models'][AgentKind]>[number],
-): boolean {
- return model.supportsImageInput === true || model.modalities?.input.includes('image') === true;
-}
-
function matchingModel(
provider: ProviderView,
agent: AgentKind,
modelIds: readonly string[],
- requireNewSessionDefault = false,
- requireImageInput = false,
+ allowOtherModels = true,
enabled?: (agent: AgentKind, providerId: string, model: { id: string; defaultEnabled?: boolean }) => boolean,
) {
const models = provider.models[agent] ?? [];
const preferred = modelIds.map((id) => models.find((model) => model.id === id));
// Once the owner has an enabled list, a disabled factory recommendation must
// yield to another enabled model from this source, never bypass that list.
- return (enabled ? [...preferred, ...models] : preferred)
+ // Cindy Auto is an upstream route identity; do not substitute a fixed model.
+ return (enabled && allowOtherModels ? [...preferred, ...models] : preferred)
.find(
(model) =>
model !== undefined &&
(enabled ? enabled(agent, provider.id, model) : model.defaultEnabled !== false) &&
- (!requireNewSessionDefault || model.newSessionDefault?.includes(agent) === true) &&
- (!requireImageInput || supportsImageInput(model)) &&
isModelSelectableForNewRoute(model, { userProvider: provider.source === 'user' }),
);
}
@@ -134,39 +127,43 @@ export function resolveNewMakerDefaultTuples(args: {
const tuples: NewMakerDefaultTuple[] = [];
for (const policy of DEFAULT_POLICIES) {
- const provider = providers.find(
+ const matchingProviders = providers.filter(
(candidate) =>
- candidate.id === policy.providerId &&
+ providerCatalogId(candidate) === policy.providerId &&
candidate.connected &&
!candidate.suspended &&
!candidate.modelDiscoveryFailure &&
candidate.access?.kind === policy.accessKind,
);
- if (!provider) continue;
-
- for (const agent of policy.agents) {
- const vendor = vendorForAgent(agent);
- if (!availableAgents.has(vendor)) continue;
- const model = matchingModel(
- provider,
- agent,
- policy.modelIds,
- policy.requireNewSessionDefault,
- policy.requireImageInput,
- args.isModelEnabled,
- );
- if (!model) continue;
- tuples.push({
- vendor,
- providerId: provider.id,
- model: model.id,
- // Missing or stale optional metadata does not disqualify a usable route.
- effort: model.efforts.length === 0 ? null
- : model.defaultEffort === null ? null
- : (clampEffortToSupported(model.defaultEffort, model.efforts)
- ?? defaultEffortForCapabilities(model.efforts)) as Effort | null,
- });
- break;
+ // Search every account for the recommendation before falling back to other
+ // enabled models. An earlier account's fallback must not hide a later Sol.
+ policySearch: for (const allowOtherModels of [false, true]) {
+ if (allowOtherModels && (!args.isModelEnabled || policy.allowOtherModels === false)) break;
+ for (const provider of matchingProviders) {
+ for (const agent of policy.agents) {
+ const vendor = vendorForAgent(agent);
+ if (!availableAgents.has(vendor)) continue;
+ const model = matchingModel(
+ provider,
+ agent,
+ policy.modelIds,
+ allowOtherModels,
+ args.isModelEnabled,
+ );
+ if (!model) continue;
+ tuples.push({
+ vendor,
+ providerId: provider.id,
+ model: model.id,
+ // Missing or stale optional metadata does not disqualify a usable route.
+ effort: model.efforts.length === 0 ? null
+ : model.defaultEffort === null ? null
+ : (clampEffortToSupported(model.defaultEffort, model.efforts)
+ ?? defaultEffortForCapabilities(model.efforts)) as Effort | null,
+ });
+ break policySearch;
+ }
+ }
}
}
return tuples;
diff --git a/docs/dev-rules/model-catalog-maintenance.md b/docs/dev-rules/model-catalog-maintenance.md
index 698532e91a..abb7d69d53 100644
--- a/docs/dev-rules/model-catalog-maintenance.md
+++ b/docs/dev-rules/model-catalog-maintenance.md
@@ -99,10 +99,13 @@ xAI 保留 Registry 声明顺序,XD 以 Gateway `/models` 为准,均不受
来源内的默认推荐可由服务端按区域下发的 `newSessionDefault` 指定;公共 Registry 的
同名字段不进入活动目录。未标记时取排序第一的默认可见模型,即账号返回的第一个可见模型。
-未手动选择模型时,客户端出厂来源顺序为 Claude 订阅 Opus 5.5(Claude Code)、
-Codex 订阅 Astra(Codex)、Cindy 推荐模型(Pi),最后保留 xAI 回退。
+未手动选择模型时,客户端出厂来源顺序为 Codex 订阅 GPT-6 Sol(Codex)、
+Claude 订阅 Opus 5.5(Claude Code)、Cindy AI 下发的 Auto(Pi),最后保留 xAI 回退。
+订阅按认证身份识别独立账号,始终保留实际账号 ID;Auto 必须存在于 Cindy AI 的可用 Pi
+目录,不依赖旧 GLM 默认标记,也不在客户端将其替换成固定型号。草稿发送校准与无人值守
+默认解析复用同一策略,避免初始化选中 Auto 后又被旧标记改回 GLM。
策略在 `apps/desktop/src/shared/newMakerDefaultTuple.ts`;连接、型号和对应引擎必须实际可用,
-不能为了满足推荐而把 Opus / Astra 放入另一个引擎。用户手动选择及型号开关始终优先,
+不能为了满足推荐而把 Sol / Opus 放入另一个引擎。用户手动选择及型号开关始终优先,
不修改已有任务的运行配置;伙伴默认复用应用选择,不另造一套来源优先级。
定时任务、`/learn`、IM 新建任务与分享导入等不由用户当场选模型的入口,
没指定模型时同样按新建任务口径解析(`apps/desktop/src/shared/draftModelCalibration.ts`
diff --git a/docs/product-rules/model-selector-unified.md b/docs/product-rules/model-selector-unified.md
index c628039f30..a6133ef55e 100644
--- a/docs/product-rules/model-selector-unified.md
+++ b/docs/product-rules/model-selector-unified.md
@@ -115,6 +115,7 @@
显式空数组不回填。不能从 Claude Code/Codex 的发现清单猜测 Pi 路由;旧 Registry
wire enum 仍不增加 pi。原生 SDK 名单不再是成员门槛;具体协议仍由客户端执行。
缺项表示尚未配置,不能仅凭目录缺席显示“不支持”。
+- **Grok 默认 Pi**:Grok 行有可用 Pi 候选时优先推荐 Pi,包括 Responses 路由;Pi 不可用时沿用已有候选回落。此推荐不改变协议、原生底座排序或用户手动引擎覆盖。
- **推荐依据缺失时默认 Pi(2026-09-11)**:模型没有可据以推导的原生协议或底座时,使用候选中的 Pi 兜底,适用于本地和自定义模型;已有协议、底座和用户手动选择仍按原规则生效。Pi 不可用时沿用已有候选回落,不按本地供应商身份强制指定 Harness。
- **Google 原生协议优先(2026-09-05)**:Cindy 模型目录明确声明
`nativeApi: google-generative-ai`,且 Pi 的实际协议匹配、在候选中时推荐 Pi。Claude Code / Codex 的
@@ -175,8 +176,8 @@
| 情形 | 行为 |
|---|---|
-| 新用户 | 本地新任务按完整组合落点:OpenAI 订阅→GPT-5.6-Sol / Codex / 模型目录默认深度;Anthropic 订阅→Claude Opus 5 / Claude Code / 模型目录默认深度;xAI 订阅→Grok 4.6 / Pi / 模型目录默认深度;CN / Global Cindy Gateway→原生多模态 GLM-5.3-Flash / Pi / 模型目录默认深度。Gateway 默认必须同时明确声明图片输入与 Pi 实时能力;Pi 不可用时不把该默认强塞进 Codex 或 Claude Code |
-| 多来源 | Gateway 的可用推荐组合优先于订阅(CN / Global 一致);Gateway 未就绪或推荐组合不可用时回退订阅,多订阅稳定按 OpenAI→Anthropic→xAI。本机自动发现 ChatGPT 登录不改变此优先级。来源仍在加载、账号目录没有目标模型、或零来源时不编造组合,保留连接引导 |
+| 新用户 | 本地新任务按完整组合落点:OpenAI 订阅→GPT-6 Sol / Codex;Anthropic 订阅→Claude Opus 5.5 / Claude Code;Cindy AI→服务端下发的 Auto / Pi;之后保留 xAI 订阅→Grok / Pi 回退。深度沿用各模型目录默认值;来源、模型和引擎必须可用,不伪造 Auto,也不借旧 GLM 默认标记选固定型号 |
+| 多来源 | 未自定义时按 OpenAI→Anthropic→Cindy AI→xAI 选择可用组合(CN / Global 一致);独立订阅账号按认证身份识别,保留真实账号 ID。用户手动选择保持优先;来源仍在加载、账号没有可用目标、或零来源时不编造组合 |
| 未自定义老用户 | 同新用户;自动下放不设置 `modelChosenByVendor`。仅由旧版 cc 不可用触发并持久化的非 cc Harness 仍属于系统回退,不算用户自定义 |
| 已自定义老用户 | 任一明确的 Harness / 来源 / 模型 / 思考深度 / Fast 选择会封住后续自动下放;`modelChosenByVendor`、providerModelMemory、引擎 override 与形态偏好全部保留 |
| 远程任务 | SSH / device-link 不套用控制端本机登录态;继续由执行端能力与来源快照决定,避免把本机授权强塞给远端 |
diff --git a/packages/model-providers/src/__tests__/unifiedSelection.test.ts b/packages/model-providers/src/__tests__/unifiedSelection.test.ts
index 8fde11b780..b88152c97f 100644
--- a/packages/model-providers/src/__tests__/unifiedSelection.test.ts
+++ b/packages/model-providers/src/__tests__/unifiedSelection.test.ts
@@ -520,6 +520,17 @@ describe('recommendedAgentForModel', () => {
expect(recommendedAgentForModel(providers, 'xai', 'xai/grok-4.5')).toBe('pi');
});
+ it.each(['xai', 'xd', 'custom-gateway'])('Grok Responses on %s recommends Pi without changing other candidates', (id) => {
+ const grok = view({ id, models: {
+ codex: [m('x-ai/grok-future', { group: 'grok', nativeApi: 'openai-responses', api: 'openai-responses' })],
+ pi: [m('x-ai/grok-future', { group: 'grok', nativeApi: 'openai-responses', piApi: 'openai-responses' })],
+ } });
+ expect(pickRecommendedAgent(grok, 'x-ai/grok-future', ['codex', 'pi'])).toBe('pi');
+ expect(pickRecommendedAgent(grok, 'x-ai/grok-future', ['codex'])).toBe('codex');
+ expect(nativeAgentForProviderModel(grok, 'x-ai/grok-future')).toBeNull();
+ expect(candidateAgentsForModel([grok], id, 'x-ai/grok-future')).toEqual(['codex', 'pi']);
+ });
+
it('xd 网关:按家族推荐 —— gpt 系(含 codex/ 折扣)→ codex,claude 系 → claude-code', () => {
expect(recommendedAgentForModel(providers, 'xd', 'codex/gpt-5.5')).toBe('codex');
// 2026-08-14 改判:GPT 非折扣行主场也是 codex,推荐随主场(此前落 null 走 cc 优先
diff --git a/packages/model-providers/src/unifiedSelection.ts b/packages/model-providers/src/unifiedSelection.ts
index c0f309ce2a..add272be95 100644
--- a/packages/model-providers/src/unifiedSelection.ts
+++ b/packages/model-providers/src/unifiedSelection.ts
@@ -347,7 +347,7 @@ export function nativeAgentForProviderModel(
*
* 1. 无候选 → null(没有可推荐的东西,不编);
* 2. 单候选 → 即它(pi 唯一候选时也推荐 pi);
- * 3. 目录声明原生协议且实际路由匹配 → 取该协议首选引擎,其次原生 Pi;
+ * 3. Grok 有 Pi 候选时推荐 Pi;其余模型有原生协议且路由匹配时取协议首选引擎,其次 Pi;
* 4. 旧目录缺声明时,保留 Google API Pi 与已有底座的回落规则;
* 5. 没有原生协议或底座依据时默认 Pi(必须是候选);
* 6. 其余回落:候选里按 cc > codex 取第一个;都没有则 pi。
@@ -366,6 +366,12 @@ export function pickRecommendedAgent(
const model = findCatalogModel(provider, modelId, agent, { exact: true });
if (model) models[agent] = model;
}
+ // Grok uses Pi by default even when the supplier speaks Responses. This is a
+ // recommendation only: candidates and explicit engine overrides stay authoritative.
+ if (candidates.includes('pi') && models.pi && groupOf({
+ id: normalizeModelIdForClassification(modelId),
+ ...(models.pi.group !== undefined ? { group: models.pi.group } : {}),
+ }) === 'grok') return 'pi';
const comparison = provider ? modelProtocolComparison(provider, models) : null;
const canonical = comparison?.reference;
if (canonical) {