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。

13.2 KB
Raw Blame
/**
 * getDefaultModelForVendor 的种子默认取法 —— 目录排序第一的默认可见模型。
 *
 * 回归「默认模型写死在渲染层」:原先 cc 写死 `claude-opus-4-8`(目录里旗舰早已是 Opus 5),
 * codex 这里写死 `gpt-5.5` 而 newMakerDraft 写死 `gpt-5.4` —— 两个值不同,且都是目录里
 * `defaultEnabled: false` 的默认收起条目,也就是种子默认模型压根不在用户看到的清单里。
 *
 * 注意这只是**种子**:真正的落点由 calibrateDraftModel 按「可用的里面选,供应商优先订阅」
 * 决定(见 draftModelCalibration.test.ts),这里拿不到连接态与来源。
 */
import { beforeEach, describe, expect, it, vi } from 'vitest';
import type { ModelRegistry } from '@cindy/model-providers';

beforeEach(() => {
  vi.resetModules();
});

interface StubModel {
  id: string;
  displayName: string;
  contextWindow: number;
  efforts: string[];
  defaultEffort: string;
  sortOrder?: number;
  defaultEnabled?: boolean;
  /** 新对话默认种子标记(与 sortOrder 解耦)。 */
  newSessionDefault?: ('claude-code' | 'codex' | 'pi')[];
}

/** pi 也是一个 vendor;缺省的 agent 一律回落空清单。 */
type StubByAgent = Partial<Record<'claude-code' | 'codex' | 'pi', StubModel[]>>;

function model(id: string, over: Partial<StubModel> = {}): StubModel {
  return {
    id,
    displayName: id,
    contextWindow: 200_000,
    efforts: ['high'],
    defaultEffort: 'high',
    ...over,
  };
}

function stubCapabilities(byAgent: StubByAgent): void {
  const getCapabilities = vi.fn(async (kind: 'claude-code' | 'codex' | 'pi') => ({
    availableModels: byAgent[kind] ?? [],
    hasFastMode: false,
    effortLevels: [],
    permissionModes: [],
  }));
  vi.stubGlobal('window', { electronAPI: { maker: { getCapabilities } } });
}

async function loadWith(byAgent: StubByAgent) {
  stubCapabilities(byAgent);
  const caps = await import('@/hooks/useAgentCapabilities');
  const md = await import('@/lib/modelDefinitions');
  await caps.preloadAllCapabilities();
  return md;
}

describe('getDefaultModelForVendor', () => {
  it('取 sortOrder 最小的模型,而不是清单里排前面的', async () => {
    const md = await loadWith({
      'claude-code': [
        model('first-in-list', { sortOrder: 30 }),
        model('flagship', { sortOrder: 0 }),
      ],
      codex: [model('gpt-old', { sortOrder: 20 }), model('gpt-new', { sortOrder: 17 })],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('flagship');
    expect(md.getDefaultModelForVendor('codex').id).toBe('gpt-new');
  });

  it('跳过默认收起的模型 —— 用户在清单里看不到它', async () => {
    const md = await loadWith({
      'claude-code': [
        model('hidden-legacy', { sortOrder: 1, defaultEnabled: false }),
        model('visible', { sortOrder: 6 }),
      ],
      codex: [],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('visible');
  });

  it('整份清单都默认收起时退回纯排序第一,不返回空', async () => {
    const md = await loadWith({
      'claude-code': [
        model('hidden-b', { sortOrder: 9, defaultEnabled: false }),
        model('hidden-a', { sortOrder: 2, defaultEnabled: false }),
      ],
      codex: [],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('hidden-a');
  });

  it('缺 sortOrder 的条目排末尾,同序取先出现者', async () => {
    const md = await loadWith({
      'claude-code': [model('no-order'), model('ordered', { sortOrder: 40 })],
      codex: [model('tie-first', { sortOrder: 5 }), model('tie-second', { sortOrder: 5 })],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('ordered');
    expect(md.getDefaultModelForVendor('codex').id).toBe('tie-first');
  });

  it('不跨 vendor 串味', async () => {
    const md = await loadWith({
      'claude-code': [model('cc-only', { sortOrder: 50 })],
      codex: [model('codex-only', { sortOrder: 0 })],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('cc-only');
    expect(md.getDefaultModelForVendor('codex').id).toBe('codex-only');
  });

  it('不修改 capabilities 缓存的清单顺序(排序必须走副本)', async () => {
    // 展示层按 capabilities 的顺序渲染;原地 sort 会把它搅乱。
    const md = await loadWith({
      'claude-code': [model('b', { sortOrder: 9 }), model('a', { sortOrder: 0 })],
      codex: [],
    });

    md.getDefaultModelForVendor('cc');
    expect(md.getModelsForVendor('cc').map((m) => m.id)).toEqual(['b', 'a']);
  });

  it('capabilities 未加载时给冷启动占位,且与 coldStartModelIdForVendor 同源', async () => {
    stubCapabilities({ 'claude-code': [], codex: [] });
    const md = await import('@/lib/modelDefinitions');

    // 占位值必须与那个导出一致 —— 否则首帧会闪一个之后被换掉的模型名。
    expect(md.getDefaultModelForVendor('cc').id).toBe(md.coldStartModelIdForVendor('cc'));
    expect(md.getDefaultModelForVendor('codex').id).toBe(md.coldStartModelIdForVendor('codex'));
  });

  it('cc 冷启动占位的 id 与展示名必须是 bundled 目录里排序第一的可见 Claude 型号', async () => {
    // 占位不是「另一份产品默认」,只是目录还没到位时的同值影子。两者漂移就会出现首帧一个
    // 模型、清单到位后换成另一个的跳变。
    //
    // 占位沿用 Claude 型号口径;Gateway Auto 是路由别名,不能成为订阅占位。
    // 按公共型号身份限定参照,不因网关别名排到最前就改变冷启动默认。
    // codex 侧不能锁相同排序,理由见下一条。
    //
    // 展示名一起锁住:renderer 刻意不 import BUNDLED_CATALOG(会把整份目录 JSON 打进
    // bundle,为一个瞬态 label 不值得),所以 label 只能写在代码里 —— 那就由这条断言保证
    // 它不漂移,而不是靠人记得两处一起改。
    stubCapabilities({ 'claude-code': [], codex: [] });
    const { BUNDLED_CATALOG } = await import('@cindy/model-providers');
    const md = await import('@/lib/modelDefinitions');
    const first = Object.entries(bundledMeta(BUNDLED_CATALOG))
      .filter(([, v]) => v.modelRef?.startsWith('anthropic/') &&
        v.agents?.includes('claude-code') && v.defaultEnabled !== false)
      .sort(
        ([, a], [, b]) =>
          (a.sortOrder ?? Number.MAX_SAFE_INTEGER) - (b.sortOrder ?? Number.MAX_SAFE_INTEGER),
      )[0];

    expect(first).toBeDefined();
    expect(md.coldStartModelIdForVendor('cc')).toBe(first?.[0]);
    expect(md.getDefaultModelForVendor('cc').label).toBe(first?.[1].name);
  });

  it('codex 冷启动占位必须是目录里属 codex tab、默认可见、非折扣组的模型', async () => {
    // 这里刻意**不锁「排序第一」**:codex tab 的 sortOrder 有两个互相矛盾的来源 ——
    //   · ChatGPT 订阅清单来自动态发现,按上游 priority 算(Sol→17、Terra→18、Luna→19);
    //   · Cindy AI 网关清单按 registry 的静态值(Luna=17、Sol=18、Terra=19)。
    // 两套顺序对 GPT-5.6 三兄弟正好相反,于是「排序第一」会随用户连的是订阅还是网关而不同。
    // 占位按订阅口径取(校准规则优先订阅供应商),锁死目录静态序会锁成另一个模型。
    // 这个不一致本身是目录数据问题,待产品裁决后再收紧本条断言。
    stubCapabilities({ 'claude-code': [], codex: [] });
    const { BUNDLED_CATALOG } = await import('@cindy/model-providers');
    const md = await import('@/lib/modelDefinitions');
    const meta = bundledMeta(BUNDLED_CATALOG);
    const placeholder = md.coldStartModelIdForVendor('codex');
    const entry = meta[placeholder];

    expect(entry).toBeDefined();
    expect(entry?.agents).toContain('codex');
    expect(entry?.defaultEnabled).not.toBe(false);
    expect(entry?.group).not.toBe('gpt-budget');
    expect(md.getDefaultModelForVendor('codex').label).toBe(entry?.name);
  });
});

describe('newSessionDefault(专用默认种子标记)', () => {
  it('被标记的模型优先,即便 sortOrder 不是最小', async () => {
    const md = await loadWith({
      'claude-code': [
        model('flagship-by-order', { sortOrder: 0 }),
        model('deepseek', { sortOrder: 44, newSessionDefault: ['claude-code'] }),
      ],
      codex: [
        model('gpt-first', { sortOrder: 0 }),
        model('deepseek', { sortOrder: 44, newSessionDefault: ['claude-code', 'codex'] }),
      ],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('deepseek');
    expect(md.getDefaultModelForVendor('codex').id).toBe('deepseek');
    expect(md.newSessionDefaultModelId('cc')).toBe('deepseek');
    expect(md.newSessionDefaultModelId('codex')).toBe('deepseek');
  });

  it('没有任何标记时逐字节回退到「排序第一可见」', async () => {
    const md = await loadWith({
      'claude-code': [model('a', { sortOrder: 5 }), model('b', { sortOrder: 1 })],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('b');
    expect(md.newSessionDefaultModelId('cc')).toBeNull();
  });

  it('标记只对声明的 agent 生效(只标 claude-code 时 codex 不选它)', async () => {
    const md = await loadWith({
      codex: [
        model('gpt-first', { sortOrder: 0 }),
        model('cc-only-default', { sortOrder: 44, newSessionDefault: ['claude-code'] }),
      ],
    });

    expect(md.getDefaultModelForVendor('codex').id).toBe('gpt-first');
    expect(md.newSessionDefaultModelId('codex')).toBeNull();
  });

  it('被标记但默认收起(defaultEnabled:false)时不选,回退排序第一', async () => {
    const md = await loadWith({
      'claude-code': [
        model('visible', { sortOrder: 5 }),
        model('hidden-flagged', {
          sortOrder: 0,
          defaultEnabled: false,
          newSessionDefault: ['claude-code'],
        }),
      ],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('visible');
    expect(md.newSessionDefaultModelId('cc')).toBeNull();
  });

  it('多个被标记时按 sortOrder 决胜', async () => {
    const md = await loadWith({
      'claude-code': [
        model('flag-hi', { sortOrder: 40, newSessionDefault: ['claude-code'] }),
        model('flag-lo', { sortOrder: 10, newSessionDefault: ['claude-code'] }),
      ],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('flag-lo');
  });

  it('省略 sortOrder 永远排在任意有限数值之后', async () => {
    const md = await loadWith({
      'claude-code': [
        model('flag-omitted', { newSessionDefault: ['claude-code'] }),
        model('flag-large-finite', {
          sortOrder: Number.MAX_SAFE_INTEGER + 1,
          newSessionDefault: ['claude-code'],
        }),
      ],
    });

    expect(md.getDefaultModelForVendor('cc').id).toBe('flag-large-finite');
  });

  it.each([
    {
      label: '相同 sortOrder',
      models: [
        model('flag-first', { sortOrder: 10, newSessionDefault: ['claude-code'] }),
        model('flag-second', { sortOrder: 10, newSessionDefault: ['claude-code'] }),
      ],
    },
    {
      label: '都省略 sortOrder',
      models: [
        model('flag-first', { newSessionDefault: ['claude-code'] }),
        model('flag-second', { newSessionDefault: ['claude-code'] }),
      ],
    },
  ])('$label 时保留 ListModels 响应顺序', async ({ models }) => {
    const md = await loadWith({ 'claude-code': models });

    expect(md.getDefaultModelForVendor('cc').id).toBe('flag-first');
  });

  it('pi 接受 v3 自己的默认标记', async () => {
    const md = await loadWith({
      pi: [
        model('sonnet', { sortOrder: 0 }),
        model('deepseek', { sortOrder: 44, newSessionDefault: ['pi'] }),
      ],
    });

    expect(md.getDefaultModelForVendor('pi').id).toBe('deepseek');
    expect(md.newSessionDefaultModelId('pi')).toBe('deepseek');
  });

  it('pi 不借用 claude-code 的默认标记', async () => {
    const md = await loadWith({
      pi: [
        model('sonnet', { sortOrder: 0 }),
        model('opus', { sortOrder: 44, newSessionDefault: ['claude-code'] }),
      ],
    });

    expect(md.getDefaultModelForVendor('pi').id).toBe('sonnet');
    expect(md.newSessionDefaultModelId('pi')).toBeNull();
  });

  it('pi 未标记时冷启动占位是 claude-sonnet-5(不再错落到 cc 的 opus-5)', async () => {
    stubCapabilities({});
    const md = await import('@/lib/modelDefinitions');

    expect(md.coldStartModelIdForVendor('pi')).toBe('claude-sonnet-5');
    expect(md.getDefaultModelForVendor('pi').id).toBe('claude-sonnet-5');
  });
});

interface BundledMetaEntry {
  modelRef?: string;
  agents?: readonly string[];
  group?: string;
  name?: string;
  sortOrder?: number;
  defaultEnabled?: boolean;
}

function bundledMeta(catalog: { modelRegistry?: ModelRegistry }): Record<string, BundledMetaEntry> {
  const models: Record<string, BundledMetaEntry> = {};
  for (const entry of catalog.modelRegistry?.models ?? []) {
    for (const route of entry.routes) {
      if (route.providerId !== 'xd') continue;
      models[route.modelId] = {
        modelRef: entry.modelRef,
        agents: route.agents,
        group: entry.group,
        name: entry.name,
        sortOrder: entry.sortOrder,
        defaultEnabled: entry.defaultEnabled,
      };
    }
  }
  return models;
}