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.tsnew file mode 100644index 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+ );+});