Skip to content

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

9.0 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
import { readFileSync } from "node:fs";
import { _resetAgyClientVersion } from "./auth/antigravity-client-version.js";
import * as tokenModule from "./auth/antigravity-token.js";
import type { AntigravityTokenDeps } from "./auth/antigravity-token.js";
import {
  _resetAntigravityServedModelsCache,
  resetAntigravityUserCache,
} from "./auth/antigravity-user.js";
import { credentials } from "./auth/credentials/authority.js";
import { buildDiscoveredModelOutcome } from "./model-selector.js";
import type { CatalogClient } from "./providers/model-catalog.js";
import {
  type DiscoveredModel,
  discoverProviderModelsCatalog,
  invalidateModelDiscovery,
  registerModelDiscoveryFetcher,
} from "./providers/model-discovery.js";
import type { ProviderDefinition } from "./providers/provider-definitions.js";
import { clearRuntimeRegistry, registerRuntimeProvider } from "./providers/runtime-providers.js";
import { _clearChatCapabilityIndex } from "./providers/transport/probe-discovery.js";

const capture = JSON.parse(
  readFileSync(
    new URL("./auth/fixtures/antigravity-fetchAvailableModels-1.3.5.json", import.meta.url),
    "utf8"
  )
);
const agentIds: string[] = capture.agentModelSorts[0].groups[0].modelIds;
const realFetch = globalThis.fetch;
const realGetToken = tokenModule.getValidAntigravityAccessToken;
const realGetRequestAuth = credentials.getRequestAuth;
let tokenSpy: ReturnType<typeof spyOn> | undefined;
const NOW = Date.parse("2026-10-14T00:00:00Z");
const deps: AntigravityTokenDeps = {
  readStore: () =>
    "go-keyring-base64:" +
    Buffer.from(
      JSON.stringify({
        token: {
          access_token: "offline-discovery-token",
          token_type: "Bearer",
          refresh_token: "offline-refresh",
          expiry: new Date(NOW + 3_600_000).toISOString(),
        },
      })
    ).toString("base64"),
  writeStore: () => {
    throw new Error("Unexpected token write");
  },
  deleteStore: () => {
    throw new Error("Unexpected token deletion");
  },
  runAgyRefresh: () => {
    throw new Error("Unexpected agy refresh");
  },
  readAgyVersion: () => "1.3.5",
  now: () => NOW,
};
const catalog: CatalogClient = {
  async modelsByVendor() {
    return [];
  },
  async vendorsForModel() {
    return null;
  },
  async searchModels() {
    return [];
  },
  servedByVendor() {
    return [];
  },
};

function resetState(): void {
  _resetAgyClientVersion();
  _resetAntigravityServedModelsCache();
  resetAntigravityUserCache();
  tokenModule._resetAntigravityTokenState();
  invalidateModelDiscovery();
  _clearChatCapabilityIndex();
  clearRuntimeRegistry();
}

beforeEach(() => {
  resetState();
  // Substitute only the token dependency boundary. The registered production
  // fetchAntigravityModelsCatalog still performs setup, parsing and exclusions.
  tokenSpy = spyOn(tokenModule, "getValidAntigravityAccessToken").mockImplementation(() =>
    realGetToken(deps)
  );
  credentials.getRequestAuth = mock(async () => ({
    headers: { Authorization: "Bearer offline-discovery-token" },
  }));
  globalThis.fetch = mock(async () => {
    throw new Error("Unexpected network request");
  }) as unknown as typeof fetch;
});
afterEach(() => {
  tokenSpy?.mockRestore();
  tokenSpy = undefined;
  credentials.getRequestAuth = realGetRequestAuth;
  globalThis.fetch = realFetch;
  resetState();
});

function stubAntigravityFetch() {
  const fetchStub = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
    expect(new Headers(init?.headers).get("User-Agent")).toStartWith("antigravity/cli/1.3.5 ");
    expect(new Headers(init?.headers).get("Authorization")).toBe("Bearer offline-discovery-token");
    const url = String(input);
    if (url.endsWith("/v1internal:loadCodeAssist")) {
      return Response.json({
        currentTier: "offline-tier",
        cloudaicompanionProject: "offline-project",
      });
    }
    if (url.endsWith("/v1internal:fetchAvailableModels")) {
      expect(JSON.parse(String(init?.body))).toEqual({ project: "offline-project" });
      return Response.json(capture);
    }
    throw new Error(`Unexpected endpoint: ${url}`);
  });
  globalThis.fetch = fetchStub as unknown as typeof fetch;
  return fetchStub;
}

const PROVIDER = "test-antigravity-picker-order";
const FORMAT = "test-antigravity-picker-order-format";
function discoverForPicker(models: DiscoveredModel[]): void {
  const definition: ProviderDefinition = {
    name: PROVIDER,
    displayName: "Offline picker order",
    transport: "openai",
    baseUrl: "https://picker-order.invalid",
    apiPath: "/v1/chat/completions",
    apiKeyEnvVar: "OFFLINE_PICKER_ORDER_KEY",
    apiKeyDescription: "Offline only",
    apiKeyUrl: "https://picker-order.invalid/key",
    shortcuts: [],
    legacyPrefixes: [],
    modelDiscovery: { path: "", format: FORMAT as "ollama-tags" },
    createHandler: { kind: "none", reason: "virtual", note: "Offline test" },
    isDirectApi: true,
  };
  registerRuntimeProvider(definition);
  registerModelDiscoveryFetcher(FORMAT, async () => ({
    kind: "models",
    models,
    endpoint: "https://picker-order.invalid/models",
  }));
}

describe("Antigravity discovery and picker order", () => {
  test("B9: production discovery places all 13 agy ids but retains other selectable ids for routing", async () => {
    const fetchStub = stubAntigravityFetch();
    const result = await discoverProviderModelsCatalog("antigravity");
    expect(result.kind).toBe("served");
    if (result.kind !== "served") throw new Error(JSON.stringify(result));
    expect(fetchStub).toHaveBeenCalledTimes(2);
    expect(agentIds).toHaveLength(13);
    expect(
      result.models
        .filter((m) => typeof m.providerOrder === "number")
        .map((m) => [m.id, m.providerOrder])
    ).toEqual(agentIds.map((id, index) => [id, index]));
    const older = result.models.find((m) => m.id === "gemini-2.5-pro");
    expect(older).toBeDefined();
    expect(older).not.toHaveProperty("providerOrder");
    const unplaced = result.models.filter((m) => !agentIds.includes(m.id));
    expect(unplaced.length).toBeGreaterThan(0);
    for (const model of unplaced) expect(model).not.toHaveProperty("providerOrder");
    expect(result.models.some((m) => /^(chat_|tab_)/.test(m.id))).toBe(false);
    expect(result.models.map((m) => m.id)).not.toContain("gemini-3.1-flash-image");
    // Check every captured internal id individually; an empty list cannot pass.
    for (const id of Object.keys(capture.models).filter((id) => /^(chat_|tab_)/.test(id))) {
      expect(result.models.map((m) => m.id)).not.toContain(id);
    }
  });

  test("B10: real Antigravity picker shows exactly the 13 published ids in order", async () => {
    stubAntigravityFetch();
    const result = await buildDiscoveredModelOutcome("antigravity", "Antigravity", catalog);
    expect(result.kind).toBe("rows");
    if (result.kind !== "rows") throw new Error(JSON.stringify(result));
    expect(result.rows.map((r) => r.id)).toEqual(agentIds);
    expect(result.providerOrdered).toBe(true);
    expect(result.servedCount).toBeGreaterThan(result.rows.length);
  });

  test("B10: shuffled mixed discovery uses only placed rows, ordered by providerOrder", async () => {
    discoverForPicker([
      {
        id: "offline-newest-unplaced",
        releaseDate: "2026-10-14",
        reported: "chat",
        ignoreCatalogReleaseDate: true,
      },
      {
        id: "offline-placed-second",
        providerOrder: 1,
        releaseDate: "2026-10-10",
        reported: "chat",
        ignoreCatalogReleaseDate: true,
      },
      {
        id: "offline-placed-first",
        providerOrder: 0,
        releaseDate: "2026-01-01",
        reported: "chat",
        ignoreCatalogReleaseDate: true,
      },
    ]);
    const result = await buildDiscoveredModelOutcome(PROVIDER, "Offline picker order", catalog);
    expect(result.kind).toBe("rows");
    if (result.kind !== "rows") throw new Error(JSON.stringify(result));
    expect(result.rows.map((r) => r.id)).toEqual(["offline-placed-first", "offline-placed-second"]);
    expect(result.providerOrdered).toBe(true);
  });

  test("B10: no providerOrder keeps all rows newest-first and omits providerOrdered", async () => {
    discoverForPicker([
      {
        id: "offline-old",
        releaseDate: "2026-01-01",
        reported: "chat",
        ignoreCatalogReleaseDate: true,
      },
      {
        id: "offline-new",
        releaseDate: "2026-10-14",
        reported: "chat",
        ignoreCatalogReleaseDate: true,
      },
      {
        id: "offline-middle",
        releaseDate: "2026-06-01",
        reported: "chat",
        ignoreCatalogReleaseDate: true,
      },
    ]);
    const result = await buildDiscoveredModelOutcome(PROVIDER, "Offline picker order", catalog);
    expect(result.kind).toBe("rows");
    if (result.kind !== "rows") throw new Error(JSON.stringify(result));
    expect(result.rows.map((r) => r.id)).toEqual(["offline-new", "offline-middle", "offline-old"]);
    expect(result).not.toHaveProperty("providerOrdered");
  });
});