antigravity-claude-proxy 2.8.4 → 2.8.6

package/README.md

@@ -183,9 +183,9 @@ Add this configuration:
     "ANTHROPIC_BASE_URL": "http://localhost:8080",
     "ANTHROPIC_MODEL": "claude-opus-4-6-thinking",
     "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-4-6-thinking",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-6-thinking",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-6",
     "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-sonnet-4-6",
-    "CLAUDE_CODE_SUBAGENT_MODEL": "claude-sonnet-4-6-thinking",
+    "CLAUDE_CODE_SUBAGENT_MODEL": "claude-sonnet-4-6",
     "ENABLE_EXPERIMENTAL_MCP_CLI": "true"
   }
 }
@@ -198,11 +198,11 @@ Or to use Gemini models:
   "env": {
     "ANTHROPIC_AUTH_TOKEN": "test",
     "ANTHROPIC_BASE_URL": "http://localhost:8080",
-    "ANTHROPIC_MODEL": "gemini-3.1-pro-high[1m]",
-    "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemini-3.1-pro-high[1m]",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemini-3-flash[1m]",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemini-3-flash[1m]",
-    "CLAUDE_CODE_SUBAGENT_MODEL": "gemini-3-flash[1m]",
+    "ANTHROPIC_MODEL": "gemini-3.1-pro-low",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemini-3.1-pro-low",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemini-3.5-flash-low",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemini-3.5-flash-low",
+    "CLAUDE_CODE_SUBAGENT_MODEL": "gemini-3.5-flash-low",
     "ENABLE_EXPERIMENTAL_MCP_CLI": "true"
   }
 }
@@ -339,4 +339,4 @@ MIT
 
 ## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=badrisnarayanan/antigravity-claude-proxy&type=date&legend=top-left&cache-control=no-cache)](https://www.star-history.com/#badrisnarayanan/antigravity-claude-proxy&type=date&legend=top-left)
+[![Star History Chart](https://star-history.dera.page/svg?repos=badrisnarayanan/antigravity-claude-proxy&type=date&legend=top-left&cache-control=no-cache)](https://star-history.dera.page/#badrisnarayanan/antigravity-claude-proxy&type=date&legend=top-left)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "2.8.4",
+  "version": "2.8.6",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",

package/public/js/data-store.js

@@ -436,11 +436,11 @@ document.addEventListener('alpine:init', () => {
         _generatePlaceholderData() {
             const models = [
                 'claude-opus-4-6-thinking',
-                'claude-sonnet-4-6-thinking',
                 'claude-sonnet-4-6',
-                'gemini-3.1-pro-high',
-                'gemini-3.1-pro-low',
-                'gemini-3-flash'
+                'gemini-3.8-flash-tiered',
+                'gemini-3.6-flash-high',
+                'gemini-3.6-flash-low',
+                'gemini-3.5-flash-low'
             ];
 
             const tiers = ['ultra', 'pro', 'pro', 'free'];

package/src/cloudcode/model-api.js

@@ -33,6 +33,23 @@ function isSupportedModel(modelId) {
     return family === 'claude' || family === 'gemini';
 }
 
+/**
+ * Whether a model id is an old Gemini generation (version below 3.5),
+ * hidden from the /v1/models listing in favor of the current line. Claude
+ * ids aren't versioned this way and are unaffected.
+ * @param {string} modelId
+ * @returns {boolean}
+ */
+function isOldGemini(modelId) {
+    // 'gemini-pro-agent' carries no version number in its id at all - it's
+    // an unversioned duplicate alias of gemini-3.1-pro-high, so it's always
+    // old regardless of what the version regex below would say.
+    if (modelId === 'gemini-pro-agent') return true;
+
+    const match = modelId.match(/^gemini-(\d+(?:\.\d+)?)/);
+    return !!match && parseFloat(match[1]) < 3.5;
+}
+
 /**
  * List available models in Anthropic API format
  * Fetches models dynamically from the Cloud Code API
@@ -46,8 +63,17 @@ export async function listModels(token) {
         return { object: 'list', data: [] };
     }
 
-    const modelList = Object.entries(data.models)
-        .filter(([modelId]) => isSupportedModel(modelId))
+    const supportedEntries = Object.entries(data.models).filter(([modelId]) => isSupportedModel(modelId));
+
+    // Warm the model validation cache with every supported id, unfiltered -
+    // isValidModel() (the actual request-time gate) must keep accepting an
+    // id a client already has configured even if it's hidden from the
+    // listing below.
+    modelCache.validModels = new Set(supportedEntries.map(([modelId]) => modelId));
+    modelCache.lastFetched = Date.now();
+
+    const modelList = supportedEntries
+        .filter(([modelId]) => !isOldGemini(modelId))
         .map(([modelId, modelData]) => ({
             id: modelId,
             object: 'model',
@@ -56,10 +82,6 @@ export async function listModels(token) {
             description: modelData.displayName || modelId
         }));
 
-    // Warm the model validation cache
-    modelCache.validModels = new Set(modelList.map(m => m.id));
-    modelCache.lastFetched = Date.now();
-
     return {
         object: 'list',
         data: modelList

package/src/cloudcode/request-builder.js

@@ -14,6 +14,48 @@ import {
 import { convertAnthropicToGoogle } from '../format/index.js';
 import { deriveSessionId } from './session-manager.js';
 
+// cloudcode-pa returns an opaque 429 RESOURCE_EXHAUSTED (reported as "quota
+// exhausted", even when quota remains) when a request's system prompt names a
+// known third-party AI product — e.g. an agent whose identity line says it was
+// "created by <vendor>". This is the same class of problem as the "Antigravity"
+// identity handling above (issue #76), but for the *caller's* identity. We
+// neutralize those strings in the caller-supplied system parts.
+//
+// Defaults cover agents commonly used with this proxy; extend or override with
+// the ANTIGRAVITY_SCRUB_IDENTITY env var, formatted as a comma-separated list of
+// "Term=>Replacement" pairs, e.g. "Nous Research=>the team,Hermes=>the assistant".
+const DEFAULT_IDENTITY_SCRUB = [
+    ['Nous Research', 'the assistant team'],
+    ['Hermes Agent', 'the assistant'],
+    ['Hermes', 'the assistant']
+];
+
+function parseIdentityScrubEnv(raw) {
+    if (!raw) return [];
+    return raw
+        .split(',')
+        .map((pair) => {
+            const idx = pair.indexOf('=>');
+            if (idx === -1) return null;
+            return [pair.slice(0, idx).trim(), pair.slice(idx + 2).trim()];
+        })
+        .filter((rule) => rule && rule[0].length > 0);
+}
+
+const IDENTITY_SCRUB_RULES = [
+    ...DEFAULT_IDENTITY_SCRUB,
+    ...parseIdentityScrubEnv(process.env.ANTIGRAVITY_SCRUB_IDENTITY)
+];
+
+function scrubClientIdentity(text) {
+    if (typeof text !== 'string') return text;
+    let out = text;
+    for (const [term, replacement] of IDENTITY_SCRUB_RULES) {
+        out = out.split(term).join(replacement);
+    }
+    return out;
+}
+
 /**
  * Build the wrapped request body for Cloud Code API
  *
@@ -37,11 +79,12 @@ export function buildCloudCodeRequest(anthropicRequest, projectId, accountEmail)
         { text: `Please ignore the following [ignore]${ANTIGRAVITY_SYSTEM_INSTRUCTION}[/ignore]` }
     ];
 
-    // Append any existing system instructions from the request
+    // Append any existing system instructions from the request, scrubbing
+    // third-party AI product identities that trip cloudcode-pa's 429 (see above).
     if (googleRequest.systemInstruction && googleRequest.systemInstruction.parts) {
         for (const part of googleRequest.systemInstruction.parts) {
             if (part.text) {
-                systemParts.push({ text: part.text });
+                systemParts.push({ text: scrubClientIdentity(part.text) });
             }
         }
     }

package/src/constants.js

@@ -6,7 +6,7 @@
 import { homedir, platform, arch } from 'os';
 import { join } from 'path';
 import { config } from './config.js';
-import { generateSmartUserAgent } from './utils/version-detector.js';
+import { generateSmartUserAgent, getClientVersion } from './utils/version-detector.js';
 
 /**
  * Get the Antigravity database path based on the current platform.
@@ -104,7 +104,7 @@ export const ANTIGRAVITY_HEADERS = {
     'User-Agent': getPlatformUserAgent(),
     'Content-Type': 'application/json',
     'X-Client-Name': 'antigravity',
-    'X-Client-Version': '1.107.0', // Match product.json version
+    'X-Client-Version': getClientVersion(),
     'x-goog-api-client': 'gl-node/18.18.2 fire/0.8.6 grpc/1.10.x' // Simulate Google Node.js client environment
 };
 
@@ -279,16 +279,15 @@ export const ANTIGRAVITY_SYSTEM_INSTRUCTION = `You are Antigravity, a powerful a
 export const MODEL_FALLBACK_MAP = {
     'gemini-3.1-pro-high': 'claude-opus-4-6-thinking',
     'gemini-3.1-pro-low': 'claude-sonnet-4-6',
-    'gemini-3-flash': 'claude-sonnet-4-6-thinking',
+    'gemini-3-flash': 'claude-sonnet-4-6',
     'claude-opus-4-6-thinking': 'gemini-3.1-pro-high',
-    'claude-sonnet-4-6-thinking': 'gemini-3-flash',
     'claude-sonnet-4-6': 'gemini-3-flash'
 };
 
 // Default test models for each family (used by test suite)
 export const TEST_MODELS = {
-    claude: 'claude-sonnet-4-6-thinking',
-    gemini: 'gemini-3-flash'
+    claude: 'claude-sonnet-4-6',
+    gemini: 'gemini-3.8-flash-tiered'
 };
 
 // Default Claude CLI presets (used by WebUI settings)
@@ -300,9 +299,9 @@ export const DEFAULT_PRESETS = [
             ANTHROPIC_BASE_URL: 'http://localhost:8080',
             ANTHROPIC_MODEL: 'claude-opus-4-6-thinking',
             ANTHROPIC_DEFAULT_OPUS_MODEL: 'claude-opus-4-6-thinking',
-            ANTHROPIC_DEFAULT_SONNET_MODEL: 'claude-sonnet-4-6-thinking',
+            ANTHROPIC_DEFAULT_SONNET_MODEL: 'claude-sonnet-4-6',
             ANTHROPIC_DEFAULT_HAIKU_MODEL: 'claude-sonnet-4-6',
-            CLAUDE_CODE_SUBAGENT_MODEL: 'claude-sonnet-4-6-thinking',
+            CLAUDE_CODE_SUBAGENT_MODEL: 'claude-sonnet-4-6',
             ENABLE_EXPERIMENTAL_MCP_CLI: 'true'
         }
     },
@@ -311,11 +310,11 @@ export const DEFAULT_PRESETS = [
         config: {
             ANTHROPIC_AUTH_TOKEN: 'test',
             ANTHROPIC_BASE_URL: 'http://localhost:8080',
-            ANTHROPIC_MODEL: 'gemini-3.1-pro-high',
-            ANTHROPIC_DEFAULT_OPUS_MODEL: 'gemini-3.1-pro-high',
-            ANTHROPIC_DEFAULT_SONNET_MODEL: 'gemini-3.1-flash',
-            ANTHROPIC_DEFAULT_HAIKU_MODEL: 'gemini-3.1-flash',
-            CLAUDE_CODE_SUBAGENT_MODEL: 'gemini-3.1-flash',
+            ANTHROPIC_MODEL: 'gemini-3.1-pro-low',
+            ANTHROPIC_DEFAULT_OPUS_MODEL: 'gemini-3.1-pro-low',
+            ANTHROPIC_DEFAULT_SONNET_MODEL: 'gemini-3.5-flash-low',
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: 'gemini-3.5-flash-low',
+            CLAUDE_CODE_SUBAGENT_MODEL: 'gemini-3.5-flash-low',
             ENABLE_EXPERIMENTAL_MCP_CLI: 'true'
         }
     }

package/src/format/schema-sanitizer.js

@@ -669,5 +669,42 @@ export function cleanSchema(schema) {
         result.type = toGoogleType(result.type);
     }
 
+    // Phase 6: Google's protobuf-based schema requires every ARRAY type to
+    // declare a single object `items` schema. Plain JSON Schema allows this
+    // to be omitted (`{ type: 'array' }` = "array of anything"), boolean
+    // (`items: true` = "any"), or tuple-form (`items: [...]`) - none of
+    // which the Cloud Code API accepts; it rejects the first two with
+    // "items: missing field". This runs after the items/properties
+    // recursion above (and after Phase 5's type conversion), so it applies
+    // at every nesting depth - fixing issue #368 (nested array schemas like
+    // `where.items.items` losing their innermost `items`).
+    if (result.type === 'ARRAY') {
+        if (!result.items || typeof result.items !== 'object') {
+            // Missing entirely, or a boolean schema like `items: true`.
+            result.items = { type: 'STRING' };
+        } else if (Array.isArray(result.items)) {
+            // Tuple-form `items: [...]` - Google only supports one items
+            // schema, so collapse to the most informative entry.
+            let best = null;
+            let bestScore = -1;
+            for (const option of result.items) {
+                const score = scoreSchemaOption(option);
+                if (score > bestScore) {
+                    bestScore = score;
+                    best = option;
+                }
+            }
+            result.items = best || { type: 'STRING' };
+        }
+    }
+
+    // Phase 7: Google rejects `properties`/`required` on a non-OBJECT schema.
+    // These can survive on the current node after anyOf/oneOf flattening
+    // picked a non-object option while the parent still carried them.
+    if (result.type !== 'OBJECT') {
+        delete result.properties;
+        delete result.required;
+    }
+
     return result;
 }

package/src/utils/version-detector.js

@@ -1,24 +1,37 @@
 import { execSync } from 'child_process';
 import { platform, homedir } from 'os';
 import { join } from 'path';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 
 /**
  * Intelligent Version Detection for Antigravity
- * Attempts to find the local installation and extract its version.
- * Falls back to hard-coded stable versions if detection fails.
+ *
+ * Detects versions from the local Antigravity installation's product.json.
+ * Two version values are tracked:
+ *   - "version" field      → X-Client-Version header (API version gate)
+ *   - "ideVersion" field   → User-Agent version string
+ *
+ * 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
  */
 
-// Fallback constant (can be overridden via FALLBACK_ANTIGRAVITY_VERSION env var)
-const FALLBACK_ANTIGRAVITY_VERSION = process.env.FALLBACK_ANTIGRAVITY_VERSION || '1.23.2';
+// Fallback for User-Agent version (ideVersion in product.json)
+const FALLBACK_USER_AGENT_VERSION = process.env.FALLBACK_ANTIGRAVITY_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
+const FALLBACK_CLIENT_VERSION = process.env.ANTIGRAVITY_CLIENT_VERSION_FALLBACK || '1.110.0';
 
-// Cache for the generated User-Agent string
 let cachedUserAgent = null;
+let cachedClientVersion = null;
+let cachedProductJson = undefined; // undefined = not yet attempted
+let loggedVersionInfo = false;
 
 /**
  * Compares two semver-ish version strings (X.Y.Z).
- * @param {string} v1 - Version string 1
- * @param {string} v2 - Version string 2
  * @returns {boolean} True if v1 > v2
  */
 function isVersionHigher(v1, v2) {
@@ -35,15 +48,119 @@ function isVersionHigher(v1, v2) {
 }
 
 /**
- * Gets the version config (version, source)
+ * Returns platform-specific search paths for product.json.
+ */
+function getProductJsonPaths() {
+    const os = platform();
+    const paths = [];
+
+    if (os === 'darwin') {
+        paths.push('/Applications/Antigravity.app/Contents/Resources/app/product.json');
+        paths.push(join(homedir(), 'Applications', 'Antigravity.app', 'Contents', 'Resources', 'app', 'product.json'));
+    } else if (os === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA;
+        const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+        if (localAppData) {
+            paths.push(join(localAppData, 'Programs', 'Antigravity', 'resources', 'app', 'product.json'));
+        }
+        paths.push(join(programFiles, 'Antigravity', 'resources', 'app', 'product.json'));
+    } else {
+        paths.push('/usr/share/antigravity/resources/app/product.json');
+        paths.push('/opt/antigravity/resources/app/product.json');
+        paths.push('/opt/Antigravity/resources/app/product.json');
+        paths.push(join(homedir(), '.local', 'share', 'antigravity', 'resources', 'app', 'product.json'));
+        paths.push('/snap/antigravity/current/resources/app/product.json');
+    }
+
+    return paths;
+}
+
+/**
+ * Find and parse product.json from the local Antigravity installation.
+ * Caches the result after first attempt.
+ * @returns {Object|null} Parsed product.json or null
+ */
+function getProductJson() {
+    if (cachedProductJson !== undefined) return cachedProductJson;
+
+    for (const p of getProductJsonPaths()) {
+        try {
+            if (existsSync(p)) {
+                const content = JSON.parse(readFileSync(p, 'utf8'));
+                if (content && (content.version || content.ideVersion)) {
+                    cachedProductJson = content;
+                    return content;
+                }
+            }
+        } catch (e) {
+            // Continue to next path
+        }
+    }
+
+    cachedProductJson = null;
+    return null;
+}
+
+/**
+ * Log version detection results once at startup (lazy import to avoid circular deps).
+ */
+function logVersionInfo(version, source) {
+    if (loggedVersionInfo) return;
+    loggedVersionInfo = true;
+
+    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.`);
+        } else {
+            logger.debug(`X-Client-Version: ${version} (source: ${source})`);
+        }
+    }).catch(() => {});
+}
+
+/**
+ * Get the X-Client-Version value for API requests.
+ * Priority: ANTIGRAVITY_CLIENT_VERSION env var > 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');
+    return cachedClientVersion;
+}
+
+/**
+ * Get the User-Agent version string.
+ * Priority: FALLBACK_ANTIGRAVITY_VERSION env var > product.json "ideVersion" > OS detection > fallback
  * @returns {{ version: string, source: string }}
  */
-function getVersionConfig() {
+function getUserAgentVersionConfig() {
+    if (process.env.FALLBACK_ANTIGRAVITY_VERSION) {
+        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' };
+    }
+
+    // OS-specific detection (legacy — reads app binary metadata directly)
     const os = platform();
     let detectedVersion = null;
-    let finalVersion = FALLBACK_ANTIGRAVITY_VERSION;
-    let source = 'fallback';
-
     try {
         if (os === 'darwin') {
             detectedVersion = getVersionMacos();
@@ -54,16 +171,11 @@ function getVersionConfig() {
         // Silently fail and use fallback
     }
 
-    // Only use detected version if it's higher than the fallback version
-    if (detectedVersion && isVersionHigher(detectedVersion, FALLBACK_ANTIGRAVITY_VERSION)) {
-        finalVersion = detectedVersion;
-        source = 'local';
+    if (detectedVersion && isVersionHigher(detectedVersion, FALLBACK_USER_AGENT_VERSION)) {
+        return { version: detectedVersion, source: 'local' };
     }
 
-    return {
-        version: finalVersion,
-        source
-    };
+    return { version: FALLBACK_USER_AGENT_VERSION, source: 'fallback' };
 }
 
 /**
@@ -74,11 +186,10 @@ function getVersionConfig() {
 export function generateSmartUserAgent() {
     if (cachedUserAgent) return cachedUserAgent;
 
-    const { version } = getVersionConfig();
+    const { version } = getUserAgentVersionConfig();
     const os = platform();
     const architecture = process.arch;
 
-    // Map Node.js platform names to binary-friendly names
     const osName = os === 'darwin' ? 'darwin' : (os === 'win32' ? 'win32' : 'linux');
 
     cachedUserAgent = `antigravity/${version} ${osName}/${architecture}`;
@@ -131,4 +242,3 @@ function getVersionWindows() {
     }
     return null;
 }
-