Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

10.8 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
import * as antigravityUser from "../auth/antigravity-user.js";
import type { AntigravityServedModels } from "../auth/antigravity-user.js";
import { credentials } from "../auth/credentials/authority.js";
import * as allModelsCache from "./all-models-cache.js";
import type { DiskCacheV3, SlimModelEntry } from "./all-models-cache.js";
import { _resetCatalogClient, _setCatalogEntriesForTest } from "./catalog-client.js";
import { catalogRouteForProvider } from "./catalog-route-bindings.js";
import { providerServesModel } from "./model-availability.js";
import {
  type FetcherResult,
  discoverProviderModelsCatalog,
  getModelDiscoveryFetcher,
  invalidateModelDiscovery,
  registerModelDiscoveryFetcher,
} from "./model-discovery.js";
import "./model-discovery-builtins.js";
import { route } from "./routing-rules.js";
import { resolveAntigravityServedModel } from "./transport/antigravity.js";

// Structural inputs from ai-docs/reports/model-failures-2026-10-21.md, D8:
// the account serves the tiered id, not the requested bare family name.
const FAMILY = "gemini-3.8-flash";
const TIERED = "gemini-3.8-flash-tiered";
const MISSING = "gemini-9-flash"; // Negative input specified by the T6 brief.
const TIMEOUT = 20_000;

const realFetch = globalThis.fetch;
const realGetRequestAuth = credentials.getRequestAuth;
const realIsAvailable = credentials.isAvailable;
const realDescribeReadiness = credentials.describeReadiness;
const realDiscovery = getModelDiscoveryFetcher("antigravity");
if (!realDiscovery) throw new Error("Antigravity discovery fetcher was not registered");

let servedCache: AntigravityServedModels | null = null;
let diskCache: DiskCacheV3 | null = null;
let restoreCacheReads: () => void = () => {};
const networkFetch = mock(async () => {
  throw new Error("T6 must not fetch or contact a real account");
});

function setCatalog(entries: SlimModelEntry[]): void {
  _setCatalogEntriesForTest(entries);
  // This is an in-memory cache object, not a fabricated provider response.
  diskCache = {
    version: 3,
    lastUpdated: "2026-10-21T00:00:00.000Z",
    entries,
    models: entries.map(({ modelId }) => ({ id: modelId })),
    plans: [],
    catalogGenerationId: "T6-offline",
  };
}

function installAccount(
  servedIds: string[],
  defaultId: string | null = null,
  selectableIds = servedIds,
  populateCache = true
) {
  const cached: AntigravityServedModels = { servedIds, defaultId, meta: {} };
  const discovery = mock(async (): Promise<FetcherResult> => {
    // Discovery and the documented cache-read seam share this structural input.
    servedCache = populateCache ? cached : null;
    return { kind: "models", models: selectableIds.map((id) => ({ id })) };
  });
  registerModelDiscoveryFetcher("antigravity", discovery);
  return discovery;
}

beforeEach(() => {
  servedCache = null;
  diskCache = null;
  _resetCatalogClient();
  _setCatalogEntriesForTest([]);
  invalidateModelDiscovery();
  antigravityUser._resetAntigravityServedModelsCache();

  // Intercept disk/cache reads rather than touching ~/.claudish or auth files.
  const diskRead = spyOn(allModelsCache, "readAllModelsCache").mockImplementation(() => diskCache);
  const servedRead = spyOn(antigravityUser, "peekServedAntigravityModels").mockImplementation(
    () => servedCache
  );
  restoreCacheReads = () => {
    servedRead.mockRestore();
    diskRead.mockRestore();
  };

  credentials.getRequestAuth = mock(async () => ({ headers: {} }));
  credentials.isAvailable = async (provider: string) => provider === "antigravity";
  credentials.describeReadiness = async (provider: string) => ({
    readiness: provider === "antigravity" ? "present" : "absent",
  });
  networkFetch.mockClear();
  globalThis.fetch = networkFetch as unknown as typeof fetch;
});

afterEach(() => {
  restoreCacheReads();
  registerModelDiscoveryFetcher("antigravity", realDiscovery);
  invalidateModelDiscovery();
  antigravityUser._resetAntigravityServedModelsCache();
  _resetCatalogClient();
  credentials.getRequestAuth = realGetRequestAuth;
  credentials.isAvailable = realIsAvailable;
  credentials.describeReadiness = realDescribeReadiness;
  globalThis.fetch = realFetch;
  expect(networkFetch).not.toHaveBeenCalled();
});

describe("T6 G1 — Antigravity serves a family through its tiered variant", () => {
  test(
    "the explicit ag@ spec is available when discovery lists only the tiered id",
    async () => {
      installAccount([TIERED]);

      expect(await providerServesModel("antigravity", FAMILY)).toBe("serves");
      const plan = await route(`ag@${FAMILY}`, {}, "openrouter");

      expect(plan.kind).toBe("ok");
      if (plan.kind !== "ok") throw new Error(plan.reason);
      expect(plan.primary.provider).toBe("antigravity");
      expect(plan.primary.modelSpec).toBe(`ag@${FAMILY}`);
    },
    TIMEOUT
  );

  test(
    "the bare-name availability filter keeps the ag@ hop",
    async () => {
      installAccount([TIERED]);
      setCatalog([
        {
          modelId: FAMILY,
          aliases: [],
          aggregators: [
            {
              sourceProviderId: "antigravity",
              sourceCollectorId: "T6",
              routeStatus: "mapped",
              route: catalogRouteForProvider("antigravity"),
              externalModelId: FAMILY,
              confidence: "api_official",
            },
          ],
        },
      ]);

      const plan = await route(FAMILY, {}, "openrouter");

      expect(plan.kind).toBe("ok");
      if (plan.kind !== "ok") throw new Error(plan.reason);
      expect(plan.primary.provider).toBe("antigravity");
      expect(plan.primary.modelSpec).toBe(`ag@${FAMILY}`);
    },
    TIMEOUT
  );
});

interface ParityCase {
  name: string;
  requested: string;
  servedIds: string[];
  defaultId: string | null;
  selectableIds?: string[];
  catalogDefault?: string;
  populateCache?: boolean;
  resolvedId: string;
  verdict: "serves" | "not-served";
}

// The 2.5-pro and 3.5-flash ids also come from report D8's observed account list.
const parityCases: ParityCase[] = [
  {
    name: "exact served id",
    requested: "gemini-2.5-pro",
    servedIds: [TIERED, "gemini-2.5-pro"],
    defaultId: TIERED,
    resolvedId: "gemini-2.5-pro",
    verdict: "serves",
  },
  {
    name: "bare family with a tiered variant",
    requested: FAMILY,
    servedIds: [TIERED, "gemini-2.5-pro"],
    defaultId: "gemini-2.5-pro",
    resolvedId: TIERED,
    verdict: "serves",
  },
  {
    name: "catalog-default variant instead of the stronger tier",
    requested: "gemini-3.5-flash",
    servedIds: ["gemini-3.5-flash-low", "gemini-3.5-flash-extra-low"],
    defaultId: null,
    catalogDefault: "gemini-3.5-flash-extra-low",
    resolvedId: "gemini-3.5-flash-extra-low",
    verdict: "serves",
  },
  {
    name: "catalog-default variant is unselectable despite another selectable tier",
    requested: "gemini-3.5-flash",
    servedIds: ["gemini-3.5-flash-low", "gemini-3.5-flash-extra-low"],
    defaultId: null,
    selectableIds: ["gemini-3.5-flash-low"],
    catalogDefault: "gemini-3.5-flash-extra-low",
    resolvedId: "gemini-3.5-flash-extra-low",
    verdict: "not-served",
  },
  {
    name: "backend default is unselectable despite another selectable tier",
    requested: "gemini-3.5-flash",
    servedIds: ["gemini-3.5-flash-low", "gemini-3.5-flash-extra-low"],
    defaultId: "gemini-3.5-flash-extra-low",
    selectableIds: ["gemini-3.5-flash-low"],
    resolvedId: "gemini-3.5-flash-extra-low",
    verdict: "not-served",
  },
  {
    name: "id the account does not serve",
    requested: MISSING,
    servedIds: [TIERED, "gemini-2.5-pro"],
    defaultId: TIERED,
    resolvedId: MISSING,
    verdict: "not-served",
  },
  {
    name: "no served-models cache uses discovery ids with no backend default",
    requested: FAMILY,
    servedIds: [TIERED],
    defaultId: null,
    populateCache: false,
    resolvedId: TIERED,
    verdict: "serves",
  },
];

describe("T6 G2 — availability agrees with the transport resolver", () => {
  test.each(parityCases)(
    "$name",
    async (row) => {
      const selectableIds = row.selectableIds ?? row.servedIds;
      installAccount(row.servedIds, row.defaultId, selectableIds, row.populateCache ?? true);
      if (row.catalogDefault) {
        setCatalog([
          {
            modelId: row.catalogDefault,
            aliases: [],
            routeVariant: {
              kind: "preset",
              familyId: row.requested,
              provider: "antigravity",
              isDefault: true,
            },
          },
        ]);
      }
      await discoverProviderModelsCatalog("antigravity");
      const transportInputs =
        row.populateCache === false
          ? { servedIds: selectableIds, defaultId: null }
          : { servedIds: row.servedIds, defaultId: row.defaultId };
      const resolved = resolveAntigravityServedModel(row.requested, transportInputs);

      expect(resolved).toBe(row.resolvedId);
      const transportVerdict = selectableIds.includes(resolved) ? "serves" : "not-served";
      expect(transportVerdict).toBe(row.verdict);
      expect(await providerServesModel("antigravity", row.requested)).toBe(transportVerdict);
    },
    TIMEOUT
  );
});

describe("T6 G3 — an unserved id cannot keep an Antigravity hop", () => {
  test(
    "reports not-served when resolution finds no served id",
    async () => {
      installAccount([TIERED]);

      expect(await providerServesModel("antigravity", MISSING)).toBe("not-served");
    },
    TIMEOUT
  );

  test(
    "drops the ag@ hop from a bare-name routing chain",
    async () => {
      installAccount([TIERED]);
      const rules = { "gemini-*": ["antigravity"] };
      // The positive control proves credentials and this rule can retain ag@.
      expect((await route(FAMILY, rules, "openrouter")).kind).toBe("ok");

      const plan = await route(MISSING, rules, "openrouter");

      expect(plan.kind).toBe("no-route");
    },
    TIMEOUT
  );
});

describe("T6 G4 — availability reuses the cache discovery filled", () => {
  test(
    "adds no discovery or fetch calls after discovery has populated the cache",
    async () => {
      const discovery = installAccount([TIERED], TIERED);
      await discoverProviderModelsCatalog("antigravity");
      expect(discovery).toHaveBeenCalledTimes(1);
      expect(servedCache?.servedIds).toEqual([TIERED]);

      expect(await providerServesModel("antigravity", FAMILY)).toBe("serves");
      expect(await providerServesModel("antigravity", TIERED)).toBe("serves");
      expect(await providerServesModel("antigravity", MISSING)).toBe("not-served");
      expect((await route(`ag@${FAMILY}`, {}, "openrouter")).kind).toBe("ok");
      expect((await route(FAMILY, { "gemini-*": ["antigravity"] }, "openrouter")).kind).toBe("ok");

      expect(discovery).toHaveBeenCalledTimes(1);
      expect(networkFetch).not.toHaveBeenCalled();
    },
    TIMEOUT
  );
});