antigravity-claude-proxy 2.8.6 → 2.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "2.8.6",
+  "version": "2.9.0",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",
@@ -37,7 +37,8 @@
     "test:emptyretry": "node tests/test-empty-response-retry.cjs",
     "test:sanitizer": "node tests/test-schema-sanitizer.cjs",
     "test:strategies": "node tests/test-strategies.cjs",
-    "test:cache-control": "node tests/test-cache-control.cjs"
+    "test:cache-control": "node tests/test-cache-control.cjs",
+    "test:billing-header": "node tests/test-billing-header.cjs"
   },
   "keywords": [
     "claude",

package/public/views/logs.html

@@ -89,7 +89,8 @@
 
                 <!-- Message: Clean & High Contrast -->
                 <span class="text-zinc-300 break-all group-hover:text-white transition-colors flex-1"
-                    x-html="Redact.logMessage(log.message).replace(/\n/g, '<br>')"></span>
+                    style="white-space: pre-wrap"
+                    x-text="Redact.logMessage(log.message)"></span>
             </div>
         </template>
         <!-- Blinking Cursor -->

package/src/cloudcode/model-api.js

@@ -15,6 +15,7 @@ import {
 } from '../constants.js';
 import { logger } from '../utils/logger.js';
 import { throttledFetch } from '../utils/helpers.js';
+import { recordModels } from './model-registry.js';
 
 // Model validation cache
 const modelCache = {
@@ -24,7 +25,7 @@ const modelCache = {
 };
 
 /**
- * Check if a model is supported (Claude or Gemini)
+ * Check if a model is supported (Claude or Gemini, by name or backend provider)
  * @param {string} modelId - Model ID to check
  * @returns {boolean} True if model is supported
  */
@@ -50,6 +51,17 @@ function isOldGemini(modelId) {
     return !!match && parseFloat(match[1]) < 3.5;
 }
 
+/**
+ * Whether a model id is a backend placeholder for a model the account can't
+ * use (e.g. 'gemini-4-argon-disabled' on free-tier accounts), hidden from the
+ * /v1/models listing since requests to it can't succeed.
+ * @param {string} modelId
+ * @returns {boolean}
+ */
+function isDisabledPlaceholder(modelId) {
+    return modelId.endsWith('-disabled');
+}
+
 /**
  * List available models in Anthropic API format
  * Fetches models dynamically from the Cloud Code API
@@ -63,6 +75,7 @@ export async function listModels(token) {
         return { object: 'list', data: [] };
     }
 
+    recordModels(data);
     const supportedEntries = Object.entries(data.models).filter(([modelId]) => isSupportedModel(modelId));
 
     // Warm the model validation cache with every supported id, unfiltered -
@@ -73,7 +86,7 @@ export async function listModels(token) {
     modelCache.lastFetched = Date.now();
 
     const modelList = supportedEntries
-        .filter(([modelId]) => !isOldGemini(modelId))
+        .filter(([modelId]) => !isOldGemini(modelId) && !isDisabledPlaceholder(modelId))
         .map(([modelId, modelData]) => ({
             id: modelId,
             object: 'model',
@@ -148,6 +161,7 @@ export async function fetchAvailableModels(token, projectId = null) {
 export async function getModelQuotas(token, projectId = null) {
     const data = await fetchAvailableModels(token, projectId);
     if (!data || !data.models) return {};
+    recordModels(data);
 
     const quotas = {};
     for (const [modelId, modelData] of Object.entries(data.models)) {
@@ -319,6 +333,7 @@ async function populateModelCache(token, projectId = null) {
         try {
             const data = await fetchAvailableModels(token, projectId);
             if (data && data.models) {
+                recordModels(data);
                 const validIds = Object.keys(data.models).filter(modelId => isSupportedModel(modelId));
                 modelCache.validModels = new Set(validIds);
                 modelCache.lastFetched = Date.now();

package/src/cloudcode/model-registry.js

@@ -0,0 +1,96 @@
+/**
+ * Model Registry
+ *
+ * Records per-model metadata from Cloud Code's fetchAvailableModels response so
+ * model family / thinking support can be resolved from what the backend reports
+ * (apiProvider, supportsThinking) when the model id itself doesn't say - e.g. a
+ * new model shipped under a codename without "gemini" or "claude" in its id.
+ *
+ * Deliberately has no imports: constants.js reads from it, and model-api.js
+ * (which imports constants.js) writes to it.
+ */
+
+const registry = new Map();
+
+/**
+ * Map a Cloud Code apiProvider value to a model family.
+ * @param {string} apiProvider - e.g. 'API_PROVIDER_GOOGLE_GEMINI'
+ * @returns {'claude' | 'gemini' | null}
+ */
+function familyFromProvider(apiProvider) {
+    const provider = String(apiProvider || '').toUpperCase();
+    if (provider.includes('GOOGLE_GEMINI')) return 'gemini';
+    if (provider.includes('ANTHROPIC')) return 'claude';
+    return null;
+}
+
+/**
+ * Collect the ids the backend offers as selectable agent models
+ * (agentModelSorts groups and tieredModelIds). Internal/tab-completion
+ * models (tab_*, chat_*) never appear in these lists.
+ * @param {Object} data - fetchAvailableModels response
+ * @returns {Set<string>}
+ */
+function collectAgentModelIds(data) {
+    const ids = new Set();
+    for (const sort of data?.agentModelSorts || []) {
+        for (const group of sort?.groups || []) {
+            for (const id of group?.modelIds || []) ids.add(id);
+        }
+    }
+    for (const list of Object.values(data?.tieredModelIds || {})) {
+        if (Array.isArray(list)) list.forEach(id => ids.add(id));
+    }
+    return ids;
+}
+
+/**
+ * Whether the model id names its family itself (legacy name-based detection).
+ * @param {string} modelId
+ * @returns {boolean}
+ */
+function hasFamilyInName(modelId) {
+    const lower = (modelId || '').toLowerCase();
+    return lower.includes('claude') || lower.includes('gemini');
+}
+
+/**
+ * Record model metadata from a fetchAvailableModels response.
+ * Ids whose name already identifies the family are always recorded; other ids
+ * only when the backend lists them as agent models with a Gemini/Anthropic
+ * provider, so internal models (tab_*, chat_*) and other providers (gpt-oss)
+ * stay excluded.
+ * @param {Object} data - fetchAvailableModels response
+ */
+export function recordModels(data) {
+    if (!data || !data.models) return;
+    const agentIds = collectAgentModelIds(data);
+
+    for (const [modelId, modelData] of Object.entries(data.models)) {
+        const family = familyFromProvider(modelData?.apiProvider);
+        if (!hasFamilyInName(modelId) && !(family && agentIds.has(modelId))) continue;
+
+        registry.set(modelId, {
+            family,
+            supportsThinking: modelData?.supportsThinking === true,
+            maxOutputTokens: modelData?.maxOutputTokens ?? null,
+            displayName: modelData?.displayName || null
+        });
+    }
+}
+
+/**
+ * Get recorded metadata for a model id.
+ * @param {string} modelId
+ * @returns {{family: 'claude'|'gemini'|null, supportsThinking: boolean, maxOutputTokens: number|null, displayName: string|null} | undefined}
+ */
+export function getRegisteredModel(modelId) {
+    return registry.get(modelId);
+}
+
+/**
+ * Clear all recorded metadata (used by tests).
+ */
+export function clearModelRegistry() {
+    registry.clear();
+}

package/src/config.js

@@ -53,6 +53,11 @@ const DEFAULT_CONFIG = {
     switchAccountDelayMs: 5000,    // Delay before switching accounts on rate limit
     capacityBackoffTiersMs: [5000, 10000, 20000, 30000, 60000], // Progressive backoff tiers for capacity exhaustion
     modelMapping: {},
+    // Antigravity client version sent to Cloud Code (X-Client-Version / User-Agent).
+    // Empty = auto-detect from local Antigravity install, then hardcoded fallback.
+    // The backend hides newer models from outdated client versions.
+    antigravityClientVersion: '',
+    antigravityIdeVersion: '',
     // Account selection strategy configuration
     accountSelection: {
         strategy: 'hybrid',           // 'sticky' | 'round-robin' | 'hybrid'

package/src/constants.js

@@ -7,6 +7,7 @@ import { homedir, platform, arch } from 'os';
 import { join } from 'path';
 import { config } from './config.js';
 import { generateSmartUserAgent, getClientVersion } from './utils/version-detector.js';
+import { getRegisteredModel } from './cloudcode/model-registry.js';
 
 /**
  * Get the Antigravity database path based on the current platform.
@@ -29,7 +30,7 @@ function getAntigravityDbPath() {
 
 /**
  * Generate platform-specific User-Agent string.
- * @returns {string} User-Agent in format "antigravity/version os/arch"
+ * @returns {string} User-Agent in format "antigravity/hub/version os/arch"
  */
 export function getPlatformUserAgent() {
     return generateSmartUserAgent();
@@ -217,6 +218,7 @@ export const MODEL_VALIDATION_CACHE_TTL_MS = 5 * 60 * 1000;
 
 /**
  * Get the model family from model name (dynamic detection, no hardcoded list).
+ * Ids without a family in their name resolve via backend metadata (model-registry.js).
  * @param {string} modelName - The model name from the request
  * @returns {'claude' | 'gemini' | 'unknown'} The model family
  */
@@ -224,7 +226,8 @@ export function getModelFamily(modelName) {
     const lower = (modelName || '').toLowerCase();
     if (lower.includes('claude')) return 'claude';
     if (lower.includes('gemini')) return 'gemini';
-    return 'unknown';
+    // Fall back to the provider reported by the backend (codename model ids)
+    return getRegisteredModel(modelName)?.family || 'unknown';
 }
 
 /**
@@ -242,8 +245,11 @@ export function isThinkingModel(modelName) {
         // Check for gemini-3 or higher (e.g., gemini-3, gemini-3.5, gemini-4, etc.)
         const versionMatch = lower.match(/gemini-(\d+)/);
         if (versionMatch && parseInt(versionMatch[1], 10) >= 3) return true;
+        return false;
     }
-    return false;
+    if (lower.includes('claude')) return false;
+    // Codename ids: trust the backend's supportsThinking flag
+    return getRegisteredModel(modelName)?.supportsThinking === true;
 }
 
 // Google OAuth configuration (from opencode-antigravity-auth)

package/src/format/request-converter.js

@@ -24,6 +24,17 @@ import {
 } from './thinking-utils.js';
 import { logger } from '../utils/logger.js';
 
+// Claude Code injects a billing pseudo-header as a system prompt block, e.g.
+// "x-anthropic-billing-header: cc_version=2.1.274.834; cc_entrypoint=sdk-cli;".
+// Cloud Code API answers any request containing it with a 429 RESOURCE_EXHAUSTED
+// even when quota remains (Issue #375).
+const BILLING_HEADER_LINE = /^x-anthropic-billing-header:[^\n]*\n?/gim;
+
+function stripBillingHeader(text) {
+    if (typeof text !== 'string' || !/x-anthropic-billing-header:/i.test(text)) return text;
+    return text.replace(BILLING_HEADER_LINE, '').trim();
+}
+
 /**
  * Convert Anthropic Messages API request to the format expected by Cloud Code
  *
@@ -56,15 +67,18 @@ export function convertAnthropicToGoogle(anthropicRequest) {
     if (system) {
         let systemParts = [];
         if (typeof system === 'string') {
-            systemParts = [{ text: system }];
+            systemParts = [{ text: stripBillingHeader(system) }];
         } else if (Array.isArray(system)) {
             // Filter for text blocks as system prompts are usually text
             // Anthropic supports text blocks in system prompts
             systemParts = system
                 .filter(block => block.type === 'text')
-                .map(block => ({ text: block.text }));
+                .map(block => ({ text: stripBillingHeader(block.text) }));
         }
 
+        // Drop parts left empty once the billing header is stripped
+        systemParts = systemParts.filter(part => part.text);
+
         if (systemParts.length > 0) {
             googleRequest.systemInstruction = {
                 parts: systemParts

package/src/format/schema-sanitizer.js

@@ -518,7 +518,16 @@ export function sanitizeSchema(schema) {
     for (const [key, value] of Object.entries(schema)) {
         // Convert "const" to "enum" for compatibility
         if (key === 'const') {
-            sanitized.enum = [value];
+            // Google's API rejects non-string enum values (TYPE_STRING).
+            // Convert booleans/numbers to strings, or skip if the value is
+            // not a simple scalar.
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                sanitized.enum = [String(value)];
+            } else {
+                // For complex const values, add as description hint instead
+                // local fix: `sanitized` is a const; merge the hint instead of reassigning
+                Object.assign(sanitized, appendDescriptionHint(sanitized, `Must be: ${JSON.stringify(value)}`));
+            }
             continue;
         }
 
@@ -527,6 +536,12 @@ export function sanitizeSchema(schema) {
             continue;
         }
 
+        // Sanitize enum values: Google requires TYPE_STRING for enum entries
+        if (key === 'enum' && Array.isArray(value)) {
+            sanitized.enum = value.map(v => (typeof v === 'string') ? v : String(v));
+            continue;
+        }
+
         if (key === 'properties' && value && typeof value === 'object') {
             sanitized.properties = {};
             for (const [propKey, propValue] of Object.entries(value)) {

package/src/utils/version-detector.js

@@ -2,6 +2,7 @@ import { execSync } from 'child_process';
 import { platform, homedir } from 'os';
 import { join } from 'path';
 import { existsSync, readFileSync } from 'fs';
+import { config } from '../config.js';
 
 /**
  * Intelligent Version Detection for Antigravity
@@ -13,13 +14,23 @@ import { existsSync, readFileSync } from 'fs';
  *
  * Detection priority (for each):
  *   1. Environment variable override
- *   2. product.json from local Antigravity app
- *   3. OS-specific detection (macOS plist / Windows exe)
- *   4. Hardcoded fallback
+ *   2. config.json (antigravityClientVersion / antigravityIdeVersion)
+ *   3. product.json from local Antigravity app
+ *   4. OS-specific detection (macOS plist / Windows exe)
+ *   5. Hardcoded fallback
+ *
+ * The Cloud Code backend gates newer models (e.g. gemini-4-argon-*) on the
+ * User-Agent: it must use the Antigravity Hub format ("antigravity/hub/<version>")
+ * with a recent enough version, so an outdated fallback can hide models that the
+ * real Antigravity client lists.
  */
 
-// Fallback for User-Agent version (ideVersion in product.json)
-const FALLBACK_USER_AGENT_VERSION = process.env.FALLBACK_ANTIGRAVITY_VERSION || '2.0.3';
+// Fallback for User-Agent version (ideVersion in product.json), used only when
+// no installed Antigravity version is detected
+const FALLBACK_USER_AGENT_VERSION = process.env.FALLBACK_ANTIGRAVITY_VERSION || '2.25.0';
+
+// Detected versions must be above this to be used (older installs are ignored)
+const MIN_DETECTED_USER_AGENT_VERSION = '2.0.3';
 
 // Fallback for X-Client-Version (top-level "version" in product.json)
 // Can be overridden via ANTIGRAVITY_CLIENT_VERSION_FALLBACK env var
@@ -110,42 +121,49 @@ function logVersionInfo(version, source) {
 
     import('./logger.js').then(({ logger }) => {
         if (source === 'fallback') {
-            logger.warn(`X-Client-Version: using hardcoded fallback ${version} — product.json not found. Set ANTIGRAVITY_CLIENT_VERSION (exact version) or ANTIGRAVITY_CLIENT_VERSION_FALLBACK (fallback value) env var to override.`);
+            logger.warn(`X-Client-Version: using hardcoded fallback ${version} — product.json not found. Newer models may be hidden by the backend. Set "antigravityClientVersion" in config.json or the ANTIGRAVITY_CLIENT_VERSION env var to your Antigravity version.`);
         } else {
             logger.debug(`X-Client-Version: ${version} (source: ${source})`);
         }
     }).catch(() => {});
 }
 
+/**
+ * Resolve the X-Client-Version from its candidate sources (pure, for testing).
+ * Priority: env var > config.json > product.json "version" > hardcoded fallback
+ * @param {{envVersion?: string, configVersion?: string, productVersion?: string}} sources
+ * @returns {{version: string, source: 'env'|'config'|'product.json'|'fallback'}}
+ */
+export function resolveClientVersion({ envVersion, configVersion, productVersion } = {}) {
+    if (envVersion) return { version: envVersion, source: 'env' };
+    if (configVersion) return { version: String(configVersion), source: 'config' };
+    if (productVersion) return { version: productVersion, source: 'product.json' };
+    return { version: FALLBACK_CLIENT_VERSION, source: 'fallback' };
+}
+
 /**
  * Get the X-Client-Version value for API requests.
- * Priority: ANTIGRAVITY_CLIENT_VERSION env var > product.json "version" > hardcoded fallback
+ * Priority: ANTIGRAVITY_CLIENT_VERSION env var > config.json "antigravityClientVersion"
+ *           > product.json "version" > hardcoded fallback
  * @returns {string} Version string (e.g. "1.110.0")
  */
 export function getClientVersion() {
     if (cachedClientVersion) return cachedClientVersion;
 
-    if (process.env.ANTIGRAVITY_CLIENT_VERSION) {
-        cachedClientVersion = process.env.ANTIGRAVITY_CLIENT_VERSION;
-        logVersionInfo(cachedClientVersion, 'env');
-        return cachedClientVersion;
-    }
-
-    const product = getProductJson();
-    if (product?.version) {
-        cachedClientVersion = product.version;
-        logVersionInfo(cachedClientVersion, 'product.json');
-        return cachedClientVersion;
-    }
-
-    cachedClientVersion = FALLBACK_CLIENT_VERSION;
-    logVersionInfo(cachedClientVersion, 'fallback');
+    const { version, source } = resolveClientVersion({
+        envVersion: process.env.ANTIGRAVITY_CLIENT_VERSION,
+        configVersion: config?.antigravityClientVersion,
+        productVersion: getProductJson()?.version
+    });
+    cachedClientVersion = version;
+    logVersionInfo(cachedClientVersion, source);
     return cachedClientVersion;
 }
 
 /**
  * Get the User-Agent version string.
- * Priority: FALLBACK_ANTIGRAVITY_VERSION env var > product.json "ideVersion" > OS detection > fallback
+ * Priority: FALLBACK_ANTIGRAVITY_VERSION env var > config.json "antigravityIdeVersion"
+ *           > product.json "ideVersion" > OS detection > fallback
  * @returns {{ version: string, source: string }}
  */
 function getUserAgentVersionConfig() {
@@ -153,34 +171,51 @@ function getUserAgentVersionConfig() {
         return { version: process.env.FALLBACK_ANTIGRAVITY_VERSION, source: 'env' };
     }
 
-    const product = getProductJson();
-    if (product?.ideVersion && isVersionHigher(product.ideVersion, FALLBACK_USER_AGENT_VERSION)) {
-        return { version: product.ideVersion, source: 'product.json' };
+    if (config?.antigravityIdeVersion) {
+        return { version: String(config.antigravityIdeVersion), source: 'config' };
     }
 
+    const fromProduct = resolveUserAgentVersion({ productVersion: getProductJson()?.ideVersion });
+    if (fromProduct.source !== 'fallback') return fromProduct;
+
     // OS-specific detection (legacy — reads app binary metadata directly)
     const os = platform();
-    let detectedVersion = null;
+    let localVersion = null;
     try {
         if (os === 'darwin') {
-            detectedVersion = getVersionMacos();
+            localVersion = getVersionMacos();
         } else if (os === 'win32') {
-            detectedVersion = getVersionWindows();
+            localVersion = getVersionWindows();
         }
     } catch (error) {
         // Silently fail and use fallback
     }
 
-    if (detectedVersion && isVersionHigher(detectedVersion, FALLBACK_USER_AGENT_VERSION)) {
-        return { version: detectedVersion, source: 'local' };
-    }
+    return resolveUserAgentVersion({ localVersion });
+}
 
+/**
+ * Resolve the User-Agent version from detected installs (pure, for testing).
+ * A detected version is used as-is; the fallback applies only when nothing
+ * usable was detected.
+ * @param {{productVersion?: string, localVersion?: string}} detected
+ * @returns {{version: string, source: 'product.json'|'local'|'fallback'}}
+ */
+export function resolveUserAgentVersion({ productVersion, localVersion } = {}) {
+    if (productVersion && isVersionHigher(productVersion, MIN_DETECTED_USER_AGENT_VERSION)) {
+        return { version: productVersion, source: 'product.json' };
+    }
+    if (localVersion && isVersionHigher(localVersion, MIN_DETECTED_USER_AGENT_VERSION)) {
+        return { version: localVersion, source: 'local' };
+    }
     return { version: FALLBACK_USER_AGENT_VERSION, source: 'fallback' };
 }
 
 /**
  * Generate a simplified User-Agent string used by the Antigravity binary.
- * Format: "antigravity/version os/arch"
+ * Format: "antigravity/hub/version os/arch" (Antigravity 2.x Hub family; the
+ * backend hides newer models such as gemini-4-argon-* from the legacy
+ * "antigravity/version os/arch" format)
  * @returns {string} The User-Agent string
  */
 export function generateSmartUserAgent() {
@@ -192,7 +227,7 @@ export function generateSmartUserAgent() {
 
     const osName = os === 'darwin' ? 'darwin' : (os === 'win32' ? 'win32' : 'linux');
 
-    cachedUserAgent = `antigravity/${version} ${osName}/${architecture}`;
+    cachedUserAgent = `antigravity/hub/${version} ${osName}/${architecture}`;
     return cachedUserAgent;
 }