antigravity-proxy 0.1.1

package/.dockerignore

@@ -0,0 +1,10 @@
+node_modules
+*.log
+antigravity-accounts.json
+.git
+.gitignore
+README.md
+AGENTS.md
+proxy.log
+server.log
+bun.lockb

package/.env.example

@@ -0,0 +1,2 @@
+BASE_URL=http://localhost:3000
+SAFETY_THRESHOLD=BLOCK_NONE

package/Dockerfile

@@ -0,0 +1,20 @@
+FROM oven/bun:alpine AS builder
+WORKDIR /app
+
+COPY package.json bun.lock ./
+RUN bun install --frozen-lockfile --production
+
+FROM oven/bun:alpine
+WORKDIR /app
+
+COPY --from=builder /app/node_modules ./node_modules
+COPY src ./src
+COPY package.json ./
+
+# Create a data directory for persistence and set permissions
+RUN mkdir -p /app/data && chown -R bun:bun /app/data
+
+EXPOSE 3000
+
+USER bun
+CMD ["bun", "run", "src/server.ts"]

package/README.md

@@ -0,0 +1,132 @@
+# Antigravity Proxy
+
+![Antigravity Proxy Dashboard](screenshots/screenshot.png)
+
+Antigravity Proxy is a high-performance, Bun-native gateway that exposes Google's internal Gemini and CloudCode APIs through an **OpenAI-compatible interface**. It enables seamless integration between advanced models (like Claude 3.5 Sonnet, Gemini 3, and GPT-equivalent models) and CLI agents (such as **OpenCode** or **Claude Code**), as well as any application supporting the OpenAI API standard.
+
+This project is strongly inspired by [opencode-antigravity-auth](https://github.com/NoeFabris/opencode-antigravity-auth).
+
+## Features
+
+- **OpenAI API Compatibility**: Full support for `v1/chat/completions` with streaming (SSE).
+- **Multi-Agent Support**: Specifically designed to work with **Claude Code**, **OpenCode**, and other agentic frameworks.
+- **Account Rotation & Health Scoring**: Automatically rotates multiple Google accounts, penalizing those with errors and favoring healthy ones.
+- **Quota Management**: Real-time monitoring and automatic cooldowns (backoff) on `429 Too Many Requests` errors.
+- **Dual-Pool Routing**:
+  - **CLI Pool**: Routes to production endpoints (Gemini 2.5/3 Flash & Pro).
+  - **Sandbox Pool**: Accesses internal/experimental models (Claude 3.5 Sonnet, Thinking models, GPT-equivalent).
+- **Integrated Dashboard**: Manage accounts, monitor health, and view real-time logs via a built-in web interface.
+- **Automatic Project Discovery**: Auto-detects Google Cloud Project IDs via Cloud SDK impersonation.
+
+## Deployment Options
+
+### Bunx (Recommended)
+You can run the proxy instantly using `bunx`:
+```bash
+bunx antigravity-proxy
+```
+
+### Docker Hub
+```bash
+docker run -d -p 3000:3000 -e BASE_URL=http://localhost:3000 --name antigravity-proxy frieserpaldi/antigravity-proxy:0.1.0
+```
+
+### Local Execution (Bun)
+Requirements: Bun (v1.0.0 or higher).
+```bash
+bun install
+bun run start
+```
+The server starts on port 3000.
+
+## Integration Guides
+
+### Claude Code Configuration
+To use **Claude Code** with Antigravity Proxy, point the API base URL to your local instance and specify a model from the Sandbox Pool:
+
+```bash
+# Point Claude Code to the proxy
+export CLAUDE_CODE_API_BASE="http://localhost:3000/v1"
+
+# Run Claude specifying an Antigravity model
+claude --model antigravity-claude-sonnet-4-5
+```
+
+### OpenCode Configuration
+Add the following provider to your `~/.config/opencode/opencode.json` under the `"provider"` key:
+
+```json
+"provider": {
+    "antigravity-proxy": {
+        "npm": "@ai-sdk/openai-compatible",
+        "name": "Antigravity Proxy",
+        "options": {
+            "baseURL": "http://localhost:3000/v1"
+        },
+        "models": {
+            "antigravity-gemini-3-pro-low": {
+                "name": "Gemini 3 Pro Low (Antigravity)",
+                "limit": { "context": 1048576, "output": 65535 }
+            },
+            "antigravity-gemini-3-pro-high": {
+                "name": "Gemini 3 Pro High (Antigravity)",
+                "limit": { "context": 1048576, "output": 65535 }
+            },
+            "antigravity-gemini-3-flash": {
+                "name": "Gemini 3 Flash (Antigravity)",
+                "limit": { "context": 1048576, "output": 65536 }
+            },
+            "antigravity-claude-sonnet-4-5": {
+                "name": "Claude Sonnet 4.5 (Antigravity)",
+                "limit": { "context": 200000, "output": 64000 }
+            },
+            "antigravity-claude-sonnet-4-5-thinking-low": {
+                "name": "Claude Sonnet 4.5 Think Low (Antigravity)",
+                "limit": { "context": 200000, "output": 64000 }
+            },
+            "antigravity-claude-sonnet-4-5-thinking-medium": {
+                "name": "Claude Sonnet 4.5 Think Medium (Antigravity)",
+                "limit": { "context": 200000, "output": 64000 }
+            },
+            "antigravity-claude-sonnet-4-5-thinking-high": {
+                "name": "Claude Sonnet 4.5 Think High (Antigravity)",
+                "limit": { "context": 200000, "output": 64000 }
+            },
+            "antigravity-claude-opus-4-5-thinking-low": {
+                "name": "Claude Opus 4.5 Think Low (Antigravity)",
+                "limit": { "context": 200000, "output": 64000 }
+            },
+            "antigravity-claude-opus-4-5-thinking-medium": {
+                "name": "Claude Opus 4.5 Think Medium (Antigravity)",
+                "limit": { "context": 200000, "output": 64000 }
+            },
+            "antigravity-claude-opus-4-5-thinking-high": {
+                "name": "Claude Opus 4.5 Think High (Antigravity)",
+                "limit": { "context": 200000, "output": 64000 }
+            },
+            "gemini-2.5-flash": {
+                "name": "Gemini 2.5 Flash (CLI)",
+                "limit": { "context": 1048576, "output": 65536 }
+            },
+            "gemini-2.5-pro": {
+                "name": "Gemini 2.5 Pro (CLI)",
+                "limit": { "context": 1048576, "output": 65536 }
+            }
+        }
+    }
+}
+```
+
+## How It Works
+
+Antigravity Proxy acts as a sophisticated bridge that translates OpenAI-formatted requests into Google's internal RPC protocols. It manages the complexities of authentication, session handling, and response streaming, allowing you to use high-tier models with your favorite tools.
+
+### Account Selection Strategy
+- **Hybrid (Default)**: Ranks accounts based on `(Health Score × 2) + (Idle Time × 0.1)`.
+- **Sticky**: Keeps a client session tied to the same account for consistency.
+- **Round-Robin**: Cycles through all available accounts evenly.
+
+## Security Notes
+- **Safety Filters**: Controlled via `SAFETY_THRESHOLD` (default: `BLOCK_NONE`).
+- **Credentials**: OAuth tokens are stored locally in `antigravity-accounts.json`. Do not share or commit this file.
+

package/bun.lock

@@ -0,0 +1,51 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "antigravity-llm-proxy",
+      "dependencies": {
+        "bun": "^1.0.0",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "typescript": "^5.9.3",
+      },
+    },
+  },
+  "packages": {
+    "@oven/bun-darwin-aarch64": ["@oven/bun-darwin-aarch64@1.3.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Mh78f4B+vNTOhFpI7RWHRWDqSKTnFXj/MauRx7I/GmNwEfw56sUx98gWRwXyF4lkW+9VNU+33wuw6E+M22W66w=="],
+
+    "@oven/bun-darwin-x64": ["@oven/bun-darwin-x64@1.3.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-dFfKdSVz6Ois5zjEJboUC7igcYAVd+c//ajotd0L6WUQAKQrHMVq/+6LjOj/0zjC6VPFNGWzeF8erymNo1y0Jw=="],
+
+    "@oven/bun-darwin-x64-baseline": ["@oven/bun-darwin-x64-baseline@1.3.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-bUND1aQoTCfIL+idALT7FWtuX59ltOIRo954c7p/JkESbSIJ01jY06BSNVbkGk8RQM19v/7qiqZZqi4NyO4Utw=="],
+
+    "@oven/bun-linux-aarch64": ["@oven/bun-linux-aarch64@1.3.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-m03OtzEs+/RkWtk6tBf8yw0GW4P8ajfzTXnTt984tQBgkMubGQYUyUnFasWgr3mD2820LhkVjhYeBf1rkz/biQ=="],
+
+    "@oven/bun-linux-aarch64-musl": ["@oven/bun-linux-aarch64-musl@1.3.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-QDxrROdUnC1d/uoilXtUeFHaLhYdRN7dRIzw/Iqj/vrrhnkA6VS+HYoCWtyyVvci/K+JrPmDwxOWlSRpmV4INA=="],
+
+    "@oven/bun-linux-x64": ["@oven/bun-linux-x64@1.3.7", "", { "os": "linux", "cpu": "x64" }, "sha512-uttKQ/eIRVGc4uBtLRqmQqXGf57/dmQaF0AEd37RQNRRRd1P/VYnFMiMcVaot3HJ6IFjHjGtcPO9ekT49LxBYQ=="],
+
+    "@oven/bun-linux-x64-baseline": ["@oven/bun-linux-x64-baseline@1.3.7", "", { "os": "linux", "cpu": "x64" }, "sha512-Jlb/AcrIFU3QDeR3EL4UVT1CIKqnLJDgbU+R0k/+NaSWMrBEpZV+gJJT5L1cmEKTNhU/d+c7hudxkjtqA7XXqA=="],
+
+    "@oven/bun-linux-x64-musl": ["@oven/bun-linux-x64-musl@1.3.7", "", { "os": "linux", "cpu": "x64" }, "sha512-aK8fvkCosrHRG3CNdVqMom1C8Rj3XkqZp0ZFSBXgaXlKP22RkxlEE9tS7OmSq9yVgEk6euTB3dW4NFo/jlXqeg=="],
+
+    "@oven/bun-linux-x64-musl-baseline": ["@oven/bun-linux-x64-musl-baseline@1.3.7", "", { "os": "linux", "cpu": "x64" }, "sha512-lySQQ7zJJsoa5hQH+PE5bQyQaTI8G2Erszhu4iQuDtsocwy3zSxjB6TxGWTd4HmetPl9aRvg3nb2KR8RVAd7ug=="],
+
+    "@oven/bun-windows-x64": ["@oven/bun-windows-x64@1.3.7", "", { "os": "win32", "cpu": "x64" }, "sha512-3QdIGdSn3fkssCq/vPjtPLAQxo+eMUzcwJedn1c5mXDy1AoisjhoxhWnbVl8+uk+wt9N6JUPdISoe0N4OdwXfg=="],
+
+    "@oven/bun-windows-x64-baseline": ["@oven/bun-windows-x64-baseline@1.3.7", "", { "os": "win32", "cpu": "x64" }, "sha512-wMgELfW5vFceh4qEOYb5iV5TjrjjnBJzE383ixA3kqGKzaubksSxNc11eZhS0ptcJ5a0UjN5hfbMh6sYoh+cRQ=="],
+
+    "@types/bun": ["@types/bun@1.3.7", "", { "dependencies": { "bun-types": "1.3.7" } }, "sha512-lmNuMda+Z9b7tmhA0tohwy8ZWFSnmQm1UDWXtH5r9F7wZCfkeO3Jx7wKQ1EOiKq43yHts7ky6r8SDJQWRNupkA=="],
+
+    "@types/node": ["@types/node@25.1.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-t7frlewr6+cbx+9Ohpl0NOTKXZNV9xHRmNOvql47BFJKcEG1CxtxlPEEe+gR9uhVWM4DwhnvTF110mIL4yP9RA=="],
+
+    "bun": ["bun@1.3.7", "", { "optionalDependencies": { "@oven/bun-darwin-aarch64": "1.3.7", "@oven/bun-darwin-x64": "1.3.7", "@oven/bun-darwin-x64-baseline": "1.3.7", "@oven/bun-linux-aarch64": "1.3.7", "@oven/bun-linux-aarch64-musl": "1.3.7", "@oven/bun-linux-x64": "1.3.7", "@oven/bun-linux-x64-baseline": "1.3.7", "@oven/bun-linux-x64-musl": "1.3.7", "@oven/bun-linux-x64-musl-baseline": "1.3.7", "@oven/bun-windows-x64": "1.3.7", "@oven/bun-windows-x64-baseline": "1.3.7" }, "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "bun": "bin/bun.exe", "bunx": "bin/bunx.exe" } }, "sha512-ha86NG8WiAXYR7eQw/9S+7V7Lo8KfD36XutWJNS1VndzaipWS0QIen5n3K9MT3PpP/sdGmmHjhkrU0sCM2lGGQ=="],
+
+    "bun-types": ["bun-types@1.3.7", "", { "dependencies": { "@types/node": "*" } }, "sha512-qyschsA03Qz+gou+apt6HNl6HnI+sJJLL4wLDke4iugsE6584CMupOtTY1n+2YC9nGVrEKUlTs99jjRLKgWnjQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+  }
+}

package/docker-compose.yml

@@ -0,0 +1,11 @@
+services:
+  proxy:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - ACCOUNTS_FILE=/app/data/antigravity-accounts.json
+      - BASE_URL=http://127.0.0.1:3000
+    volumes:
+      - ./data:/app/data:z
+    restart: unless-stopped

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "antigravity-proxy",
+  "version": "0.1.1",
+  "module": "index.ts",
+  "type": "module",
+  "scripts": {
+    "start": "bun run src/server.ts",
+    "dev": "bun run --watch src/server.ts",
+    "lint:check": "bun x tsc --noEmit --skipLibCheck",
+    "test": "bun test tests/unit",
+    "test:functional": "bun test tests/functional",
+    "reset-accounts": "bun run src/scripts/reset-accounts.ts",
+    "lint:html": "bun -e \"const c=await Bun.file('src/frontend/index.html').text(); try { new Function(c.match(/<script>([\\s\\S]*?)<\\/script>/)[1]) } catch(e) { console.error(e); process.exit(1) }\""
+  },
+  "dependencies": {
+    "bun": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.9.3"
+  }
+}

package/reset-accounts.ts

@@ -0,0 +1,17 @@
+import { readFileSync, writeFileSync } from 'fs';
+
+const path = './antigravity-accounts.json';
+const data = JSON.parse(readFileSync(path, 'utf8'));
+
+for (const acc of data.accounts) {
+    acc.healthScore = 100;
+    acc.consecutiveFailures = 0;
+    acc.cooldowns = {};
+    acc.modelScores = {};
+    acc.history = [];
+    acc.quota = [];
+    delete acc.challenge;
+}
+
+writeFileSync(path, JSON.stringify(data, null, 2));
+console.log("Reset all accounts successfully.");

package/src/api/quota.ts

@@ -0,0 +1,187 @@
+import { getImpersonationHeaders, generateFingerprint } from "../utils/headers";
+import { type AntigravityAccount } from "../auth/types";
+import { getAccounts, saveAccounts } from "../auth/manager";
+import { refreshAccessToken } from "../auth/oauth";
+
+export async function fetchQuota(account: AntigravityAccount, retry = true): Promise<AntigravityAccount['quota'] | null> {
+  if (!account.projectId || !account.accessToken) return null;
+  
+  if (!account.fingerprint || !account.fingerprint.clientMetadata?.sqmId) {
+    account.fingerprint = generateFingerprint(account.email);
+  }
+
+  try {
+    const res = await fetch(`https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels`, {
+      method: "POST",
+      headers: {
+        ...getImpersonationHeaders(account.accessToken, account.fingerprint),
+        "User-Agent": "antigravity",
+      },
+      body: JSON.stringify({
+        project: account.projectId
+      })
+    });
+
+    if (res.status === 401 && retry) {
+      console.log(`Quota fetch 401 for ${account.email}, refreshing token...`);
+      try {
+        const tokens = await refreshAccessToken(account.refreshToken);
+        account.accessToken = tokens.access_token;
+        account.expiresAt = Date.now() + (tokens.expires_in * 1000);
+        await saveAccounts(getAccounts());
+        return fetchQuota(account, false); // Retry once
+      } catch (e) {
+        console.error(`Failed to refresh token for ${account.email} during quota fetch`, e);
+        return null;
+      }
+    }
+
+    if (!res.ok) {
+        console.error(`Quota fetch failed for ${account.email}: ${res.status}`);
+        return null;
+    }
+
+    return parseQuotaResponse(await res.json());
+  } catch (e) {
+    console.error(`Error fetching quota for ${account.email}`, e);
+  }
+  return null;
+}
+
+function getNextMidnightPT(): string {
+    const now = new Date();
+    const ptDateStr = now.toLocaleString("en-US", { timeZone: "America/Los_Angeles" });
+    const ptDate = new Date(ptDateStr);
+    
+    const midnightPT = new Date(ptDate);
+    midnightPT.setHours(24, 0, 0, 0);
+    
+    const diffMs = midnightPT.getTime() - ptDate.getTime();
+    return new Date(now.getTime() + diffMs).toISOString();
+}
+
+export const supportedModelsCache: Set<string> = new Set();
+
+function parseQuotaResponse(data: any): AntigravityAccount['quota'] | null {
+    // Handle both array and map formats
+    let rawModels = data.availableModels || data.models || [];
+    if (!Array.isArray(rawModels) && typeof rawModels === 'object') {
+        rawModels = Object.values(rawModels);
+    }
+    
+    const groups = new Map<string, any>();
+
+    for (const m of rawModels) {
+        if (!m.quotaInfo) continue;
+
+        const label = m.displayMetadata?.label || m.displayName || m.model?.name || "Unknown";
+        const lowerLabel = label.toLowerCase();
+        
+        // Skip unknown or placeholder models
+        if (label === "Unknown" || lowerLabel === "unknown") continue;
+
+        // Cache supported model ID/Name
+        if (m.model?.name) {
+            const modelName = m.model.name.replace("models/", "");
+            supportedModelsCache.add(modelName);
+        } else if (label !== "Unknown") {
+            supportedModelsCache.add(label);
+        }
+
+        const allowedPatterns = [
+            "Claude",
+            "Anthropic",
+            "GPT",
+            "Gemini",
+            "chat",
+            "tab_flash",
+            "MODEL_PLACEHOLDER"
+        ];
+
+        const isAllowed = allowedPatterns.some(pattern => label.includes(pattern));
+        
+        if (!isAllowed) continue;
+
+        const remainingFraction = m.quotaInfo.remainingFraction ?? 0;
+        
+        const limitName = m.quotaInfo.limitName || label;
+
+        if (groups.has(limitName)) {
+            const group = groups.get(limitName);
+            // Append label if not already present
+            if (!group.labels.includes(label)) {
+                group.labels.push(label);
+                group.labels.sort();
+                group.groupName = group.labels.join(" / ");
+            }
+        } else {
+            let resetTime = m.quotaInfo.quotaResetTime || 
+                           m.quotaResetTime || 
+                           m.quotaInfo.resetTime || 
+                           m.resetTime || 
+                           m.quotaInfo.nextResetTime || 
+                           m.nextResetTime ||
+                           m.quotaInfo.quota_reset_time ||
+                           m.quota_reset_time;
+            
+            if (typeof resetTime === 'number') {
+                if (resetTime < 10000000000) resetTime *= 1000;
+                resetTime = new Date(resetTime).toISOString();
+            }
+            
+            if (typeof resetTime === 'string' && resetTime.endsWith('s') && /^\d+/.test(resetTime)) {
+                const seconds = parseInt(resetTime, 10);
+                if (!isNaN(seconds)) {
+                    resetTime = new Date(Date.now() + seconds * 1000).toISOString();
+                }
+            }
+
+            if (!resetTime || Number.isNaN(new Date(resetTime).getTime())) {
+                resetTime = getNextMidnightPT();
+            }
+
+            const diffMs = Math.max(0, new Date(resetTime).getTime() - Date.now());
+            const hours = Math.floor(diffMs / (1000 * 60 * 60));
+            const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
+            const resetIn = `${hours}h ${minutes}m`;
+            const pct = Math.round(remainingFraction * 100);
+            const quotaLeft = `${pct}%`;
+
+            groups.set(limitName, {
+                groupName: label,
+                labels: [label], 
+                limit: m.quotaInfo.quotaLimit || "Unknown",
+                usage: m.quotaInfo.quotaUsage || "Unknown",
+                limitName: limitName,
+                remainingFraction: remainingFraction,
+                resetTime: resetTime,
+                quotaLeft,
+                resetIn
+            });
+        }
+    }
+
+    const results = Array.from(groups.values()).map(g => {
+        const { labels, ...rest } = g; 
+        return rest;
+    });
+
+    // Sort by name for consistency
+    results.sort((a, b) => a.groupName.localeCompare(b.groupName));
+
+    return results.length > 0 ? results : null;
+}
+
+export async function refreshAllQuotas() {
+    const accounts = getAccounts();
+    
+    await Promise.all(accounts.map(async (acc) => {
+        if (acc.projectId) { 
+            const quota = await fetchQuota(acc);
+            if (quota) {
+                acc.quota = quota;
+                await saveAccounts(getAccounts());
+            }
+        }
+    }));
+}