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。

24.0 KB
Raw Blame
/**
 * sourceSwitch.test.ts
 * ---------------------------------------------------------------------------
 * 回归 components/new-chat/sourceSwitch.ts 的纯逻辑:
 *   - categorize:按 id 前缀归类
 *   - resolveSourceSwitch:切来源时「目标 model / effort」的决策优先级
 *       1. 记忆命中(仍被 offer + 当前 agent 可见)→ 恢复 model + effort
 *       2. 记忆命中但与当前模型相同 → 不动模型,只带回 effort
 *       3. 记忆的 effort 已不被目标模型支持 → 只恢复 model,effort 留空
 *       4. 无记忆 + 当前模型不被新来源 offer → reconcile 到 CATEGORY_ORDER 首个可用
 *       5. 无记忆 + 当前模型仍被 offer → 全不动
 *       6. 记忆 stale(模型不被 offer / 不可见)→ 回退到 4/5 规则
 *
 * 纯函数 + 仅依赖 @cindy/model-providers 的 providerOffersModel(agent-scoped),可在 node env 直接测。
 * 本组用例全部以 claude-code 会话视角(visibleModels = claude-* )验证。
 */

import { describe, it, expect } from 'vitest';

import type { AgentKind, ProviderView } from '@cindy/model-providers';
import {
  buildProviderSections,
  categorize,
  groupOf,
  groupModelsForDisplay,
  isSelectedSourceDisconnected,
  resolveEffort,
  resolveProviderSwitchEffort,
  resolveSourceSwitch,
  type SwitchModel,
} from '@/components/new-chat/sourceSwitch';
import type { Effort } from '@/lib/userPreferences.types';

const AGENT: AgentKind = 'claude-code';

/** 最小 ProviderView —— resolveSourceSwitch 只读 provider.models[agent][].id。 */
function provider(id: string, modelIds: string[]): ProviderView {
  return {
    id,
    name: id,
    models: { [AGENT]: modelIds.map((mid) => ({ id: mid })) },
  } as unknown as ProviderView;
}

const models = (...defs: Array<[string, string[]]>): SwitchModel[] =>
  defs.map(([id, efforts]) => ({ id, efforts }));

describe('categorize', () => {
  it('按 id 前缀归类', () => {
    expect(categorize('claude-opus-4-8')).toBe('anthropic');
    expect(categorize('gpt-5.4')).toBe('gpt');
    expect(categorize('codex/gpt-5.4')).toBe('gpt-budget');
    expect(categorize('gemini-3-pro')).toBe('google');
    // 认不出厂商 → 中性兜底组;「中国」只由目录 group 产生(见 model-providers 的
    // classification.test.ts「只认目录下发的 group」用例)。
    expect(categorize('moonshotai/kimi-k2')).toBe('ungrouped');
  });
});

describe('groupOf — 数据优先,前缀兜底', () => {
  it('合法 group 字段优先于 id 前缀', () => {
    // id 看着像 gpt,但目录把它归到 china → 以 group 为准
    expect(groupOf({ id: 'gpt-weird', group: 'china' })).toBe('china');
    expect(groupOf({ id: 'codex/gpt-5.5', group: 'gpt-budget' })).toBe('gpt-budget');
  });
  it('无 group / 未知 group → 回退 categorize', () => {
    expect(groupOf({ id: 'claude-opus-4-8' })).toBe('anthropic');
    expect(groupOf({ id: 'gemini-3-flash' })).toBe('google');
    expect(groupOf({ id: 'gpt-5.5', group: 'mistral' })).toBe('gpt'); // 未知 group 忽略,按前缀
  });
});

describe('groupModelsForDisplay — sortOrder 升序 + group 分桶 + 桶序按最小 sortOrder', () => {
  it('按 sortOrder 排序并分桶,桶序 = 桶内首个出现序', () => {
    const out = groupModelsForDisplay([
      { id: 'qwen/q', group: 'china', sortOrder: 40 },
      { id: 'gpt-5.5', group: 'gpt', sortOrder: 20 },
      { id: 'codex/gpt-5.5', group: 'gpt-budget', sortOrder: 10 },
      { id: 'claude-opus-4-8', group: 'anthropic', sortOrder: 0 },
      { id: 'gpt-5.4', group: 'gpt', sortOrder: 21 },
    ]);
    // 桶序:anthropic(0) → gpt-budget(10) → gpt(20) → china(40)
    expect(out.map((g) => g.category)).toEqual(['anthropic', 'gpt-budget', 'gpt', 'china']);
    // gpt 桶内按 sortOrder:5.5(20) 在 5.4(21) 前
    expect(out.find((g) => g.category === 'gpt')!.models.map((m) => m.id)).toEqual(['gpt-5.5', 'gpt-5.4']);
  });

  it('缺 sortOrder 的排末尾;group 缺省回退前缀', () => {
    const out = groupModelsForDisplay([
      { id: 'gpt-5.5', sortOrder: 20 }, // 无 group → 前缀 gpt
      { id: 'claude-opus-4-8' }, // 无 group 无 sortOrder → anthropic,排末尾
    ]);
    expect(out.map((g) => g.category)).toEqual(['gpt', 'anthropic']);
  });
});

describe('resolveSourceSwitch', () => {
  const visible = models(
    ['claude-opus-4-8', ['low', 'medium', 'high', 'max']],
    ['claude-sonnet-4-6', ['low', 'medium', 'high']],
    ['claude-haiku-4-5', []],
  );

  it('记忆命中(与当前模型不同):恢复 model + effort', () => {
    const r = resolveSourceSwitch({
      provider: provider('anthropic', ['claude-opus-4-8', 'claude-sonnet-4-6']),
      agent: AGENT,
      currentModelId: 'claude-sonnet-4-6',
      visibleModels: visible,
      remembered: { model: 'claude-opus-4-8', effort: 'max' },
    });
    expect(r).toEqual({ reconciledModelId: 'claude-opus-4-8', reconciledEffort: 'max' });
  });

  it('记忆命中(与当前模型相同):不动模型,只带回 effort', () => {
    const r = resolveSourceSwitch({
      provider: provider('anthropic', ['claude-opus-4-8']),
      agent: AGENT,
      currentModelId: 'claude-opus-4-8',
      visibleModels: visible,
      remembered: { model: 'claude-opus-4-8', effort: 'high' },
    });
    expect(r.reconciledModelId).toBeUndefined();
    expect(r.reconciledEffort).toBe('high');
  });

  it('记忆的 effort 已不被目标模型支持:只恢复 model,effort 留空', () => {
    const r = resolveSourceSwitch({
      provider: provider('anthropic', ['claude-sonnet-4-6']),
      agent: AGENT,
      currentModelId: 'claude-opus-4-8',
      visibleModels: visible,
      // sonnet 不支持 'max'
      remembered: { model: 'claude-sonnet-4-6', effort: 'max' },
    });
    expect(r.reconciledModelId).toBe('claude-sonnet-4-6');
    expect(r.reconciledEffort).toBeUndefined();
  });

  it('无记忆 + 当前模型不被新来源 offer:reconcile 到 CATEGORY_ORDER 首个可用', () => {
    const r = resolveSourceSwitch({
      // anthropic 类排在最前;两者都 offer 时取 opus(visible 中 opus 在前)
      provider: provider('anthropic', ['claude-sonnet-4-6', 'claude-opus-4-8']),
      agent: AGENT,
      currentModelId: 'gpt-5.4', // 不被 anthropic offer
      visibleModels: visible,
      remembered: undefined,
    });
    expect(r.reconciledModelId).toBe('claude-opus-4-8');
    expect(r.reconciledEffort).toBeUndefined();
  });

  it('reconcile 候选按 mode 准入过滤(issue #882 review):mode 非 chat 且 id 落 categorize 兜底组时不被选中', () => {
    // 故意造一个 id 不含任何非聊天关键词、只能靠 categorize 兜底落中性组 'ungrouped' 的场景
    // (2026-08 前这个兜底是 'china'):旧实现用纯 id 正则的 categorize 判定候选分组,兜底组
    // 在 CHAT_VENDOR_CATEGORY_ORDER 里、会被当成有效候选;换成 mode 优先的 classifyModel 后,mode='embedding' 权威判定
    // 为非聊天,不再落进任何厂商组,候选列表为空。该来源只 offer 这一个模型,
    // 没有别的候选可选 —— 必须不选中它、保持模型不变,而不是"退而求其次"选一个非聊天模型。
    const r = resolveSourceSwitch({
      provider: provider('xd', ['some-vendor-neutral-id']),
      agent: AGENT,
      currentModelId: 'gpt-5.4', // 不被该来源 offer,触发 reconcile
      visibleModels: [{ id: 'some-vendor-neutral-id', efforts: [], mode: 'embedding' }],
      remembered: undefined,
    });
    expect(r.reconciledModelId).toBeUndefined();
  });

  it('候选校验目标 provider 自己的那份数据,不是 visibleModels 并集里的同 id 条目(issue #882,2026-07 review:fresh evidence——并集条目可能来自另一个 provider 的聊天分类,和目标 provider 自己的 mode 不一致)', () => {
    // 目标 provider('xd')上 'shared-id' 是非聊天(image_generation);但 visibleModels
    // 并集里同 id 的条目标了 mode='chat'(模拟它是从另一个 provider 的聊天分类合并过来的)。
    const targetProviderWithNonChatCopy = {
      id: 'xd',
      name: 'xd',
      models: { [AGENT]: [{ id: 'shared-id', mode: 'image_generation' }] },
    } as unknown as ProviderView;

    const r = resolveSourceSwitch({
      provider: targetProviderWithNonChatCopy,
      agent: AGENT,
      currentModelId: 'gpt-5.4', // 不被 xd offer,触发 reconcile
      visibleModels: [{ id: 'shared-id', efforts: ['low', 'high'], mode: 'chat' }],
      remembered: undefined,
    });
    // 不能选中它——目标 provider 自己的这份条目不是聊天模型,即便并集里同 id 条目标了 chat。
    expect(r.reconciledModelId).toBeUndefined();
  });

  it('记忆命中校验目标 provider 自己的那份数据(同上,remembered 分支)', () => {
    const targetProviderWithNonChatCopy = {
      id: 'xd',
      name: 'xd',
      models: { [AGENT]: [{ id: 'shared-id', mode: 'image_generation' }] },
    } as unknown as ProviderView;

    const r = resolveSourceSwitch({
      provider: targetProviderWithNonChatCopy,
      agent: AGENT,
      currentModelId: 'gpt-5.4',
      visibleModels: [{ id: 'shared-id', efforts: ['low', 'high'], mode: 'chat' }],
      remembered: { model: 'shared-id', effort: 'high' },
    });
    // 记忆指向的模型在目标 provider 上不是聊天模型 → 记忆失效,不恢复它;也没有别的候选。
    expect(r.reconciledModelId).toBeUndefined();
    expect(r.reconciledEffort).toBeUndefined();
  });

  it('无记忆 + 当前模型仍被 offer:全不动', () => {
    const r = resolveSourceSwitch({
      provider: provider('anthropic', ['claude-opus-4-8', 'claude-sonnet-4-6']),
      agent: AGENT,
      currentModelId: 'claude-opus-4-8',
      visibleModels: visible,
      remembered: undefined,
    });
    expect(r).toEqual({ reconciledModelId: undefined, reconciledEffort: undefined });
  });

  it('记忆 stale(模型不再被该来源 offer):回退到 reconcile', () => {
    const r = resolveSourceSwitch({
      provider: provider('anthropic', ['claude-sonnet-4-6']),
      agent: AGENT,
      currentModelId: 'gpt-5.4',
      visibleModels: visible,
      // 记忆里是 opus,但该来源现在只 offer sonnet → 记忆失效
      remembered: { model: 'claude-opus-4-8', effort: 'max' },
    });
    expect(r.reconciledModelId).toBe('claude-sonnet-4-6');
    expect(r.reconciledEffort).toBeUndefined();
  });

  it('记忆模型不在当前 agent 可见列表(visibleModels)中:视为失效', () => {
    const r = resolveSourceSwitch({
      provider: provider('xd', ['gpt-5.4', 'claude-opus-4-8']),
      agent: AGENT,
      currentModelId: 'claude-opus-4-8',
      visibleModels: visible, // 只有 claude-* 可见(cc agent)
      // xd offer gpt-5.4,但当前 cc agent 看不到它 → 不恢复
      remembered: { model: 'gpt-5.4', effort: 'high' },
    });
    expect(r.reconciledModelId).toBeUndefined();
    expect(r.reconciledEffort).toBeUndefined();
  });

  it('isVisible:reconcile 跳过被用户隐藏的模型,落到下一个可见的', () => {
    const r = resolveSourceSwitch({
      provider: provider('anthropic', ['claude-opus-4-8', 'claude-sonnet-4-6']),
      agent: AGENT,
      currentModelId: 'gpt-5.4', // 不被 offer → 触发 reconcile
      visibleModels: visible,
      remembered: undefined,
      // opus 被用户隐藏 → 应跳过,落到 sonnet
      isVisible: (id) => id !== 'claude-opus-4-8',
    });
    expect(r.reconciledModelId).toBe('claude-sonnet-4-6');
  });

  it('isVisible:记忆的模型已被隐藏 → 视为失效,回退 reconcile', () => {
    const r = resolveSourceSwitch({
      provider: provider('anthropic', ['claude-opus-4-8', 'claude-sonnet-4-6']),
      agent: AGENT,
      currentModelId: 'gpt-5.4', // 不被 offer
      visibleModels: visible,
      remembered: { model: 'claude-opus-4-8', effort: 'max' }, // 记忆是 opus
      isVisible: (id) => id !== 'claude-opus-4-8', // 但 opus 已隐藏
    });
    expect(r.reconciledModelId).toBe('claude-sonnet-4-6');
    expect(r.reconciledEffort).toBeUndefined();
  });
});

describe('resolveEffort —— 选中模型后 effort 落档优先级', () => {
  const EFFORTS: readonly Effort[] = ['low', 'medium', 'high', 'xhigh', 'max'];

  it('无 effort 档(efforts 为空)→ 始终 low(占位,UI 不显示)', () => {
    expect(
      resolveEffort({ efforts: [], defaultEffort: null, activeEffort: 'high', preferred: 'max' }),
    ).toBe('low');
  });

  it('preferred 最高优先(仍受支持时)', () => {
    expect(
      resolveEffort({
        efforts: EFFORTS,
        defaultEffort: 'high',
        activeEffort: 'low',
        preferred: 'max',
        providerEffort: 'medium',
        rememberedEffort: 'xhigh',
      }),
    ).toBe('max');
  });

  it('preferred 不受支持 → 跳过,落到 providerEffort((agent,provider,model) 精确记忆)', () => {
    expect(
      resolveEffort({
        efforts: ['low', 'medium', 'high'],
        defaultEffort: 'high',
        activeEffort: 'low',
        preferred: 'max', // 不在 efforts
        providerEffort: 'medium',
        rememberedEffort: 'high',
      }),
    ).toBe('medium');
  });

  it('providerEffort > rememberedEffort:同模型跨来源记忆精确恢复', () => {
    expect(
      resolveEffort({
        efforts: EFFORTS,
        defaultEffort: 'high',
        activeEffort: 'low',
        providerEffort: 'xhigh',
        rememberedEffort: 'medium',
      }),
    ).toBe('xhigh');
  });

  it('无 provider 记忆 → 落到 per-model rememberedEffort', () => {
    expect(
      resolveEffort({
        efforts: EFFORTS,
        defaultEffort: 'high',
        activeEffort: 'low',
        rememberedEffort: 'medium',
      }),
    ).toBe('medium');
  });

  it('记忆都不受支持 → 沿用当前 activeEffort(仍受支持时)', () => {
    expect(
      resolveEffort({
        efforts: ['low', 'medium', 'high'],
        defaultEffort: 'high',
        activeEffort: 'medium',
        providerEffort: 'max', // 不在 efforts
        rememberedEffort: 'xhigh', // 不在 efforts
      }),
    ).toBe('medium');
  });

  it('全无可用 → 模型默认 defaultEffort', () => {
    expect(
      resolveEffort({
        efforts: ['low', 'medium', 'high', 'xhigh'],
        defaultEffort: 'high',
        activeEffort: 'max', // 不在 efforts
      }),
    ).toBe('high');
  });

  it('defaultEffort 为 null → 落 efforts 首档(catalog 病态数据防御,现实数据不可达)', () => {
    expect(
      resolveEffort({
        efforts: ['medium', 'high'],
        defaultEffort: null,
        activeEffort: 'max', // 不在 efforts
      }),
    ).toBe('medium');
  });

  it('自定义供应商首次选中(无任何记忆,activeEffort 来自上个模型且受支持)→ 沿用', () => {
    // 自定义模型 catalog 默认档 high;若用户从一个 high 的模型切过来,沿用 high。
    expect(
      resolveEffort({
        efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
        defaultEffort: 'high',
        activeEffort: 'high',
      }),
    ).toBe('high');
  });
});

describe('resolveProviderSwitchEffort —— 同模型只切来源(严格 per-供应商,不沿用 activeEffort)', () => {
  const EFFORTS: readonly Effort[] = ['low', 'medium', 'high', 'xhigh', 'max'];

  it('preferred 最高优先(仍受支持时)', () => {
    expect(
      resolveProviderSwitchEffort({
        efforts: EFFORTS,
        defaultEffort: 'high',
        providerEffort: 'medium',
        preferred: 'max',
        fallbackEffort: 'low',
      }),
    ).toBe('max');
  });

  it('新来源有该模型记忆 → 恢复 providerEffort', () => {
    expect(
      resolveProviderSwitchEffort({
        efforts: EFFORTS,
        defaultEffort: 'high',
        providerEffort: 'xhigh',
        fallbackEffort: 'low',
      }),
    ).toBe('xhigh');
  });

  it('【bug 回归】新来源无记忆 → 落模型默认,绝不沿用 fallback(=当前来源 activeEffort)', () => {
    // 这正是「改了 A 来源 Opus 的 effort(=fallback max),选 B 来源同名 Opus」的场景:
    // B 没记忆 → 必须落到模型默认 high,而不是继承 A 的 max。
    expect(
      resolveProviderSwitchEffort({
        efforts: EFFORTS,
        defaultEffort: 'high',
        providerEffort: undefined,
        fallbackEffort: 'max', // = A 来源当前档,绝不能被选中
      }),
    ).toBe('high');
  });

  it('providerEffort 不受目标模型支持 → 跳过,落模型默认', () => {
    expect(
      resolveProviderSwitchEffort({
        efforts: ['low', 'medium', 'high'],
        defaultEffort: 'high',
        providerEffort: 'max', // 不在 efforts
        fallbackEffort: 'low',
      }),
    ).toBe('high');
  });

  it('无记忆、defaultEffort 为 null → efforts 首档(仍不取 fallback)', () => {
    expect(
      resolveProviderSwitchEffort({
        efforts: ['medium', 'high'],
        defaultEffort: null,
        fallbackEffort: 'max',
      }),
    ).toBe('medium');
  });

  it('模型无 effort 档(efforts 为空)→ fallbackEffort(占位,UI 不显示 effort)', () => {
    expect(
      resolveProviderSwitchEffort({
        efforts: [],
        defaultEffort: null,
        fallbackEffort: 'high',
      }),
    ).toBe('high');
  });
});

describe('buildProviderSections —— 单栏按供应商分段', () => {
  // 造带 name/efforts 的最小 catalog model(buildProviderSections 读 name 做搜索 + 展示)。
  const m = (id: string, name?: string) => ({
    id,
    name: name ?? id,
    contextWindow: 200_000,
    efforts: ['low', 'high'] as Effort[],
    defaultEffort: 'high' as Effort,
  });
  /** 最小 ProviderView —— buildProviderSections 只读 provider.models[agent][].{id,name,...}。 */
  const prov = (id: string, modelDefs: Array<ReturnType<typeof m>>): ProviderView =>
    ({ id, name: id, models: { [AGENT]: modelDefs } }) as unknown as ProviderView;

  const allVisible = () => true;

  it('按供应商顺序分段,组内保留 catalog 顺序(不二次排序)', () => {
    const sections = buildProviderSections({
      providers: [
        prov('xd', [m('claude-opus-4-8', 'Opus 4.8'), m('gpt-5.5', 'GPT-5.5')]),
        prov('anthropic', [m('claude-opus-4-8', 'Opus 4.8'), m('claude-sonnet-4-6', 'Sonnet 4.6')]),
      ],
      agent: AGENT,
      isVisible: allVisible,
    });
    expect(sections.map((s) => s.provider.id)).toEqual(['xd', 'anthropic']);
    expect(sections[0].models.map((x) => x.id)).toEqual(['claude-opus-4-8', 'gpt-5.5']);
    expect(sections[1].models.map((x) => x.id)).toEqual(['claude-opus-4-8', 'claude-sonnet-4-6']);
  });

  it('同一模型被多个供应商 offer → 各供应商段各出现一次', () => {
    const sections = buildProviderSections({
      providers: [
        prov('xd', [m('claude-opus-4-8')]),
        prov('anthropic', [m('claude-opus-4-8')]),
      ],
      agent: AGENT,
      isVisible: allVisible,
    });
    expect(sections).toHaveLength(2);
    expect(sections[0].models[0].id).toBe('claude-opus-4-8');
    expect(sections[1].models[0].id).toBe('claude-opus-4-8');
  });

  it('isVisible 过滤隐藏模型;但当前选中(供应商,模型)即便隐藏也保留', () => {
    const sections = buildProviderSections({
      providers: [prov('xd', [m('claude-opus-4-8'), m('claude-sonnet-4-6')])],
      agent: AGENT,
      selectedModelId: 'claude-opus-4-8',
      selectedProviderId: 'xd',
      // 两个都"隐藏",只有选中的 opus 该保留
      isVisible: () => false,
    });
    expect(sections[0].models.map((x) => x.id)).toEqual(['claude-opus-4-8']);
  });

  it('query 命中 displayName / id(大小写不敏感)', () => {
    const providers = [prov('xd', [m('claude-opus-4-8', 'Opus 4.8'), m('gpt-5.5', 'GPT-5.5')])];
    expect(
      buildProviderSections({ providers, agent: AGENT, isVisible: allVisible, query: 'opus' })[0].models.map(
        (x) => x.id,
      ),
    ).toEqual(['claude-opus-4-8']);
    // 命中 id 前缀
    expect(
      buildProviderSections({ providers, agent: AGENT, isVisible: allVisible, query: 'gpt-5' })[0].models.map(
        (x) => x.id,
      ),
    ).toEqual(['gpt-5.5']);
  });

  it('过滤后空的供应商段被丢弃;单供应商仍返回一个段', () => {
    const sections = buildProviderSections({
      providers: [prov('xd', [m('gpt-5.5')]), prov('anthropic', [m('claude-opus-4-8')])],
      agent: AGENT,
      isVisible: allVisible,
      query: 'gpt', // anthropic 段过滤后为空
    });
    expect(sections.map((s) => s.provider.id)).toEqual(['xd']);
  });
});

describe('isSelectedSourceDisconnected — 会话显式来源断连判定', () => {
  const MODEL_ID = 'claude-opus-4-8';
  /** 最小 ProviderView —— 来源必须同时 connected、匹配 agent 且提供当前模型。 */
  const view = (id: string, connected: boolean, agents: AgentKind[] = [AGENT]): ProviderView =>
    ({
      id,
      name: id,
      connected,
      agents,
      routing: Object.fromEntries(agents.map((agent) => [agent, {}])),
      models: { [AGENT]: [{ id: MODEL_ID }] },
    }) as unknown as ProviderView;

  it('选中来源仍在已连接栏内 → false', () => {
    expect(
      isSelectedSourceDisconnected({
        providers: [view('xd', true), view('anthropic', true)],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: 'anthropic',
        providersLoading: false,
      }),
    ).toBe(false);
  });

  it('选中来源存在但 connected=false → true(订阅 OAuth 被外部清除的事故场景)', () => {
    expect(
      isSelectedSourceDisconnected({
        providers: [view('xd', true), view('anthropic', false)],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: 'anthropic',
        providersLoading: false,
      }),
    ).toBe(true);
  });

  it('选中来源在 providers 里不存在(自定义供应商被删)→ true', () => {
    expect(
      isSelectedSourceDisconnected({
        providers: [view('xd', true)],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: 'my-custom',
        providersLoading: false,
      }),
    ).toBe(true);
  });

  it('选中来源已连接但不服务当前 agent → true(agents 维度也要匹配)', () => {
    expect(
      isSelectedSourceDisconnected({
        providers: [view('openai', true, ['codex'])],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: 'openai',
        providersLoading: false,
      }),
    ).toBe(true);
  });

  it('来源已连接且服务当前 agent,但不提供当前模型 → true', () => {
    const provider = {
      ...view('openai', true),
      models: { [AGENT]: [{ id: 'chatgpt/gpt-5.5' }] },
    } as unknown as ProviderView;
    expect(
      isSelectedSourceDisconnected({
        providers: [provider],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: 'openai',
        providersLoading: false,
      }),
    ).toBe(true);
  });

  it('providersLoading 期间恒 false(避免首帧闪断开态)', () => {
    expect(
      isSelectedSourceDisconnected({
        providers: [],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: 'anthropic',
        providersLoading: true,
      }),
    ).toBe(false);
  });

  it('未显式选来源(null / undefined)或 agent 解析不出 → false', () => {
    expect(
      isSelectedSourceDisconnected({
        providers: [view('xd', true)],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: null,
        providersLoading: false,
      }),
    ).toBe(false);
    expect(
      isSelectedSourceDisconnected({
        providers: [view('xd', true)],
        agent: null,
        modelId: MODEL_ID,
        selectedProviderId: 'xd',
        providersLoading: false,
      }),
    ).toBe(false);
  });

  it('选中来源仍连着,但这个模型在它上面已经不是聊天模型 → true(issue #882 第 3 点,2026-07 review)', () => {
    const nonChatView = {
      id: 'xd',
      name: 'xd',
      connected: true,
      agents: [AGENT],
      routing: { [AGENT]: {} },
      models: { [AGENT]: [{ id: MODEL_ID, mode: 'image_generation' }] },
    } as unknown as ProviderView;
    expect(
      isSelectedSourceDisconnected({
        providers: [nonChatView],
        agent: AGENT,
        modelId: MODEL_ID,
        selectedProviderId: 'xd',
        providersLoading: false,
      }),
    ).toBe(true);
  });
});