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。

8.8 KB
Raw Blame
import { describe, expect, it } from "vitest";
import { BUNDLED_CATALOG, type ModelRegistry } from "../index.js";
import { parseModelRegistry } from "../modelAccessValidator.js";
import { resolveCatalogModelNativeApi, resolveModelNativeApi } from "../modelRegistry.js";

const registry = (): ModelRegistry => ({
  schemaVersion: 3,
  updatedAt: "2026-09-05T00:00:00.000Z",
  models: [],
  nativeApiRules: [
    {
      providerId: "xd",
      modelIdPrefix: "google/gemini-",
      nativeApi: "google-generative-ai",
    },
  ],
});

describe('native declarations for verified catalog identities', () => {
  it.each([
    ['google/gemini-3.8-flash', 'google-generative-ai'],
    ['gemini-3.8-flash', 'google-generative-ai'],
    ['anthropic/claude-fable-5', 'anthropic-messages'],
    ['claude-fable-5', 'anthropic-messages'],
    ['openai/gpt-6-astra', 'openai-responses'],
    ['gpt-6-astra', 'openai-responses'],
    ['qwen3.7-plus', 'openai-completions'],
    ['deepseek-v4.1-flash', 'openai-completions'],
  ])('reuses maintained model declarations for %s', (id, api) => {
    expect(resolveCatalogModelNativeApi(BUNDLED_CATALOG.modelRegistry, id)).toBe(api);
  });
  it.each(['unknown/gemini-99', 'google/gemini-99/other', 'aion-labs/aion-3.0-mini'])('does not guess undeclared names or namespaces: %s', id => {
    expect(resolveCatalogModelNativeApi(registry(), id)).toBeUndefined();
  });
  it('keeps explicit unknown, retirement and conflicting declarations ahead of family defaults', () => {
    const r = registry();
    r.models = [{ id: 'google/gemini-99', name: 'Gemini', nativeApi: null, routes: [] }];
    expect(resolveCatalogModelNativeApi(r, 'google/gemini-99')).toBeNull();
    r.models[0].nativeApi = 'google-generative-ai';
    r.models[0].status = 'retired';
    expect(resolveCatalogModelNativeApi(r, 'google/gemini-99')).toBeNull();
    delete r.models[0].status;
    r.models.push({ ...r.models[0], nativeApi: 'openai-responses' });
    expect(resolveCatalogModelNativeApi(r, 'google/gemini-99')).toBeNull();
  });
  it('does not let a retired sibling suppress the active catalog identity', () => {
    const r = registry();
    r.baseModels = [{ id: 'gemini-99', defaults: { name: 'Gemini 99' }, aliases: [] }];
    r.models = [
      { id: 'google/gemini-99', name: 'Gemini', modelRef: 'gemini-99', nativeApi: 'google-generative-ai', routes: [] },
      { id: 'google/gemini-99-preview', name: 'Gemini preview', modelRef: 'gemini-99', status: 'retired', nativeApi: 'google-generative-ai', routes: [] },
    ];
    expect(resolveCatalogModelNativeApi(r, 'google/gemini-99')).toBe('google-generative-ai');
    expect(resolveCatalogModelNativeApi(r, 'google/gemini-99-preview')).toBeNull();
  });
  it('does not let a native declaration manufacture endpoint or capability data', () => {
    const r = registry();
    expect(resolveCatalogModelNativeApi(r, 'gemini-99')).toBe('google-generative-ai');
    expect(r.models).toEqual([]);
    expect(resolveModelNativeApi(r, 'custom-account', 'gemini-99')).toBeUndefined();
    expect(resolveCatalogModelNativeApi({ ...r, schemaVersion: 2 }, 'gemini-99')).toBeUndefined();
  });
});

describe("canonical model APIs in registry v3", () => {
  it("covers every maintained model route without relying on Pi runtime data", () => {
    const bundled = BUNDLED_CATALOG.modelRegistry!;
    for (const entry of bundled.models) {
      if (entry.status === "retired") continue;
      expect(entry.nativeApi, entry.id).toBeTruthy();
      for (const route of entry.routes) {
        expect(
          resolveModelNativeApi(bundled, route.providerId, route.modelId),
          `${route.providerId}/${route.modelId}`,
        ).toBe(entry.nativeApi);
      }
    }
    expect(
      resolveModelNativeApi(bundled, "xd", "bytedance-seed/seed-2.1-pro"),
    ).toBe("openai-completions");
    for (const id of [
      "gpt-5.3-codex-spark",
      "chatgpt/gpt-5.3-codex-spark",
      "gpt-99-new",
    ]) {
      expect(resolveModelNativeApi(bundled, "openai", id)).toBe(
        "openai-responses",
      );
    }
  });

  it("shares canonical metadata across owned subscription wire aliases only", () => {
    for (const id of ["gpt-6-astra", "chatgpt/gpt-6-astra"]) {
      expect(
        resolveModelNativeApi(BUNDLED_CATALOG.modelRegistry, "openai", id),
      ).toBe("openai-responses");
    }
    for (const id of ["grok-4.6", "xai/grok-4.6"]) {
      expect(
        resolveModelNativeApi(BUNDLED_CATALOG.modelRegistry, "xai", id),
      ).toBe("openai-responses");
    }
    expect(
      resolveModelNativeApi(
        BUNDLED_CATALOG.modelRegistry,
        "unrelated",
        "chatgpt/gpt-6-astra",
      ),
    ).toBeUndefined();
  });

  it.each([
    ["deepseek/deepseek-v99-pro", "openai-completions"],
    ["bytedance-seed/seed-99-pro", "openai-completions"],
    ["qwen/qwen99-flash", "openai-completions"],
    ["moonshotai/kimi-k99", "openai-completions"],
    ["z-ai/glm-99", "openai-completions"],
    ["tencent/hy99-preview", "openai-completions"],
    ["meta/muse-spark-99", "openai-responses"],
    ["meta/muse-wonder-99", "openai-responses"],
    ["x-ai/grok-99", "openai-responses"],
    ["minimax/MiniMax-M99", "anthropic-messages"],
    ["openai-codex/gpt-99", "openai-responses"],
    ["codex/gpt-99", "openai-responses"],
  ])(
    "declares the native API of future family member %s locally",
    (id, api) => {
      expect(
        resolveModelNativeApi(BUNDLED_CATALOG.modelRegistry, "xd", id),
      ).toBe(api);
      expect(
        resolveModelNativeApi(BUNDLED_CATALOG.modelRegistry, "unrelated", id),
      ).toBeUndefined();
      expect(
        resolveModelNativeApi(
          BUNDLED_CATALOG.modelRegistry,
          "xd",
          `${id}/other`,
        ),
      ).toBeUndefined();
    },
  );

  it("preserves legacy retirement even when the catalog cannot declare native APIs", () => {
    const r: ModelRegistry = {
      schemaVersion: 2,
      updatedAt: registry().updatedAt,
      models: [
        {
          id: "g",
          name: "G",
          status: "retired",
          routes: [
            {
              providerId: "xd",
              modelId: "google/gemini-99",
              agents: ["codex"],
            },
          ],
        },
      ],
    };
    expect(resolveModelNativeApi(r, "xd", "google/gemini-99")).toBeNull();
  });

  it("validates the complete bundled snapshot and keeps legacy versions readable", () => {
    expect(parseModelRegistry(BUNDLED_CATALOG.modelRegistry).ok).toBe(true);
    for (const schemaVersion of [1, 2])
      expect(
        parseModelRegistry({
          schemaVersion,
          updatedAt: registry().updatedAt,
          models: [],
        }).ok,
      ).toBe(true);
    expect(parseModelRegistry({ ...registry(), schemaVersion: 2 }).ok).toBe(
      false,
    );
    expect(
      parseModelRegistry({
        ...registry(),
        nativeApiRules: [
          {
            providerId: "xd",
            modelIdPrefix: "",
            nativeApi: "google-generative-ai",
          },
        ],
      }).ok,
    ).toBe(false);
    expect(
      parseModelRegistry({
        ...registry(),
        nativeApiRules: [
          ...registry().nativeApiRules!,
          ...registry().nativeApiRules!,
        ],
      }).ok,
    ).toBe(false);
  });
  it("resolves new models by route-scoped rule without inventing other provider identities", () => {
    expect(
      resolveModelNativeApi(registry(), "xd", "google/gemini-99-pro[1m]"),
    ).toBe("google-generative-ai");
    expect(
      resolveModelNativeApi(registry(), "other", "google/gemini-99-pro"),
    ).toBeUndefined();
    expect(
      resolveModelNativeApi(registry(), "xd", "google/gemini-99/other"),
    ).toBeUndefined();
  });
  it("honors an exact correction, explicit unknown, and retirement before family defaults", () => {
    const r = registry();
    r.models = [
      {
        id: "google/new",
        name: "New",
        nativeApi: "openai-responses",
        routes: [
          { providerId: "xd", modelId: "google/gemini-new", agents: ["codex"] },
        ],
      },
    ];
    expect(parseModelRegistry(r).ok).toBe(true);
    expect(resolveModelNativeApi(r, "xd", "google/gemini-new")).toBe(
      "openai-responses",
    );
    r.models[0].nativeApi = null;
    expect(resolveModelNativeApi(r, "xd", "google/gemini-new")).toBeNull();
    delete r.models[0].nativeApi;
    r.models[0].status = "retired";
    expect(resolveModelNativeApi(r, "xd", "google/gemini-new")).toBeNull();
  });
  it("rejects unrecognized protocol values instead of silently using a compatibility route", () => {
    const r = registry();
    expect(
      parseModelRegistry({
        ...r,
        nativeApiRules: [{ ...r.nativeApiRules![0], nativeApi: "future-api" }],
      }).ok,
    ).toBe(false);
    expect(
      parseModelRegistry({
        ...r,
        models: [{ id: "m", name: "M", routes: [], nativeApi: "future-api" }],
      }).ok,
    ).toBe(false);
  });
});