antigravity-claude-proxy 2.0.5 → 2.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",
@@ -34,8 +34,7 @@
     "test:crossmodel": "node tests/test-cross-model-thinking.cjs",
     "test:oauth": "node tests/test-oauth-no-browser.cjs",
     "test:emptyretry": "node tests/test-empty-response-retry.cjs",
-    "test:sanitizer": "node tests/test-schema-sanitizer.cjs",
-    "test:counttokens": "node tests/test-count-tokens.cjs"
+    "test:sanitizer": "node tests/test-schema-sanitizer.cjs"
   },
   "keywords": [
     "claude",
@@ -58,8 +57,6 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/tokenizer": "^0.0.4",
-    "@lenml/tokenizer-gemini": "^3.7.2",
     "async-mutex": "^0.5.0",
     "better-sqlite3": "^12.5.0",
     "cors": "^2.8.5",

package/src/cloudcode/model-api.js

@@ -117,6 +117,31 @@ export async function getModelQuotas(token) {
     return quotas;
 }
 
+/**
+ * Parse tier ID string to determine subscription level
+ * @param {string} tierId - The tier ID from the API
+ * @returns {'free' | 'pro' | 'ultra' | 'unknown'} The subscription tier
+ */
+function parseTierId(tierId) {
+    if (!tierId) return 'unknown';
+    const lower = tierId.toLowerCase();
+
+    if (lower.includes('ultra')) {
+        return 'ultra';
+    }
+    if (lower === 'standard-tier') {
+        // standard-tier = "Gemini Code Assist" (paid, project-based)
+        return 'pro';
+    }
+    if (lower.includes('pro') || lower.includes('premium')) {
+        return 'pro';
+    }
+    if (lower === 'free-tier' || lower.includes('free')) {
+        return 'free';
+    }
+    return 'unknown';
+}
+
 /**
  * Get subscription tier for an account
  * Calls loadCodeAssist API to discover project ID and subscription tier
@@ -162,22 +187,46 @@ export async function getSubscriptionTier(token) {
                 projectId = data.cloudaicompanionProject.id;
             }
 
-            // Extract subscription tier (priority: paidTier > currentTier)
-            let tier = 'free';
-            const tierId = data.paidTier?.id || data.currentTier?.id;
-
-            if (tierId) {
-                const lowerTier = tierId.toLowerCase();
-                if (lowerTier.includes('ultra')) {
+            // Extract subscription tier
+            // Priority: paidTier > currentTier > allowedTiers
+            // - paidTier.id: "g1-pro-tier", "g1-ultra-tier" (Google One subscription)
+            // - currentTier.id: "standard-tier" (pro), "free-tier" (free)
+            // - allowedTiers: fallback when currentTier is missing
+            // Note: paidTier is sometimes missing from the response even for Pro accounts
+            let tier = 'unknown';
+            let tierId = null;
+
+            // 1. Check paidTier first (Google One AI subscription - most reliable)
+            if (data.paidTier?.id) {
+                tierId = data.paidTier.id;
+                const lower = tierId.toLowerCase();
+                if (lower.includes('ultra')) {
                     tier = 'ultra';
-                } else if (lowerTier.includes('pro')) {
+                } else if (lower.includes('pro')) {
                     tier = 'pro';
-                } else {
-                    tier = 'free';
                 }
             }
 
-            logger.debug(`[CloudCode] Subscription detected: ${tier}, Project: ${projectId}`);
+            // 2. Fall back to currentTier if paidTier didn't give us a tier
+            if (tier === 'unknown' && data.currentTier?.id) {
+                tierId = data.currentTier.id;
+                tier = parseTierId(tierId);
+            }
+
+            // 3. Fall back to allowedTiers (find the default or first non-free tier)
+            if (tier === 'unknown' && Array.isArray(data.allowedTiers) && data.allowedTiers.length > 0) {
+                // First look for the default tier
+                let defaultTier = data.allowedTiers.find(t => t?.isDefault);
+                if (!defaultTier) {
+                    defaultTier = data.allowedTiers[0];
+                }
+                if (defaultTier?.id) {
+                    tierId = defaultTier.id;
+                    tier = parseTierId(tierId);
+                }
+            }
+
+            logger.debug(`[CloudCode] Subscription detected: ${tier} (tierId: ${tierId}), Project: ${projectId}`);
 
             return { tier, projectId };
         } catch (error) {

package/src/format/content-converter.js

@@ -35,6 +35,7 @@ export function convertContentToParts(content, isClaudeModel = false, isGeminiMo
     }
 
     const parts = [];
+    const deferredInlineData = []; // Collect inlineData to add at the end (Issue #91)
 
     for (const block of content) {
         if (!block) continue;
@@ -152,8 +153,9 @@ export function convertContentToParts(content, isClaudeModel = false, isGeminiMo
 
             parts.push({ functionResponse });
 
-            // Add any images from the tool result as separate parts
-            parts.push(...imageParts);
+            // Defer images from the tool result to end of parts array (Issue #91)
+            // This ensures all functionResponse parts are consecutive
+            deferredInlineData.push(...imageParts);
         } else if (block.type === 'thinking') {
             // Handle thinking blocks with signature compatibility check
             if (block.signature && block.signature.length >= MIN_SIGNATURE_LENGTH) {
@@ -183,5 +185,9 @@ export function convertContentToParts(content, isClaudeModel = false, isGeminiMo
         }
     }
 
+    // Add deferred inlineData at the end (Issue #91)
+    // This ensures functionResponse parts are consecutive, which Claude's API requires
+    parts.push(...deferredInlineData);
+
     return parts;
 }

package/src/format/request-converter.js

@@ -16,6 +16,7 @@ import {
     reorderAssistantContent,
     filterUnsignedThinkingBlocks,
     hasGeminiHistory,
+    hasUnsignedThinkingBlocks,
     needsThinkingRecovery,
     closeToolLoopForThinking
 } from './thinking-utils.js';
@@ -87,16 +88,16 @@ export function convertAnthropicToGoogle(anthropicRequest) {
         processedMessages = closeToolLoopForThinking(messages, 'gemini');
     }
 
-    // For Claude: apply recovery only for cross-model (Gemini→Claude) switch
-    // Detected by checking if history has Gemini-style tool_use with thoughtSignature
-    if (isClaudeModel && isThinking && hasGeminiHistory(messages) && needsThinkingRecovery(messages)) {
-        logger.debug('[RequestConverter] Applying thinking recovery for Claude (cross-model from Gemini)');
+    // For Claude: apply recovery for cross-model (Gemini→Claude) or unsigned thinking blocks
+    // Unsigned thinking blocks occur when Claude Code strips signatures it doesn't understand
+    const needsClaudeRecovery = hasGeminiHistory(messages) || hasUnsignedThinkingBlocks(messages);
+    if (isClaudeModel && isThinking && needsClaudeRecovery && needsThinkingRecovery(messages)) {
+        logger.debug('[RequestConverter] Applying thinking recovery for Claude');
         processedMessages = closeToolLoopForThinking(messages, 'claude');
     }
 
     // Convert messages to contents, then filter unsigned thinking blocks
-    for (let i = 0; i < processedMessages.length; i++) {
-        const msg = processedMessages[i];
+    for (const msg of processedMessages) {
         let msgContent = msg.content;
 
         // For assistant messages, process thinking blocks and reorder content

package/src/format/signature-cache.js

@@ -112,3 +112,11 @@ export function getCachedSignatureFamily(signature) {
 export function getThinkingCacheSize() {
     return thinkingSignatureCache.size;
 }
+
+/**
+ * Clear all entries from the thinking signature cache.
+ * Used for testing cold cache scenarios.
+ */
+export function clearThinkingSignatureCache() {
+    thinkingSignatureCache.clear();
+}

package/src/format/thinking-utils.js

@@ -42,6 +42,22 @@ export function hasGeminiHistory(messages) {
     );
 }
 
+/**
+ * Check if conversation has unsigned thinking blocks that will be dropped.
+ * These cause "Expected thinking but found text" errors.
+ * @param {Array<Object>} messages - Array of messages
+ * @returns {boolean} True if any assistant message has unsigned thinking blocks
+ */
+export function hasUnsignedThinkingBlocks(messages) {
+    return messages.some(msg => {
+        if (msg.role !== 'assistant' && msg.role !== 'model') return false;
+        if (!Array.isArray(msg.content)) return false;
+        return msg.content.some(block =>
+            isThinkingPart(block) && !hasValidSignature(block)
+        );
+    });
+}
+
 /**
  * Sanitize a thinking part by keeping only allowed fields
  */

package/src/server.js

@@ -9,7 +9,6 @@ import cors from 'cors';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { sendMessage, sendMessageStream, listModels, getModelQuotas, getSubscriptionTier } from './cloudcode/index.js';
-import { createCountTokensHandler } from './cloudcode/count-tokens.js';
 import { mountWebUI } from './webui/index.js';
 import { config } from './config.js';
 
@@ -18,6 +17,7 @@ const __dirname = path.dirname(__filename);
 import { forceRefresh } from './auth/token-extractor.js';
 import { REQUEST_BODY_LIMIT } from './constants.js';
 import { AccountManager } from './account-manager/index.js';
+import { clearThinkingSignatureCache } from './format/signature-cache.js';
 import { formatDuration } from './utils/helpers.js';
 import { logger } from './utils/logger.js';
 import usageStats from './modules/usage-stats.js';
@@ -161,6 +161,16 @@ app.use((req, res, next) => {
     next();
 });
 
+/**
+ * Test endpoint - Clear thinking signature cache
+ * Used for testing cold cache scenarios in cross-model tests
+ */
+app.post('/test/clear-signature-cache', (req, res) => {
+    clearThinkingSignatureCache();
+    logger.debug('[Test] Cleared thinking signature cache');
+    res.json({ success: true, message: 'Thinking signature cache cleared' });
+});
+
 /**
  * Health check endpoint - Detailed status
  * Returns status of all accounts including rate limits and model quotas
@@ -601,16 +611,14 @@ app.get('/v1/models', async (req, res) => {
  * Count tokens endpoint - Anthropic Messages API compatible
  * Uses local tokenization with official tokenizers (@anthropic-ai/tokenizer for Claude, @lenml/tokenizer-gemini for Gemini)
  */
-app.post('/v1/messages/count_tokens', async (req, res) => {
-    try {
-        // Ensure account manager is initialized for API-based counting
-        await ensureInitialized();
-    } catch (error) {
-        // If initialization fails, handler will fall back to local estimation
-        logger.debug(`[TokenCounter] Account manager not initialized: ${error.message}`);
-    }
-
-    return createCountTokensHandler(accountManager)(req, res);
+app.post('/v1/messages/count_tokens', (req, res) => {
+    res.status(501).json({
+        type: 'error',
+        error: {
+            type: 'not_implemented',
+            message: 'Token counting is not implemented. Use /v1/messages with max_tokens or configure your client to skip token counting.'
+        }
+    });
 });
 
 /**

package/src/cloudcode/count-tokens.js

@@ -1,302 +0,0 @@
-/**
- * Token Counter Implementation for antigravity-claude-proxy
- *
- * Implements Anthropic's /v1/messages/count_tokens endpoint
- * Uses official tokenizers for each model family:
- * - Claude: @anthropic-ai/tokenizer
- * - Gemini: @lenml/tokenizer-gemini
- *
- * @see https://platform.claude.com/docs/en/api/messages-count-tokens
- */
-
-import { countTokens as claudeCountTokens } from '@anthropic-ai/tokenizer';
-import { fromPreTrained as loadGeminiTokenizer } from '@lenml/tokenizer-gemini';
-import { logger } from '../utils/logger.js';
-import { getModelFamily } from '../constants.js';
-
-// Lazy-loaded Gemini tokenizer (138MB, loaded once on first use)
-let geminiTokenizer = null;
-let geminiTokenizerLoading = null;
-
-/**
- * Get or initialize the Gemini tokenizer
- * Uses singleton pattern with loading lock to prevent multiple loads
- *
- * @returns {Promise<Object>} Gemini tokenizer instance
- */
-async function getGeminiTokenizer() {
-    if (geminiTokenizer) {
-        return geminiTokenizer;
-    }
-
-    // Prevent multiple simultaneous loads
-    if (geminiTokenizerLoading) {
-        return geminiTokenizerLoading;
-    }
-
-    geminiTokenizerLoading = (async () => {
-        try {
-            logger.debug('[TokenCounter] Loading Gemini tokenizer...');
-            geminiTokenizer = await loadGeminiTokenizer();
-            logger.debug('[TokenCounter] Gemini tokenizer loaded successfully');
-            return geminiTokenizer;
-        } catch (error) {
-            logger.warn(`[TokenCounter] Failed to load Gemini tokenizer: ${error.message}`);
-            throw error;
-        } finally {
-            geminiTokenizerLoading = null;
-        }
-    })();
-
-    return geminiTokenizerLoading;
-}
-
-/**
- * Count tokens for text using Claude tokenizer
- *
- * @param {string} text - Text to tokenize
- * @returns {number} Token count
- */
-function countClaudeTokens(text) {
-    if (!text) return 0;
-    try {
-        return claudeCountTokens(text);
-    } catch (error) {
-        logger.debug(`[TokenCounter] Claude tokenizer error: ${error.message}`);
-        return Math.ceil(text.length / 4);
-    }
-}
-
-/**
- * Count tokens for text using Gemini tokenizer
- *
- * @param {Object} tokenizer - Gemini tokenizer instance
- * @param {string} text - Text to tokenize
- * @returns {number} Token count
- */
-function countGeminiTokens(tokenizer, text) {
-    if (!text) return 0;
-    try {
-        const tokens = tokenizer.encode(text);
-        // Remove BOS token if present (token id 2)
-        return tokens[0] === 2 ? tokens.length - 1 : tokens.length;
-    } catch (error) {
-        logger.debug(`[TokenCounter] Gemini tokenizer error: ${error.message}`);
-        return Math.ceil(text.length / 4);
-    }
-}
-
-/**
- * Estimate tokens for text content using appropriate tokenizer
- *
- * @param {string} text - Text to tokenize
- * @param {string} model - Model name to determine tokenizer
- * @param {Object} geminiTok - Gemini tokenizer instance (optional)
- * @returns {number} Token count
- */
-function estimateTextTokens(text, model, geminiTok = null) {
-    if (!text) return 0;
-
-    const family = getModelFamily(model);
-
-    if (family === 'claude') {
-        return countClaudeTokens(text);
-    } else if (family === 'gemini' && geminiTok) {
-        return countGeminiTokens(geminiTok, text);
-    }
-
-    // Fallback for unknown models: rough estimate
-    return Math.ceil(text.length / 4);
-}
-
-/**
- * Extract text from message content
- *
- * Note: This function only extracts text from 'text' type blocks.
- * Image blocks (type: 'image') and document blocks (type: 'document') are not tokenized
- * and will not contribute to the token count. This is intentional as binary content
- * requires different handling and Anthropic's actual token counting for images uses
- * a fixed estimate (~1600 tokens per image) that depends on image dimensions.
- *
- * @param {string|Array} content - Message content
- * @returns {string} Concatenated text
- */
-function extractText(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-
-    if (Array.isArray(content)) {
-        return content
-            .filter(block => block.type === 'text')
-            .map(block => block.text)
-            .join('\n');
-    }
-
-    return '';
-}
-
-/**
- * Count tokens locally using model-specific tokenizer
- *
- * @param {Object} request - Anthropic format request
- * @param {Object} geminiTok - Gemini tokenizer instance (optional)
- * @returns {number} Token count
- */
-function countTokensLocally(request, geminiTok = null) {
-    const { messages = [], system, tools, model } = request;
-    let totalTokens = 0;
-
-    // Count system prompt tokens
-    if (system) {
-        if (typeof system === 'string') {
-            totalTokens += estimateTextTokens(system, model, geminiTok);
-        } else if (Array.isArray(system)) {
-            for (const block of system) {
-                if (block.type === 'text') {
-                    totalTokens += estimateTextTokens(block.text, model, geminiTok);
-                }
-            }
-        }
-    }
-
-    // Count message tokens
-    for (const message of messages) {
-        // Add overhead for role and structure (~4 tokens per message)
-        totalTokens += 4;
-        totalTokens += estimateTextTokens(extractText(message.content), model, geminiTok);
-
-        // Handle tool_use and tool_result blocks
-        if (Array.isArray(message.content)) {
-            for (const block of message.content) {
-                if (block.type === 'tool_use') {
-                    totalTokens += estimateTextTokens(block.name, model, geminiTok);
-                    totalTokens += estimateTextTokens(JSON.stringify(block.input), model, geminiTok);
-                } else if (block.type === 'tool_result') {
-                    if (typeof block.content === 'string') {
-                        totalTokens += estimateTextTokens(block.content, model, geminiTok);
-                    } else if (Array.isArray(block.content)) {
-                        totalTokens += estimateTextTokens(extractText(block.content), model, geminiTok);
-                    }
-                } else if (block.type === 'thinking') {
-                    totalTokens += estimateTextTokens(block.thinking, model, geminiTok);
-                }
-            }
-        }
-    }
-
-    // Count tool definitions
-    if (tools && tools.length > 0) {
-        for (const tool of tools) {
-            totalTokens += estimateTextTokens(tool.name, model, geminiTok);
-            totalTokens += estimateTextTokens(tool.description || '', model, geminiTok);
-            totalTokens += estimateTextTokens(JSON.stringify(tool.input_schema || {}), model, geminiTok);
-        }
-    }
-
-    return totalTokens;
-}
-
-/**
- * Count tokens in a message request
- * Implements Anthropic's /v1/messages/count_tokens endpoint
- * Uses local tokenization for all content types
- *
- * @param {Object} anthropicRequest - Anthropic format request with messages, model, system, tools
- * @param {Object} accountManager - Account manager instance (unused, kept for API compatibility)
- * @param {Object} options - Options (unused, kept for API compatibility)
- * @returns {Promise<Object>} Response with input_tokens count
- */
-export async function countTokens(anthropicRequest, accountManager = null, options = {}) {
-    try {
-        const family = getModelFamily(anthropicRequest.model);
-        let geminiTok = null;
-
-        // Load Gemini tokenizer if needed
-        if (family === 'gemini') {
-            try {
-                geminiTok = await getGeminiTokenizer();
-            } catch (error) {
-                logger.warn(`[TokenCounter] Gemini tokenizer unavailable, using fallback`);
-            }
-        }
-
-        const inputTokens = countTokensLocally(anthropicRequest, geminiTok);
-        logger.debug(`[TokenCounter] Local count (${family}): ${inputTokens} tokens`);
-
-        return {
-            input_tokens: inputTokens
-        };
-
-    } catch (error) {
-        logger.warn(`[TokenCounter] Error: ${error.message}, using character-based fallback`);
-
-        // Ultimate fallback: character-based estimation
-        const { messages = [], system } = anthropicRequest;
-        let charCount = 0;
-
-        if (system) {
-            charCount += typeof system === 'string' ? system.length : JSON.stringify(system).length;
-        }
-
-        for (const message of messages) {
-            charCount += JSON.stringify(message.content).length;
-        }
-
-        return {
-            input_tokens: Math.ceil(charCount / 4)
-        };
-    }
-}
-
-/**
- * Express route handler for /v1/messages/count_tokens
- *
- * @param {Object} accountManager - Account manager instance
- * @returns {Function} Express middleware
- */
-export function createCountTokensHandler(accountManager) {
-    return async (req, res) => {
-        try {
-            const { messages, model, system, tools, tool_choice, thinking } = req.body;
-
-            // Validate required fields
-            if (!messages || !Array.isArray(messages)) {
-                return res.status(400).json({
-                    type: 'error',
-                    error: {
-                        type: 'invalid_request_error',
-                        message: 'messages is required and must be an array'
-                    }
-                });
-            }
-
-            if (!model) {
-                return res.status(400).json({
-                    type: 'error',
-                    error: {
-                        type: 'invalid_request_error',
-                        message: 'model is required'
-                    }
-                });
-            }
-
-            const result = await countTokens(
-                { messages, model, system, tools, tool_choice, thinking },
-                accountManager
-            );
-
-            res.json(result);
-
-        } catch (error) {
-            logger.error(`[TokenCounter] Handler error: ${error.message}`);
-            res.status(500).json({
-                type: 'error',
-                error: {
-                    type: 'api_error',
-                    message: error.message
-                }
-            });
-        }
-    };
-}