Skip to content

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

test(antigravity): pin id resolution in the availability check

Jack Rudenko25847d96091c
diff --git a/packages/cli/src/providers/model-availability.antigravity-resolve.test.ts b/packages/cli/src/providers/model-availability.antigravity-resolve.test.ts
new file mode 100644
index 00000000..3b113d02
--- /dev/null
+++ b/packages/cli/src/providers/model-availability.antigravity-resolve.test.ts
@@ -0,0 +1,320 @@
+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
+ );
+});