Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
fix(antigravity): bootstrap project via loadCodeAssist + fetchAvailableModels fallback (#2219)
Antonbbdcb97a06c7
diff --git a/open-sse/services/antigravityProjectBootstrap.ts b/open-sse/services/antigravityProjectBootstrap.tsnew file mode 100644index 0000000000..ce045461a0--- /dev/null+++ b/open-sse/services/antigravityProjectBootstrap.ts@@ -0,0 +1,125 @@+/**+ * Antigravity project bootstrap — loadCodeAssist.+ *+ * The Google Cloud Code Assist API (/v1internal:models) requires a prior+ * /v1internal:loadCodeAssist call to assign a project context to the+ * OAuth token. Without this bootstrap, :models returns 404.+ *+ * This module provides an idempotent ensureAntigravityProjectAssigned()+ * helper that is called once per access-token before every discovery+ * attempt. Results are memoized per-token for the process lifetime to+ * avoid redundant round-trips.+ *+ * Based on AntigravityService.loadCodeAssist() in+ * src/lib/oauth/services/antigravity.ts and the CLIProxyAPI reference+ * implementation in internal/runtime/executor/antigravity_executor.go.+ */++import {+ getAntigravityHeaders,+ getAntigravityLoadCodeAssistMetadata,+} from "./antigravityHeaders.ts";+import { ANTIGRAVITY_BASE_URLS } from "../config/antigravityUpstream.ts";++const LOAD_CODE_ASSIST_PATH = "/v1internal:loadCodeAssist";+const BOOTSTRAP_TIMEOUT_MS = 8_000;++/** Ordered list of loadCodeAssist endpoint URLs (mirrors the models discovery order). */+export function getAntigravityLoadCodeAssistUrls(): string[] {+ return ANTIGRAVITY_BASE_URLS.map((base) => `${base}${LOAD_CODE_ASSIST_PATH}`);+}++/** Per-token memoization cache (lives for the process lifetime). */+const projectCache = new Map<string, string>();++type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;++/**+ * Attempt loadCodeAssist against each known base URL in order.+ * Returns the discovered project id, or null if all endpoints fail.+ */+async function tryLoadCodeAssist(+ accessToken: string,+ fetchImpl: FetchLike+): Promise<string | null> {+ const urls = getAntigravityLoadCodeAssistUrls();+ for (const url of urls) {+ try {+ const response = await fetchImpl(url, {+ method: "POST",+ headers: getAntigravityHeaders("loadCodeAssist", accessToken),+ body: JSON.stringify({ metadata: getAntigravityLoadCodeAssistMetadata() }),+ signal: AbortSignal.timeout(BOOTSTRAP_TIMEOUT_MS),+ });++ if (!response.ok) {+ console.warn(+ `[models] antigravity loadCodeAssist failed at ${url} (${response.status}) — trying next`+ );+ continue;+ }++ const data = (await response.json()) as Record<string, unknown>;++ // cloudaicompanionProject may be a plain string or an object with an id field.+ const raw = data.cloudaicompanionProject;+ let projectId =+ typeof raw === "string"+ ? raw.trim()+ : raw &&+ typeof raw === "object" &&+ typeof (raw as Record<string, unknown>).id === "string"+ ? ((raw as Record<string, unknown>).id as string).trim()+ : "";++ if (projectId) {+ return projectId;+ }++ console.warn(+ `[models] antigravity loadCodeAssist at ${url} returned no project id — trying next`+ );+ } catch (error) {+ const msg = error instanceof Error ? error.message : String(error);+ console.warn(`[models] antigravity loadCodeAssist threw for ${url}: ${msg} — trying next`);+ }+ }+ return null;+}++/**+ * Ensure a project is assigned to the given access token by calling+ * loadCodeAssist if not already cached. Idempotent — repeated calls+ * for the same token return the cached result without a network round-trip.+ *+ * Failures are non-fatal: the caller should proceed with the :models+ * request regardless (the stored project_id in the DB may still be valid).+ *+ * @param accessToken The OAuth bearer token for the current connection.+ * @param fetchImpl Injected fetch implementation (defaults to globalThis.fetch).+ */+export async function ensureAntigravityProjectAssigned(+ accessToken: string,+ fetchImpl: FetchLike = fetch+): Promise<void> {+ if (projectCache.has(accessToken)) {+ return; // already bootstrapped for this token+ }++ const projectId = await tryLoadCodeAssist(accessToken, fetchImpl);++ if (projectId) {+ projectCache.set(accessToken, projectId);+ }+ // Non-fatal: if all endpoints failed, we proceed without caching.+}++/** Exported for tests. */+export function clearAntigravityProjectCache(): void {+ projectCache.clear();+}++/** Exported for tests — inspect cache state. */+export function getAntigravityProjectFromCache(accessToken: string): string | undefined {+ return projectCache.get(accessToken);+}diff --git a/src/app/api/providers/[id]/models/route.ts b/src/app/api/providers/[id]/models/route.tsindex 71dd9583ef..d86c6daaca 100755--- a/src/app/api/providers/[id]/models/route.ts+++ b/src/app/api/providers/[id]/models/route.ts@@ -21,7 +21,11 @@ import {import { getProviderOutboundGuard } from "@/shared/network/outboundUrlGuard";import { getStaticQoderModels } from "@omniroute/open-sse/services/qoderCli.ts";import { getAntigravityHeaders } from "@omniroute/open-sse/services/antigravityHeaders.ts";-import { getAntigravityModelsDiscoveryUrls } from "@omniroute/open-sse/config/antigravityUpstream.ts";+import { ensureAntigravityProjectAssigned } from "@omniroute/open-sse/services/antigravityProjectBootstrap.ts";+import {+ getAntigravityModelsDiscoveryUrls,+ getAntigravityFetchAvailableModelsUrls,+} from "@omniroute/open-sse/config/antigravityUpstream.ts";import {buildGlmCodingHeaders,buildGlmModelsUrl,@@ -229,8 +233,12 @@ async function fetchAntigravityDiscoveryModelsCached(const promise = (async () => {await resolveAntigravityVersion();+ await ensureAntigravityProjectAssigned(accessToken);- for (const discoveryUrl of getAntigravityModelsDiscoveryUrls()) {+ for (const discoveryUrl of [+ ...getAntigravityFetchAvailableModelsUrls(),+ ...getAntigravityModelsDiscoveryUrls(),+ ]) {try {const response = await safeOutboundFetch(discoveryUrl, {...SAFE_OUTBOUND_FETCH_PRESETS.modelsDiscovery,diff --git a/tests/unit/antigravity-discovery-bootstrap.test.ts b/tests/unit/antigravity-discovery-bootstrap.test.tsnew file mode 100644index 0000000000..6128eec2e2--- /dev/null+++ b/tests/unit/antigravity-discovery-bootstrap.test.ts@@ -0,0 +1,204 @@+/**+ * Tests: antigravity loadCodeAssist bootstrap before :models discovery.+ *+ * The Google Cloud Code Assist /v1internal:models endpoint requires a prior+ * /v1internal:loadCodeAssist call to assign a project context to the OAuth+ * token. Without this bootstrap, :models returns 404 for all three base URLs.+ *+ * These tests verify:+ * 1. ensureAntigravityProjectAssigned calls loadCodeAssist before returning.+ * 2. The call is memoized — repeated calls for the same token do not re-hit+ * the network.+ * 3. Non-fatal: if loadCodeAssist fails, the function resolves without throwing.+ * 4. The loadCodeAssist request uses the correct headers (Authorization, User-Agent).+ * 5. Ordering guarantee — in a full discovery flow, loadCodeAssist is called+ * BEFORE any :models request.+ */++import { test, describe, beforeEach } from "node:test";+import assert from "node:assert/strict";++import {+ ensureAntigravityProjectAssigned,+ clearAntigravityProjectCache,+ getAntigravityProjectFromCache,+ getAntigravityLoadCodeAssistUrls,+} from "../../open-sse/services/antigravityProjectBootstrap.ts";++// Reset the module-level memoization cache between tests.+beforeEach(() => {+ clearAntigravityProjectCache();+});++describe("ensureAntigravityProjectAssigned", () => {+ test("calls loadCodeAssist and caches the returned project id", async () => {+ const calls: string[] = [];++ const mockFetch = async (url: string, _init?: RequestInit): Promise<Response> => {+ calls.push(url);+ if (url.endsWith(":loadCodeAssist")) {+ return new Response(JSON.stringify({ cloudaicompanionProject: "proj-from-bootstrap" }), {+ status: 200,+ headers: { "Content-Type": "application/json" },+ });+ }+ return new Response("Not Found", { status: 404 });+ };++ await ensureAntigravityProjectAssigned("fake-token-1", mockFetch);++ const loadCalls = calls.filter((u) => u.endsWith(":loadCodeAssist"));+ assert.ok(loadCalls.length >= 1, ":loadCodeAssist must be called at least once");++ const cached = getAntigravityProjectFromCache("fake-token-1");+ assert.equal(cached, "proj-from-bootstrap", "project id must be memoized after first call");+ });++ test("subsequent calls for the same token skip the network", async () => {+ let networkCalls = 0;++ const mockFetch = async (url: string, _init?: RequestInit): Promise<Response> => {+ networkCalls += 1;+ return new Response(JSON.stringify({ cloudaicompanionProject: "proj-cached" }), {+ status: 200,+ headers: { "Content-Type": "application/json" },+ });+ };++ await ensureAntigravityProjectAssigned("fake-token-2", mockFetch);+ await ensureAntigravityProjectAssigned("fake-token-2", mockFetch);+ await ensureAntigravityProjectAssigned("fake-token-2", mockFetch);++ assert.equal(networkCalls, 1, "network must be called exactly once for the same token");+ });++ test("different tokens each trigger their own loadCodeAssist call", async () => {+ const calledFor: string[] = [];++ const mockFetch = async (url: string, init?: RequestInit): Promise<Response> => {+ const auth = new Headers(init?.headers).get("Authorization") ?? "";+ calledFor.push(auth);+ return new Response(JSON.stringify({ cloudaicompanionProject: "proj-x" }), {+ status: 200,+ headers: { "Content-Type": "application/json" },+ });+ };++ await ensureAntigravityProjectAssigned("token-A", mockFetch);+ await ensureAntigravityProjectAssigned("token-B", mockFetch);++ assert.equal(calledFor.length, 2, "each unique token should trigger one network call");+ });++ test("does not throw when loadCodeAssist returns non-200", async () => {+ const mockFetch = async (_url: string, _init?: RequestInit): Promise<Response> => {+ return new Response("Service Unavailable", { status: 503 });+ };++ // Must resolve without throwing even if all endpoints fail.+ await assert.doesNotReject(ensureAntigravityProjectAssigned("fail-token", mockFetch));+ });++ test("does not throw when fetch rejects (network error)", async () => {+ const mockFetch = async (_url: string, _init?: RequestInit): Promise<Response> => {+ throw new Error("ECONNREFUSED");+ };++ await assert.doesNotReject(ensureAntigravityProjectAssigned("throw-token", mockFetch));+ });++ test("sets Authorization header with Bearer token", async () => {+ let capturedAuth: string | null = null;++ const mockFetch = async (_url: string, init?: RequestInit): Promise<Response> => {+ capturedAuth = new Headers(init?.headers).get("Authorization") ?? null;+ return new Response(JSON.stringify({ cloudaicompanionProject: "proj-auth-check" }), {+ status: 200,+ headers: { "Content-Type": "application/json" },+ });+ };++ await ensureAntigravityProjectAssigned("my-secret-token", mockFetch);++ assert.equal(capturedAuth, "Bearer my-secret-token", "Authorization header must be set");+ });++ test("falls through to next URL when first loadCodeAssist returns 404", async () => {+ const hitUrls: string[] = [];++ const mockFetch = async (url: string, _init?: RequestInit): Promise<Response> => {+ hitUrls.push(url);+ if (url.includes("sandbox")) {+ // First URL fails+ return new Response("not found", { status: 404 });+ }+ // Second URL succeeds+ return new Response(JSON.stringify({ cloudaicompanionProject: "proj-fallback" }), {+ status: 200,+ headers: { "Content-Type": "application/json" },+ });+ };++ await ensureAntigravityProjectAssigned("fallback-token", mockFetch);++ assert.ok(hitUrls.length >= 2, "should try at least two URLs on the first failure");+ const cached = getAntigravityProjectFromCache("fallback-token");+ assert.equal(cached, "proj-fallback", "should cache the project from the successful URL");+ });++ test("getAntigravityLoadCodeAssistUrls returns URLs matching ANTIGRAVITY_BASE_URLS", () => {+ const urls = getAntigravityLoadCodeAssistUrls();+ assert.ok(urls.length >= 1, "must return at least one URL");+ for (const url of urls) {+ assert.ok(url.endsWith(":loadCodeAssist"), `URL must end with :loadCodeAssist, got: ${url}`);+ assert.ok(url.startsWith("https://"), `URL must be HTTPS, got: ${url}`);+ }+ });+});++// ── Ordering guarantee: loadCodeAssist BEFORE :models ─────────────────────────+//+// This test simulates the full discovery flow: a test-controlled fetch+// that records call order, and verifies that :loadCodeAssist precedes+// any :models request. The integration is verified by calling+// ensureAntigravityProjectAssigned then simulating a :models request.++describe("ordering guarantee: loadCodeAssist before :models", () => {+ test("loadCodeAssist is called before :models in a simulated discovery flow", async () => {+ const callOrder: string[] = [];++ const mockFetch = async (url: string, _init?: RequestInit): Promise<Response> => {+ if (url.endsWith(":loadCodeAssist")) {+ callOrder.push("loadCodeAssist");+ return new Response(JSON.stringify({ cloudaicompanionProject: "proj-order-test" }), {+ status: 200,+ headers: { "Content-Type": "application/json" },+ });+ }+ if (url.endsWith(":models")) {+ callOrder.push("models");+ return new Response(+ JSON.stringify({+ models: [{ id: "gemini-3-pro-antigravity", displayName: "Gemini 3 Pro" }],+ }),+ { status: 200, headers: { "Content-Type": "application/json" } }+ );+ }+ return new Response("not found", { status: 404 });+ };++ // Step 1: bootstrap project (what route.ts now does before the models loop).+ await ensureAntigravityProjectAssigned("order-token", mockFetch);++ // Step 2: simulate a :models discovery request (what the loop does).+ const modelsUrl = "https://cloudcode-pa.googleapis.com/v1internal:models";+ await mockFetch(modelsUrl);++ const loadIdx = callOrder.indexOf("loadCodeAssist");+ const modelsIdx = callOrder.indexOf("models");++ assert.ok(loadIdx >= 0, ":loadCodeAssist must be called");+ assert.ok(modelsIdx >= 0, ":models must be called");+ assert.ok(loadIdx < modelsIdx, ":loadCodeAssist must be called BEFORE :models");+ });+});