antigravity-claude-proxy 1.2.4 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",
@@ -25,7 +25,8 @@
     "test:streaming": "node tests/test-multiturn-thinking-tools-streaming.cjs",
     "test:interleaved": "node tests/test-interleaved-thinking.cjs",
     "test:images": "node tests/test-images.cjs",
-    "test:caching": "node tests/test-caching-streaming.cjs"
+    "test:caching": "node tests/test-caching-streaming.cjs",
+    "test:crossmodel": "node tests/test-cross-model-thinking.cjs"
   },
   "keywords": [
     "claude",

package/src/cloudcode/message-handler.js

@@ -18,6 +18,7 @@ import { logger } from '../utils/logger.js';
 import { parseResetTime } from './rate-limit-parser.js';
 import { buildCloudCodeRequest, buildHeaders } from './request-builder.js';
 import { parseThinkingSSEResponse } from './sse-parser.js';
+import { getFallbackModel } from '../fallback-config.js';
 
 /**
  * Send a non-streaming request to Cloud Code with multi-account support
@@ -32,7 +33,7 @@ import { parseThinkingSSEResponse } from './sse-parser.js';
  * @returns {Promise<Object>} Anthropic-format response object
  * @throws {Error} If max retries exceeded or no accounts available
  */
-export async function sendMessage(anthropicRequest, accountManager) {
+export async function sendMessage(anthropicRequest, accountManager, fallbackEnabled = false) {
     const model = anthropicRequest.model;
     const isThinking = isThinkingModel(model);
 
@@ -76,6 +77,16 @@ export async function sendMessage(anthropicRequest, accountManager) {
             }
 
             if (!account) {
+                // Check if fallback is enabled and available
+                if (fallbackEnabled) {
+                    const fallbackModel = getFallbackModel(model);
+                    if (fallbackModel) {
+                        logger.warn(`[CloudCode] All accounts exhausted for ${model}. Attempting fallback to ${fallbackModel}`);
+                        // Retry with fallback model
+                        const fallbackRequest = { ...anthropicRequest, model: fallbackModel };
+                        return await sendMessage(fallbackRequest, accountManager, false); // Disable fallback for recursive call
+                    }
+                }
                 throw new Error('No accounts available');
             }
         }

package/src/cloudcode/sse-streamer.js

@@ -6,8 +6,8 @@
  */
 
 import crypto from 'crypto';
-import { MIN_SIGNATURE_LENGTH } from '../constants.js';
-import { cacheSignature } from '../format/signature-cache.js';
+import { MIN_SIGNATURE_LENGTH, getModelFamily } from '../constants.js';
+import { cacheSignature, cacheThinkingSignature } from '../format/signature-cache.js';
 import { logger } from '../utils/logger.js';
 
 /**
@@ -110,6 +110,9 @@ export async function* streamSSEResponse(response, originalModel) {
 
                         if (signature && signature.length >= MIN_SIGNATURE_LENGTH) {
                             currentThinkingSignature = signature;
+                            // Cache thinking signature with model family for cross-model compatibility
+                            const modelFamily = getModelFamily(originalModel);
+                            cacheThinkingSignature(signature, modelFamily);
                         }
 
                         yield {

package/src/cloudcode/streaming-handler.js

@@ -16,6 +16,7 @@ import { logger } from '../utils/logger.js';
 import { parseResetTime } from './rate-limit-parser.js';
 import { buildCloudCodeRequest, buildHeaders } from './request-builder.js';
 import { streamSSEResponse } from './sse-streamer.js';
+import { getFallbackModel } from '../fallback-config.js';
 
 
 /**
@@ -31,7 +32,7 @@ import { streamSSEResponse } from './sse-streamer.js';
  * @yields {Object} Anthropic-format SSE events (message_start, content_block_start, content_block_delta, etc.)
  * @throws {Error} If max retries exceeded or no accounts available
  */
-export async function* sendMessageStream(anthropicRequest, accountManager) {
+export async function* sendMessageStream(anthropicRequest, accountManager, fallbackEnabled = false) {
     const model = anthropicRequest.model;
 
     // Retry loop with account failover
@@ -74,6 +75,17 @@ export async function* sendMessageStream(anthropicRequest, accountManager) {
             }
 
             if (!account) {
+                // Check if fallback is enabled and available
+                if (fallbackEnabled) {
+                    const fallbackModel = getFallbackModel(model);
+                    if (fallbackModel) {
+                        logger.warn(`[CloudCode] All accounts exhausted for ${model}. Attempting fallback to ${fallbackModel} (streaming)`);
+                        // Retry with fallback model
+                        const fallbackRequest = { ...anthropicRequest, model: fallbackModel };
+                        yield* sendMessageStream(fallbackRequest, accountManager, false); // Disable fallback for recursive call
+                        return;
+                    }
+                }
                 throw new Error('No accounts available');
             }
         }

package/src/constants.js

@@ -144,6 +144,16 @@ export const OAUTH_CONFIG = {
 };
 export const OAUTH_REDIRECT_URI = `http://localhost:${OAUTH_CONFIG.callbackPort}/oauth-callback`;
 
+// Model fallback mapping - maps primary model to fallback when quota exhausted
+export const MODEL_FALLBACK_MAP = {
+    'gemini-3-pro-high': 'claude-opus-4-5-thinking',
+    'gemini-3-pro-low': 'claude-sonnet-4-5',
+    'gemini-3-flash': 'claude-sonnet-4-5-thinking',
+    'claude-opus-4-5-thinking': 'gemini-3-pro-high',
+    'claude-sonnet-4-5-thinking': 'gemini-3-flash',
+    'claude-sonnet-4-5': 'gemini-3-flash'
+};
+
 export default {
     ANTIGRAVITY_ENDPOINT_FALLBACKS,
     ANTIGRAVITY_HEADERS,
@@ -165,5 +175,6 @@ export default {
     getModelFamily,
     isThinkingModel,
     OAUTH_CONFIG,
-    OAUTH_REDIRECT_URI
+    OAUTH_REDIRECT_URI,
+    MODEL_FALLBACK_MAP
 };

package/src/fallback-config.js

@@ -0,0 +1,29 @@
+/**
+ * Model Fallback Configuration
+ *
+ * Defines fallback mappings for when a model's quota is exhausted across all accounts.
+ * Enables graceful degradation to alternative models with similar capabilities.
+ */
+
+import { MODEL_FALLBACK_MAP } from './constants.js';
+
+// Re-export for convenience
+export { MODEL_FALLBACK_MAP };
+
+/**
+ * Get fallback model for a given model ID
+ * @param {string} model - Primary model ID
+ * @returns {string|null} Fallback model ID or null if no fallback exists
+ */
+export function getFallbackModel(model) {
+    return MODEL_FALLBACK_MAP[model] || null;
+}
+
+/**
+ * Check if a model has a fallback configured
+ * @param {string} model - Model ID to check
+ * @returns {boolean} True if fallback exists
+ */
+export function hasFallback(model) {
+    return model in MODEL_FALLBACK_MAP;
+}

package/src/format/content-converter.js

@@ -4,7 +4,7 @@
  */
 
 import { MIN_SIGNATURE_LENGTH, GEMINI_SKIP_SIGNATURE } from '../constants.js';
-import { getCachedSignature } from './signature-cache.js';
+import { getCachedSignature, getCachedSignatureFamily } from './signature-cache.js';
 import { logger } from '../utils/logger.js';
 
 /**
@@ -155,16 +155,31 @@ export function convertContentToParts(content, isClaudeModel = false, isGeminiMo
             // Add any images from the tool result as separate parts
             parts.push(...imageParts);
         } else if (block.type === 'thinking') {
-            // Handle thinking blocks - only those with valid signatures
+            // Handle thinking blocks with signature compatibility check
             if (block.signature && block.signature.length >= MIN_SIGNATURE_LENGTH) {
-                // Convert to Gemini format with signature
+                const signatureFamily = getCachedSignatureFamily(block.signature);
+                const targetFamily = isClaudeModel ? 'claude' : isGeminiModel ? 'gemini' : null;
+
+                // Drop blocks with incompatible signatures for Gemini (cross-model switch)
+                if (isGeminiModel && signatureFamily && targetFamily && signatureFamily !== targetFamily) {
+                    logger.debug(`[ContentConverter] Dropping incompatible ${signatureFamily} thinking for ${targetFamily} model`);
+                    continue;
+                }
+
+                // Drop blocks with unknown signature origin for Gemini (cold cache - safe default)
+                if (isGeminiModel && !signatureFamily && targetFamily) {
+                    logger.debug(`[ContentConverter] Dropping thinking with unknown signature origin`);
+                    continue;
+                }
+
+                // Compatible - convert to Gemini format with signature
                 parts.push({
                     text: block.thinking,
                     thought: true,
                     thoughtSignature: block.signature
                 });
             }
-            // Unsigned thinking blocks are dropped upstream
+            // Unsigned thinking blocks are dropped (existing behavior)
         }
     }
 

package/src/format/request-converter.js

@@ -15,6 +15,7 @@ import {
     removeTrailingThinkingBlocks,
     reorderAssistantContent,
     filterUnsignedThinkingBlocks,
+    hasGeminiHistory,
     needsThinkingRecovery,
     closeToolLoopForThinking
 } from './thinking-utils.js';
@@ -78,12 +79,19 @@ export function convertAnthropicToGoogle(anthropicRequest) {
     }
 
     // Apply thinking recovery for Gemini thinking models when needed
-    // This handles corrupted tool loops where thinking blocks are stripped
-    // Claude models handle this differently and don't need this recovery
+    // Gemini needs recovery for tool loops/interrupted tools (stripped thinking)
     let processedMessages = messages;
+
     if (isGeminiModel && isThinking && needsThinkingRecovery(messages)) {
         logger.debug('[RequestConverter] Applying thinking recovery for Gemini');
-        processedMessages = closeToolLoopForThinking(messages);
+        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)');
+        processedMessages = closeToolLoopForThinking(messages, 'claude');
     }
 
     // Convert messages to contents, then filter unsigned thinking blocks
@@ -106,8 +114,10 @@ export function convertAnthropicToGoogle(anthropicRequest) {
         // SAFETY: Google API requires at least one part per content message
         // This happens when all thinking blocks are filtered out (unsigned)
         if (parts.length === 0) {
+            // Use '.' instead of '' because claude models reject empty text parts.
+            // A single period is invisible in practice but satisfies the API requirement.
             logger.warn('[RequestConverter] WARNING: Empty parts array after filtering, adding placeholder');
-            parts.push({ text: '' });
+            parts.push({ text: '.' });
         }
 
         const content = {

package/src/format/response-converter.js

@@ -4,8 +4,8 @@
  */
 
 import crypto from 'crypto';
-import { MIN_SIGNATURE_LENGTH } from '../constants.js';
-import { cacheSignature } from './signature-cache.js';
+import { MIN_SIGNATURE_LENGTH, getModelFamily } from '../constants.js';
+import { cacheSignature, cacheThinkingSignature } from './signature-cache.js';
 
 /**
  * Convert Google Generative AI response to Anthropic Messages API format
@@ -33,6 +33,12 @@ export function convertGoogleToAnthropic(googleResponse, model) {
             if (part.thought === true) {
                 const signature = part.thoughtSignature || '';
 
+                // Cache thinking signature with model family for cross-model compatibility
+                if (signature && signature.length >= MIN_SIGNATURE_LENGTH) {
+                    const modelFamily = getModelFamily(model);
+                    cacheThinkingSignature(signature, modelFamily);
+                }
+
                 // Include thinking blocks in the response for Claude Code
                 anthropicContent.push({
                     type: 'thinking',

package/src/format/signature-cache.js

@@ -5,11 +5,15 @@
  * Gemini models require thoughtSignature on tool calls, but Claude Code
  * strips non-standard fields. This cache stores signatures by tool_use_id
  * so they can be restored in subsequent requests.
+ *
+ * Also caches thinking block signatures with model family for cross-model
+ * compatibility checking.
  */
 
-import { GEMINI_SIGNATURE_CACHE_TTL_MS } from '../constants.js';
+import { GEMINI_SIGNATURE_CACHE_TTL_MS, MIN_SIGNATURE_LENGTH } from '../constants.js';
 
 const signatureCache = new Map();
+const thinkingSignatureCache = new Map();
 
 /**
  * Store a signature for a tool_use_id
@@ -54,6 +58,11 @@ export function cleanupCache() {
             signatureCache.delete(key);
         }
     }
+    for (const [key, entry] of thinkingSignatureCache) {
+        if (now - entry.timestamp > GEMINI_SIGNATURE_CACHE_TTL_MS) {
+            thinkingSignatureCache.delete(key);
+        }
+    }
 }
 
 /**
@@ -63,3 +72,43 @@ export function cleanupCache() {
 export function getCacheSize() {
     return signatureCache.size;
 }
+
+/**
+ * Cache a thinking block signature with its model family
+ * @param {string} signature - The thinking signature to cache
+ * @param {string} modelFamily - The model family ('claude' or 'gemini')
+ */
+export function cacheThinkingSignature(signature, modelFamily) {
+    if (!signature || signature.length < MIN_SIGNATURE_LENGTH) return;
+    thinkingSignatureCache.set(signature, {
+        modelFamily,
+        timestamp: Date.now()
+    });
+}
+
+/**
+ * Get the cached model family for a thinking signature
+ * @param {string} signature - The signature to look up
+ * @returns {string|null} 'claude', 'gemini', or null if not found/expired
+ */
+export function getCachedSignatureFamily(signature) {
+    if (!signature) return null;
+    const entry = thinkingSignatureCache.get(signature);
+    if (!entry) return null;
+
+    // Check TTL
+    if (Date.now() - entry.timestamp > GEMINI_SIGNATURE_CACHE_TTL_MS) {
+        thinkingSignatureCache.delete(signature);
+        return null;
+    }
+
+    return entry.modelFamily;
+}
+
+/**
+ * Get the current thinking signature cache size (for debugging)
+ * @returns {number} Number of entries in the thinking signature cache
+ */
+export function getThinkingCacheSize() {
+    return thinkingSignatureCache.size;
+}

package/src/format/thinking-utils.js

@@ -4,6 +4,7 @@
  */
 
 import { MIN_SIGNATURE_LENGTH } from '../constants.js';
+import { getCachedSignatureFamily } from './signature-cache.js';
 import { logger } from '../utils/logger.js';
 
 /**
@@ -26,6 +27,21 @@ export function hasValidSignature(part) {
     return typeof signature === 'string' && signature.length >= MIN_SIGNATURE_LENGTH;
 }
 
+/**
+ * Check if conversation history contains Gemini-style messages.
+ * Gemini puts thoughtSignature on tool_use blocks, Claude puts signature on thinking blocks.
+ * @param {Array<Object>} messages - Array of messages
+ * @returns {boolean} True if any tool_use has thoughtSignature (Gemini pattern)
+ */
+export function hasGeminiHistory(messages) {
+    return messages.some(msg =>
+        Array.isArray(msg.content) &&
+        msg.content.some(block =>
+            block.type === 'tool_use' && block.thoughtSignature !== undefined
+        )
+    );
+}
+
 /**
  * Sanitize a thinking part by keeping only allowed fields
  */
@@ -386,40 +402,83 @@ export function analyzeConversationState(messages) {
 
 /**
  * Check if conversation needs thinking recovery.
- * Returns true when:
- * 1. We're in a tool loop but have no valid thinking blocks, OR
- * 2. We have an interrupted tool with no valid thinking blocks
+ *
+ * Recovery is only needed when:
+ * 1. We're in a tool loop or have an interrupted tool, AND
+ * 2. No valid thinking blocks exist in the current turn
+ *
+ * Cross-model signature compatibility is handled by stripInvalidThinkingBlocks
+ * during recovery (not here).
  *
  * @param {Array<Object>} messages - Array of messages
  * @returns {boolean} True if thinking recovery is needed
  */
 export function needsThinkingRecovery(messages) {
     const state = analyzeConversationState(messages);
-    // Need recovery if (tool loop OR interrupted tool) AND no thinking
-    return (state.inToolLoop || state.interruptedTool) && !state.turnHasThinking;
+
+    // Recovery is only needed in tool loops or interrupted tools
+    if (!state.inToolLoop && !state.interruptedTool) return false;
+
+    // Need recovery if no valid thinking blocks exist
+    return !state.turnHasThinking;
 }
 
 /**
- * Strip all thinking blocks from messages.
+ * Strip invalid or incompatible thinking blocks from messages.
  * Used before injecting synthetic messages for recovery.
+ * Keeps valid thinking blocks to preserve context from previous turns.
  *
  * @param {Array<Object>} messages - Array of messages
- * @returns {Array<Object>} Messages with all thinking blocks removed
+ * @param {string} targetFamily - Target model family ('claude' or 'gemini')
+ * @returns {Array<Object>} Messages with invalid thinking blocks removed
  */
-function stripAllThinkingBlocks(messages) {
-    return messages.map(msg => {
+function stripInvalidThinkingBlocks(messages, targetFamily = null) {
+    let strippedCount = 0;
+
+    const result = messages.map(msg => {
         const content = msg.content || msg.parts;
         if (!Array.isArray(content)) return msg;
 
-        const filtered = content.filter(block => !isThinkingPart(block));
+        const filtered = content.filter(block => {
+            // Keep non-thinking blocks
+            if (!isThinkingPart(block)) return true;
 
+            // Check generic validity (has signature of sufficient length)
+            if (!hasValidSignature(block)) {
+                strippedCount++;
+                return false;
+            }
+
+            // Check family compatibility only for Gemini targets
+            // Claude can validate its own signatures, so we don't drop for Claude
+            if (targetFamily === 'gemini') {
+                const signature = block.thought === true ? block.thoughtSignature : block.signature;
+                const signatureFamily = getCachedSignatureFamily(signature);
+
+                // For Gemini: drop unknown or mismatched signatures
+                if (!signatureFamily || signatureFamily !== targetFamily) {
+                    strippedCount++;
+                    return false;
+                }
+            }
+
+            return true;
+        });
+
+        // Use '.' instead of '' because claude models reject empty text parts
         if (msg.content) {
-            return { ...msg, content: filtered.length > 0 ? filtered : [{ type: 'text', text: '' }] };
+            return { ...msg, content: filtered.length > 0 ? filtered : [{ type: 'text', text: '.' }] };
         } else if (msg.parts) {
-            return { ...msg, parts: filtered.length > 0 ? filtered : [{ text: '' }] };
+            return { ...msg, parts: filtered.length > 0 ? filtered : [{ text: '.' }] };
         }
         return msg;
     });
+
+    if (strippedCount > 0) {
+        logger.debug(`[ThinkingUtils] Stripped ${strippedCount} invalid/incompatible thinking block(s)`);
+    }
+
+    return result;
 }
 
 /**
@@ -432,16 +491,17 @@ function stripAllThinkingBlocks(messages) {
  * loop and allow the model to continue.
  *
  * @param {Array<Object>} messages - Array of messages
+ * @param {string} targetFamily - Target model family ('claude' or 'gemini')
  * @returns {Array<Object>} Modified messages with synthetic messages injected
  */
-export function closeToolLoopForThinking(messages) {
+export function closeToolLoopForThinking(messages, targetFamily = null) {
     const state = analyzeConversationState(messages);
 
     // Handle neither tool loop nor interrupted tool
     if (!state.inToolLoop && !state.interruptedTool) return messages;
 
-    // Strip all thinking blocks
-    let modified = stripAllThinkingBlocks(messages);
+    // Strip only invalid/incompatible thinking blocks (keep valid ones)
+    let modified = stripInvalidThinkingBlocks(messages, targetFamily);
 
     if (state.interruptedTool) {
         // For interrupted tools: just strip thinking and add a synthetic assistant message
@@ -457,7 +517,7 @@ export function closeToolLoopForThinking(messages) {
         });
 
         logger.debug('[ThinkingUtils] Applied thinking recovery for interrupted tool');
-    } else {
+    } else if (state.inToolLoop) {
         // For tool loops: add synthetic messages to close the loop
         const syntheticText = state.toolResultCount === 1
             ? '[Tool execution completed.]'

package/src/index.js

@@ -12,6 +12,7 @@ import os from 'os';
 // Parse command line arguments
 const args = process.argv.slice(2);
 const isDebug = args.includes('--debug') || process.env.DEBUG === 'true';
+const isFallbackEnabled = args.includes('--fallback') || process.env.FALLBACK === 'true';
 
 // Initialize logger
 logger.setDebug(isDebug);
@@ -20,6 +21,13 @@ if (isDebug) {
     logger.debug('Debug mode enabled');
 }
 
+if (isFallbackEnabled) {
+    logger.info('Model fallback mode enabled');
+}
+
+// Export fallback flag for server to use
+export const FALLBACK_ENABLED = isFallbackEnabled;
+
 const PORT = process.env.PORT || DEFAULT_PORT;
 
 // Home directory for account storage
@@ -40,14 +48,22 @@ app.listen(PORT, () => {
     if (!isDebug) {
         controlSection += '║    --debug            Enable debug logging                   ║\n';
     }
+    if (!isFallbackEnabled) {
+        controlSection += '║    --fallback         Enable model fallback on quota exhaust ║\n';
+    }
     controlSection += '║    Ctrl+C             Stop server                            ║';
 
-    // Build status section if debug mode is active
+    // Build status section if any modes are active
     let statusSection = '';
-    if (isDebug) {
+    if (isDebug || isFallbackEnabled) {
         statusSection = '║                                                              ║\n';
         statusSection += '║  Active Modes:                                               ║\n';
-        statusSection += '║    ✓ Debug mode enabled                                      ║\n';
+        if (isDebug) {
+            statusSection += '║    ✓ Debug mode enabled                                      ║\n';
+        }
+        if (isFallbackEnabled) {
+            statusSection += '║    ✓ Model fallback enabled                                  ║\n';
+        }
     }
 
     logger.log(`

package/src/server.js

@@ -13,6 +13,10 @@ import { AccountManager } from './account-manager/index.js';
 import { formatDuration } from './utils/helpers.js';
 import { logger } from './utils/logger.js';
 
+// Parse fallback flag directly from command line args to avoid circular dependency
+const args = process.argv.slice(2);
+const FALLBACK_ENABLED = args.includes('--fallback') || process.env.FALLBACK === 'true';
+
 const app = express();
 
 // Initialize account manager (will be fully initialized on first request or startup)
@@ -595,7 +599,7 @@ app.post('/v1/messages', async (req, res) => {
 
             try {
                 // Use the streaming generator with account manager
-                for await (const event of sendMessageStream(request, accountManager)) {
+                for await (const event of sendMessageStream(request, accountManager, FALLBACK_ENABLED)) {
                     res.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
                     // Flush after each event for real-time streaming
                     if (res.flush) res.flush();
@@ -616,7 +620,7 @@ app.post('/v1/messages', async (req, res) => {
 
         } else {
             // Handle non-streaming response
-            const response = await sendMessage(request, accountManager);
+            const response = await sendMessage(request, accountManager, FALLBACK_ENABLED);
             res.json(response);
         }