antigravity-claude-proxy 2.9.0 → 2.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",
@@ -38,7 +38,8 @@
     "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:billing-header": "node tests/test-billing-header.cjs"
+    "test:billing-header": "node tests/test-billing-header.cjs",
+    "test:stats": "node tests/test-usage-stats.js"
   },
   "keywords": [
     "claude",

package/public/js/components/dashboard/charts.js

@@ -461,8 +461,18 @@ window.DashboardCharts.updateTrendChart = function (component) {
       });
     });
 
-    // Build datasets for families
+    // Build datasets for families (only include families with activity > 0)
+    const activeFamilies = new Set();
+    Object.entries(dataByFamily).forEach(([family, values]) => {
+      if (values.some((v) => v > 0)) {
+        activeFamilies.add(family);
+      }
+    });
+    component.activeFamilies = activeFamilies;
+
     component.selectedFamilies.forEach((family) => {
+      if (!activeFamilies.has(family)) return;
+
       const color = window.DashboardFilters.getFamilyColor(family);
       const familyKey =
         "family" + family.charAt(0).toUpperCase() + family.slice(1);
@@ -501,10 +511,22 @@ window.DashboardCharts.updateTrendChart = function (component) {
       });
     });
 
-    // Build datasets for models
+    // Track models with activity > 0 in this filtered time range
+    const activeModelKeys = new Set();
+    Object.entries(dataByModel).forEach(([key, values]) => {
+      if (values.some((v) => v > 0)) {
+        activeModelKeys.add(key);
+      }
+    });
+    component.activeModelKeys = activeModelKeys;
+
+    // Build datasets for models (only include models with activity > 0 in this time range)
     component.families.forEach((family) => {
       (component.selectedModels[family] || []).forEach((model, modelIndex) => {
         const key = `${family}:${model}`;
+        // Skip models with 0 calls in the selected period
+        if (!activeModelKeys.has(key)) return;
+
         const color = window.DashboardFilters.getModelColor(family, modelIndex);
         datasets.push(
           window.DashboardCharts.createDataset(
@@ -518,6 +540,13 @@ window.DashboardCharts.updateTrendChart = function (component) {
     });
   }
 
+  if (datasets.length === 0) {
+    if (window.UILogger) window.UILogger.debug("No active datasets for trend chart (all zero in time range)");
+    component.hasFilteredTrendData = false;
+    _trendChartUpdateLock = false;
+    return;
+  }
+
   try {
     const newChart = new Chart(canvas, {
       type: "line",
@@ -543,6 +572,9 @@ window.DashboardCharts.updateTrendChart = function (component) {
             borderWidth: 1,
             padding: 10,
             displayColors: true,
+            filter: function (tooltipItem) {
+              return (tooltipItem.parsed?.y || 0) > 0;
+            },
             callbacks: {
               label: function (context) {
                 return context.dataset.label + ": " + context.parsed.y;

package/public/js/components/dashboard.js

@@ -14,6 +14,8 @@ window.Components.dashboard = () => ({
     historyData: {},
     modelTree: {},
     families: [],
+    activeModelKeys: null,
+    activeFamilies: null,
 
     // Claude config status
     claudeConfigStatus: {

package/public/views/dashboard.html

@@ -451,7 +451,8 @@
             <!-- Family Mode Legend -->
             <template x-if="displayMode === 'family'">
                 <template x-for="family in selectedFamilies" :key="family">
-                    <div class="flex items-center gap-1.5 text-[10px] font-mono">
+                    <div class="flex items-center gap-1.5 text-[10px] font-mono"
+                        x-show="!activeFamilies || activeFamilies.has(family)">
                         <div class="w-2 h-2 rounded-full" :style="'background-color:' + getFamilyColor(family)"></div>
                         <span class="text-gray-400"
                             x-text="$store.global.t('family' + family.charAt(0).toUpperCase() + family.slice(1))"></span>
@@ -462,7 +463,8 @@
             <template x-if="displayMode === 'model'">
                 <template x-for="family in families" :key="'legend-' + family">
                     <template x-for="(model, modelIndex) in (selectedModels[family] || [])" :key="family + ':' + model">
-                        <div class="flex items-center gap-1.5 text-[10px] font-mono">
+                        <div class="flex items-center gap-1.5 text-[10px] font-mono"
+                            x-show="!activeModelKeys || activeModelKeys.has(family + ':' + model)">
                             <div class="w-2 h-2 rounded-full"
                                 :style="'background-color:' + getModelColor(family, modelIndex)"></div>
                             <span class="text-gray-400" x-text="model"></span>

package/src/cloudcode/request-builder.js

@@ -24,10 +24,23 @@ import { deriveSessionId } from './session-manager.js';
 // 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".
+//
+// Claude Code and Anthropic are listed explicitly: issue #375 identified
+// "You are Claude Code, Anthropic's official CLI for Claude." as a 429 trigger
+// alongside the billing header, but the merged fix (2f6afae) only stripped the
+// header and left both names in place.
+//
+// Matching is case-sensitive on purpose, so lower-case header names
+// (x-anthropic-beta, anthropic-version) and file names (CLAUDE.md) are left
+// alone. The bare word "Claude" is deliberately NOT scrubbed: it is legitimate
+// in model self-descriptions, and requests succeed with it present once the two
+// names above are neutralized.
 const DEFAULT_IDENTITY_SCRUB = [
     ['Nous Research', 'the assistant team'],
     ['Hermes Agent', 'the assistant'],
-    ['Hermes', 'the assistant']
+    ['Hermes', 'the assistant'],
+    ['Claude Code', 'the assistant'],
+    ['Anthropic', 'the vendor']
 ];
 
 function parseIdentityScrubEnv(raw) {
@@ -42,16 +55,22 @@ function parseIdentityScrubEnv(raw) {
         .filter((rule) => rule && rule[0].length > 0);
 }
 
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Terms match as whole words only, so identifiers that merely contain a term
+// (convertAnthropicToGoogle, AnthropicRequest, HermesHandler) are left alone.
 const IDENTITY_SCRUB_RULES = [
     ...DEFAULT_IDENTITY_SCRUB,
     ...parseIdentityScrubEnv(process.env.ANTIGRAVITY_SCRUB_IDENTITY)
-];
+].map(([term, replacement]) => [new RegExp(`\\b${escapeRegExp(term)}\\b`, 'g'), replacement]);
 
 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);
+    for (const [pattern, replacement] of IDENTITY_SCRUB_RULES) {
+        out = out.replace(pattern, () => replacement);
     }
     return out;
 }

package/src/constants.js

@@ -202,8 +202,8 @@ export const STRATEGY_LABELS = {
     'hybrid': 'Hybrid (Smart Distribution)'
 };
 
-// Gemini-specific limits
-export const GEMINI_MAX_OUTPUT_TOKENS = 16384;
+// Gemini-specific limits (Gemini 3.8 / Gemini 4 Argon support up to 65536 output tokens)
+export const GEMINI_MAX_OUTPUT_TOKENS = 65536;
 
 // Gemini signature handling
 // Sentinel value to skip thought signature validation when Claude Code strips the field
@@ -290,6 +290,17 @@ export const MODEL_FALLBACK_MAP = {
     'claude-sonnet-4-6': 'gemini-3-flash'
 };
 
+// Built-in model aliases mapped to canonical backend models
+export const BUILTIN_MODEL_MAPPINGS = {
+    'claude-3-5-sonnet-20241022': 'claude-sonnet-4-6',
+    'claude-3-7-sonnet-20250219': 'claude-sonnet-4-6',
+    'claude-opus-5-5': 'claude-opus-4-6-thinking',
+    'claude-sonnet-5-5': 'claude-sonnet-4-6',
+    'claude-haiku-5-5': 'claude-sonnet-4-6',
+    'claude-opus-5': 'claude-opus-4-6-thinking',
+    'claude-sonnet-5': 'claude-sonnet-4-6'
+};
+
 // Default test models for each family (used by test suite)
 export const TEST_MODELS = {
     claude: 'claude-sonnet-4-6',
@@ -522,6 +533,7 @@ export default {
     OAUTH_REDIRECT_URI,
     STRATEGY_LABELS,
     MODEL_FALLBACK_MAP,
+    BUILTIN_MODEL_MAPPINGS,
     TEST_MODELS,
     DEFAULT_PRESETS,
     DEFAULT_SERVER_PRESETS,

package/src/format/request-converter.js

@@ -202,13 +202,24 @@ export function convertAnthropicToGoogle(anthropicRequest) {
             googleRequest.generationConfig.thinkingConfig = thinkingConfig;
         } else if (isGeminiModel) {
             // Gemini thinking config (uses camelCase)
-            // Clamp budget to model-specific max (e.g., Gemini 2.5 Flash max is 24,576)
+            // For callers that did not explicitly request thinking and asked for small max_tokens,
+            // use minimal thinking budget (32) and reserve output headroom so thinking doesn't
+            // consume the entire maxOutputTokens budget and return empty text.
+            const requestedBudget = thinking?.budget_tokens
+                ? clampGeminiThinkingBudget(modelName, thinking.budget_tokens)
+                : (max_tokens && max_tokens <= 1024 ? 32 : clampGeminiThinkingBudget(modelName, undefined));
             const thinkingConfig = {
-                includeThoughts: true,
-                thinkingBudget: clampGeminiThinkingBudget(modelName, thinking?.budget_tokens)
+                includeThoughts: Boolean(thinking?.type === 'enabled' || thinking?.budget_tokens || !max_tokens || max_tokens > 256),
+                thinkingBudget: requestedBudget
             };
             logger.debug(`[RequestConverter] Gemini thinking enabled with budget: ${thinkingConfig.thinkingBudget}`);
 
+            const currentMaxTokens = googleRequest.generationConfig.maxOutputTokens;
+            if (currentMaxTokens && currentMaxTokens <= thinkingConfig.thinkingBudget) {
+                const adjustedMaxTokens = Math.min(thinkingConfig.thinkingBudget + Math.max(currentMaxTokens, 8192), GEMINI_MAX_OUTPUT_TOKENS);
+                logger.debug(`[RequestConverter] Adjusting Gemini maxOutputTokens from ${currentMaxTokens} to ${adjustedMaxTokens} to exceed thinkingBudget (${thinkingConfig.thinkingBudget})`);
+                googleRequest.generationConfig.maxOutputTokens = adjustedMaxTokens;
+            }
 
             googleRequest.generationConfig.thinkingConfig = thinkingConfig;
         }

package/src/format/thinking-utils.js

@@ -4,7 +4,7 @@
  */
 
 import { MIN_SIGNATURE_LENGTH } from '../constants.js';
-import { getCachedSignatureFamily } from './signature-cache.js';
+import { getCachedSignature, getCachedSignatureFamily } from './signature-cache.js';
 import { logger } from '../utils/logger.js';
 
 // ============================================================================
@@ -447,6 +447,11 @@ function messageHasValidThinking(message) {
     const content = message.content || message.parts || [];
     if (!Array.isArray(content)) return false;
     return content.some(block => {
+        if (block && (block.type === 'tool_use' || block.functionCall)) {
+            if (block.thoughtSignature && block.thoughtSignature.length >= MIN_SIGNATURE_LENGTH) return true;
+            if (block.id && getCachedSignature(block.id)) return true;
+            return false;
+        }
         if (!isThinkingPart(block)) return false;
         // Check for valid signature (Anthropic style)
         if (block.signature && block.signature.length >= MIN_SIGNATURE_LENGTH) return true;

package/src/modules/usage-stats.js

@@ -10,11 +10,47 @@ const DATA_DIR = path.dirname(HISTORY_FILE);
 const OLD_DATA_DIR = path.join(process.cwd(), 'data');
 const OLD_HISTORY_FILE = path.join(OLD_DATA_DIR, 'usage-history.json');
 
+// Legacy model aliases that should be migrated to canonical backend model names in history
+export const LEGACY_MODEL_MIGRATIONS = {
+    'opus-5-5': 'opus-4-6-thinking',
+    'sonnet-5-5': 'sonnet-4-6',
+    'haiku-5-5': 'sonnet-4-6'
+};
+
 // In-memory storage
 // Structure: { "YYYY-MM-DDTHH:00:00.000Z": { "claude": { "model-name": count, "_subtotal": count }, "_total": count } }
 let history = {};
 let isDirty = false;
 
+/**
+ * Migrate legacy/phantom model names in history to canonical backend model names
+ * @param {object} data - History data
+ * @returns {boolean} Whether any migration took place
+ */
+export function normalizeHistory(data) {
+    if (!data || typeof data !== 'object') return false;
+    let modified = false;
+
+    for (const [timestamp, hourData] of Object.entries(data)) {
+        if (!hourData || typeof hourData !== 'object') continue;
+
+        for (const [family, familyData] of Object.entries(hourData)) {
+            if (!familyData || typeof familyData !== 'object' || family.startsWith('_')) continue;
+
+            for (const [legacyName, targetName] of Object.entries(LEGACY_MODEL_MIGRATIONS)) {
+                if (familyData[legacyName] !== undefined) {
+                    const count = familyData[legacyName];
+                    delete familyData[legacyName];
+                    familyData[targetName] = (familyData[targetName] || 0) + count;
+                    modified = true;
+                    logger.info(`[UsageStats] Migrated legacy model ${legacyName} -> ${targetName} (${count} calls at ${timestamp})`);
+                }
+            }
+        }
+    }
+    return modified;
+}
+
 /**
  * Extract model family from model ID
  * @param {string} modelId - The model identifier (e.g., "claude-opus-4-6-thinking")
@@ -62,6 +98,10 @@ function load() {
         if (fs.existsSync(HISTORY_FILE)) {
             const data = fs.readFileSync(HISTORY_FILE, 'utf8');
             history = JSON.parse(data);
+            if (normalizeHistory(history)) {
+                isDirty = true;
+                save();
+            }
         }
     } catch (err) {
         logger.error('[UsageStats] Failed to load history:', err);
@@ -143,28 +183,17 @@ function setupMiddleware(app) {
     load();
 
     // Auto-save every minute
-    setInterval(() => {
+    const saveInterval = setInterval(() => {
         save();
         prune();
     }, 60 * 1000);
+    if (saveInterval.unref) {
+        saveInterval.unref();
+    }
 
     // Save on exit
     process.on('SIGINT', () => { save(); process.exit(); });
     process.on('SIGTERM', () => { save(); process.exit(); });
-
-    // Request interceptor
-    // Track both Anthropic (/v1/messages) and OpenAI compatible (/v1/chat/completions) endpoints
-    const TRACKED_PATHS = ['/v1/messages', '/v1/chat/completions'];
-
-    app.use((req, res, next) => {
-        if (req.method === 'POST' && TRACKED_PATHS.includes(req.path)) {
-            const model = req.body?.model;
-            if (model) {
-                track(model);
-            }
-        }
-        next();
-    });
 }
 
 /**
@@ -202,5 +231,7 @@ export default {
     track,
     getFamily,
     getShortName,
-    getHistory
+    getHistory,
+    normalizeHistory,
+    LEGACY_MODEL_MIGRATIONS
 };

package/src/server.js

@@ -15,7 +15,7 @@ import { config } from './config.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 import { forceRefresh } from './auth/token-extractor.js';
-import { REQUEST_BODY_LIMIT } from './constants.js';
+import { REQUEST_BODY_LIMIT, BUILTIN_MODEL_MAPPINGS } from './constants.js';
 import { AccountManager } from './account-manager/index.js';
 import { clearThinkingSignatureCache } from './format/signature-cache.js';
 import { formatDuration } from './utils/helpers.js';
@@ -730,6 +730,10 @@ app.post('/v1/messages', async (req, res) => {
             const targetModel = modelMapping[requestedModel].mapping;
             logger.info(`[Server] Mapping model ${requestedModel} -> ${targetModel}`);
             requestedModel = targetModel;
+        } else if (BUILTIN_MODEL_MAPPINGS[requestedModel]) {
+            const targetModel = BUILTIN_MODEL_MAPPINGS[requestedModel];
+            logger.info(`[Server] Built-in mapping model ${requestedModel} -> ${targetModel}`);
+            requestedModel = targetModel;
         }
 
         const modelId = requestedModel;
@@ -812,6 +816,7 @@ app.post('/v1/messages', async (req, res) => {
                 const firstResult = await generator.next();
 
                 // If we get here, the stream started successfully.
+                usageStats.track(modelId);
                 res.status(200);
                 res.setHeader('Content-Type', 'text/event-stream');
                 res.setHeader('Cache-Control', 'no-cache');
@@ -863,6 +868,7 @@ app.post('/v1/messages', async (req, res) => {
         } else {
             // Handle non-streaming response
             const response = await sendMessage(request, accountManager, FALLBACK_ENABLED);
+            usageStats.track(response?.model || modelId);
             res.json(response);
         }