antigravity-claude-proxy 1.0.8 → 1.0.9

package/README.md

@@ -6,7 +6,7 @@
 
 <a href="https://buymeacoffee.com/badrinarayanans" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a>
 
-A proxy server that exposes an **Anthropic-compatible API** backed by **Antigravity's Cloud Code**, letting you use Claude models like sonnet and opus with **Claude Code CLI**.
+A proxy server that exposes an **Anthropic-compatible API** backed by **Antigravity's Cloud Code**, letting you use Claude and Gemini models with **Claude Code CLI**.
 
 ![Antigravity Claude Proxy Banner](images/banner.png)
 
@@ -145,7 +145,23 @@ Add this configuration:
     "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-4-5-thinking",
     "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-5-thinking",
     "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-sonnet-4-5",
-    "CLAUDE_CODE_SUBAGENT_MODEL": "claude-opus-4-5-thinking"
+    "CLAUDE_CODE_SUBAGENT_MODEL": "claude-sonnet-4-5"
+  }
+}
+```
+
+Or to use Gemini models:
+
+```json
+{
+  "env": {
+    "ANTHROPIC_AUTH_TOKEN": "test",
+    "ANTHROPIC_BASE_URL": "http://localhost:8080",
+    "ANTHROPIC_MODEL": "gemini-3-pro-high",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemini-3-pro-high",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemini-3-flash",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemini-3-flash",
+    "CLAUDE_CODE_SUBAGENT_MODEL": "gemini-2.5-flash-lite"
   }
 }
 ```
@@ -164,6 +180,8 @@ claude
 
 ## Available Models
 
+### Claude Models
+
 | Model ID | Description |
 |----------|-------------|
 | `claude-sonnet-4-5-thinking` | Claude Sonnet 4.5 with extended thinking |
@@ -174,6 +192,16 @@ Standard Anthropic model names are automatically mapped:
 - `claude-sonnet-4-5-20250514` → `claude-sonnet-4-5-thinking`
 - `claude-opus-4-5-20250514` → `claude-opus-4-5-thinking`
 
+### Gemini Models
+
+| Model ID | Description |
+|----------|-------------|
+| `gemini-3-flash` | Gemini 3 Flash with thinking |
+| `gemini-3-pro-low` | Gemini 3 Pro Low with thinking |
+| `gemini-3-pro-high` | Gemini 3 Pro High with thinking |
+
+Gemini models include full thinking support with `thoughtSignature` handling for multi-turn conversations.
+
 ---
 
 ## Multi-Account Load Balancing
@@ -326,4 +354,4 @@ MIT
 
 ## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=badri-s2001/antigravity-claude-proxy&type=date&legend=top-left)](https://www.star-history.com/#badri-s2001/antigravity-claude-proxy&type=date&legend=top-left)
+[![Star History Chart](https://api.star-history.com/svg?repos=badri-s2001/antigravity-claude-proxy&type=date&legend=top-left&cache-control=no-cache)](https://www.star-history.com/#badri-s2001/antigravity-claude-proxy&type=date&legend=top-left)

package/package.json

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

package/src/cloudcode-client.js

@@ -13,13 +13,13 @@ import crypto from 'crypto';
 import {
     ANTIGRAVITY_ENDPOINT_FALLBACKS,
     ANTIGRAVITY_HEADERS,
-    AVAILABLE_MODELS,
     MAX_RETRIES,
     MAX_WAIT_BEFORE_ERROR_MS,
-    MIN_SIGNATURE_LENGTH
+    MIN_SIGNATURE_LENGTH,
+    getModelFamily,
+    isThinkingModel
 } from './constants.js';
 import {
-    mapModelName,
     convertAnthropicToGoogle,
     convertGoogleToAnthropic
 } from './format-converter.js';
@@ -219,7 +219,7 @@ function parseResetTime(responseOrError, errorText = '') {
  * Build the wrapped request body for Cloud Code API
  */
 function buildCloudCodeRequest(anthropicRequest, projectId) {
-    const model = mapModelName(anthropicRequest.model);
+    const model = anthropicRequest.model;
     const googleRequest = convertAnthropicToGoogle(anthropicRequest);
 
     // Use stable session ID derived from first user message for cache continuity
@@ -246,9 +246,10 @@ function buildHeaders(token, model, accept = 'application/json') {
         ...ANTIGRAVITY_HEADERS
     };
 
-    // Add interleaved thinking header for Claude thinking models
-    const isThinkingModel = model.toLowerCase().includes('thinking');
-    if (isThinkingModel) {
+    const modelFamily = getModelFamily(model);
+
+    // Add interleaved thinking header only for Claude thinking models
+    if (modelFamily === 'claude' && isThinkingModel(model)) {
         headers['anthropic-beta'] = 'interleaved-thinking-2025-05-14';
     }
 
@@ -273,8 +274,8 @@ function buildHeaders(token, model, accept = 'application/json') {
  * @throws {Error} If max retries exceeded or no accounts available
  */
 export async function sendMessage(anthropicRequest, accountManager) {
-    const model = mapModelName(anthropicRequest.model);
-    const isThinkingModel = model.toLowerCase().includes('thinking');
+    const model = anthropicRequest.model;
+    const isThinking = isThinkingModel(model);
 
     // Retry loop with account failover
     // Ensure we try at least as many times as there are accounts to cycle through everyone
@@ -332,13 +333,13 @@ export async function sendMessage(anthropicRequest, accountManager) {
             let lastError = null;
             for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
                 try {
-                    const url = isThinkingModel
+                    const url = isThinking
                         ? `${endpoint}/v1internal:streamGenerateContent?alt=sse`
                         : `${endpoint}/v1internal:generateContent`;
 
                     const response = await fetch(url, {
                         method: 'POST',
-                        headers: buildHeaders(token, model, isThinkingModel ? 'text/event-stream' : 'application/json'),
+                        headers: buildHeaders(token, model, isThinking ? 'text/event-stream' : 'application/json'),
                         body: JSON.stringify(payload)
                     });
 
@@ -372,7 +373,7 @@ export async function sendMessage(anthropicRequest, accountManager) {
                     }
 
                     // For thinking models, parse SSE and accumulate all parts
-                    if (isThinkingModel) {
+                    if (isThinking) {
                         return await parseThinkingSSEResponse(response, anthropicRequest.model);
                     }
 
@@ -537,7 +538,7 @@ async function parseThinkingSSEResponse(response, originalModel) {
  * @throws {Error} If max retries exceeded or no accounts available
  */
 export async function* sendMessageStream(anthropicRequest, accountManager) {
-    const model = mapModelName(anthropicRequest.model);
+    const model = anthropicRequest.model;
 
     // Retry loop with account failover
     // Ensure we try at least as many times as there are accounts to cycle through everyone
@@ -814,6 +815,10 @@ async function* streamSSEResponse(response, originalModel) {
 
                     } else if (part.functionCall) {
                         // Handle tool use
+                        // For Gemini 3+, capture thoughtSignature from the functionCall part
+                        // The signature is a sibling to functionCall, not inside it
+                        const functionCallSignature = part.thoughtSignature || '';
+
                         if (currentBlockType === 'thinking' && currentThinkingSignature) {
                             yield {
                                 type: 'content_block_delta',
@@ -831,15 +836,24 @@ async function* streamSSEResponse(response, originalModel) {
 
                         const toolId = part.functionCall.id || `toolu_${crypto.randomBytes(12).toString('hex')}`;
 
+                        // For Gemini, include the thoughtSignature in the tool_use block
+                        // so it can be sent back in subsequent requests
+                        const toolUseBlock = {
+                            type: 'tool_use',
+                            id: toolId,
+                            name: part.functionCall.name,
+                            input: {}
+                        };
+
+                        // Store the signature in the tool_use block for later retrieval
+                        if (functionCallSignature && functionCallSignature.length >= MIN_SIGNATURE_LENGTH) {
+                            toolUseBlock.thoughtSignature = functionCallSignature;
+                        }
+
                         yield {
                             type: 'content_block_start',
                             index: blockIndex,
-                            content_block: {
-                                type: 'tool_use',
-                                id: toolId,
-                                name: part.functionCall.name,
-                                input: {}
-                            }
+                            content_block: toolUseBlock
                         };
 
                         yield {
@@ -931,19 +945,28 @@ async function* streamSSEResponse(response, originalModel) {
 
 /**
  * List available models in Anthropic API format
+ * Fetches models dynamically from the Cloud Code API
  *
- * @returns {{object: string, data: Array<{id: string, object: string, created: number, owned_by: string, description: string}>}} List of available models
+ * @param {string} token - OAuth access token
+ * @returns {Promise<{object: string, data: Array<{id: string, object: string, created: number, owned_by: string, description: string}>}>} List of available models
  */
-export function listModels() {
+export async function listModels(token) {
+    const data = await fetchAvailableModels(token);
+    if (!data || !data.models) {
+        return { object: 'list', data: [] };
+    }
+
+    const modelList = Object.entries(data.models).map(([modelId, modelData]) => ({
+        id: modelId,
+        object: 'model',
+        created: Math.floor(Date.now() / 1000),
+        owned_by: 'anthropic',
+        description: modelData.displayName || modelId
+    }));
+
     return {
         object: 'list',
-        data: AVAILABLE_MODELS.map(m => ({
-            id: m.id,
-            object: 'model',
-            created: Math.floor(Date.now() / 1000),
-            owned_by: 'anthropic',
-            description: m.description
-        }))
+        data: modelList
     };
 }
 

package/src/constants.js

@@ -56,44 +56,6 @@ export const ANTIGRAVITY_HEADERS = {
     })
 };
 
-// Model name mappings: Anthropic format → Antigravity format
-export const MODEL_MAPPINGS = {
-    // Claude models
-    'claude-3-opus-20240229': 'claude-opus-4-5-thinking',
-    'claude-3-5-opus-20240229': 'claude-opus-4-5-thinking',
-    'claude-3-5-sonnet-20241022': 'claude-sonnet-4-5',
-    'claude-3-5-sonnet-20240620': 'claude-sonnet-4-5',
-    'claude-3-sonnet-20240229': 'claude-sonnet-4-5',
-    'claude-sonnet-4-5': 'claude-sonnet-4-5',
-    'claude-sonnet-4-5-thinking': 'claude-sonnet-4-5-thinking',
-    'claude-opus-4-5-thinking': 'claude-opus-4-5-thinking'
-};
-
-// Available models exposed by this proxy
-export const AVAILABLE_MODELS = [
-    {
-        id: 'claude-sonnet-4-5',
-        name: 'Claude Sonnet 4.5 (Antigravity)',
-        description: 'Claude Sonnet 4.5 via Antigravity Cloud Code',
-        context: 200000,
-        output: 64000
-    },
-    {
-        id: 'claude-sonnet-4-5-thinking',
-        name: 'Claude Sonnet 4.5 Thinking (Antigravity)',
-        description: 'Claude Sonnet 4.5 with extended thinking via Antigravity',
-        context: 200000,
-        output: 64000
-    },
-    {
-        id: 'claude-opus-4-5-thinking',
-        name: 'Claude Opus 4.5 Thinking (Antigravity)',
-        description: 'Claude Opus 4.5 with extended thinking via Antigravity',
-        context: 200000,
-        output: 64000
-    }
-];
-
 // Default project ID if none can be discovered
 export const DEFAULT_PROJECT_ID = 'rising-fact-p41fc';
 
@@ -120,9 +82,42 @@ export const MAX_ACCOUNTS = 10; // Maximum number of accounts allowed
 export const MAX_WAIT_BEFORE_ERROR_MS = 120000; // 2 minutes - throw error if wait exceeds this
 
 // Thinking model constants
-export const CLAUDE_THINKING_MAX_OUTPUT_TOKENS = 64000; // Max output tokens for thinking models
 export const MIN_SIGNATURE_LENGTH = 50; // Minimum valid thinking signature length
 
+// Gemini-specific limits
+export const GEMINI_MAX_OUTPUT_TOKENS = 16384;
+
+/**
+ * Get the model family from model name (dynamic detection, no hardcoded list).
+ * @param {string} modelName - The model name from the request
+ * @returns {'claude' | 'gemini' | 'unknown'} The model family
+ */
+export function getModelFamily(modelName) {
+    const lower = (modelName || '').toLowerCase();
+    if (lower.includes('claude')) return 'claude';
+    if (lower.includes('gemini')) return 'gemini';
+    return 'unknown';
+}
+
+/**
+ * Check if a model supports thinking/reasoning output.
+ * @param {string} modelName - The model name from the request
+ * @returns {boolean} True if the model supports thinking blocks
+ */
+export function isThinkingModel(modelName) {
+    const lower = (modelName || '').toLowerCase();
+    // Claude thinking models have "thinking" in the name
+    if (lower.includes('claude') && lower.includes('thinking')) return true;
+    // Gemini thinking models: explicit "thinking" in name, OR gemini version 3+
+    if (lower.includes('gemini')) {
+        if (lower.includes('thinking')) return true;
+        // 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;
+}
+
 // Google OAuth configuration (from opencode-antigravity-auth)
 export const OAUTH_CONFIG = {
     clientId: '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com',
@@ -144,8 +139,6 @@ export const OAUTH_REDIRECT_URI = `http://localhost:${OAUTH_CONFIG.callbackPort}
 export default {
     ANTIGRAVITY_ENDPOINT_FALLBACKS,
     ANTIGRAVITY_HEADERS,
-    MODEL_MAPPINGS,
-    AVAILABLE_MODELS,
     DEFAULT_PROJECT_ID,
     TOKEN_REFRESH_INTERVAL_MS,
     REQUEST_BODY_LIMIT,
@@ -157,8 +150,10 @@ export default {
     MAX_RETRIES,
     MAX_ACCOUNTS,
     MAX_WAIT_BEFORE_ERROR_MS,
-    CLAUDE_THINKING_MAX_OUTPUT_TOKENS,
     MIN_SIGNATURE_LENGTH,
+    GEMINI_MAX_OUTPUT_TOKENS,
+    getModelFamily,
+    isThinkingModel,
     OAUTH_CONFIG,
     OAUTH_REDIRECT_URI
 };

package/src/format-converter.js

@@ -9,19 +9,19 @@
 
 import crypto from 'crypto';
 import {
-    MODEL_MAPPINGS,
-    CLAUDE_THINKING_MAX_OUTPUT_TOKENS,
-    MIN_SIGNATURE_LENGTH
+    MIN_SIGNATURE_LENGTH,
+    GEMINI_MAX_OUTPUT_TOKENS,
+    getModelFamily,
+    isThinkingModel
 } from './constants.js';
 
 /**
- * Map Anthropic model name to Antigravity model name
- * @param {string} anthropicModel - Anthropic format model name (e.g., 'claude-3-5-sonnet-20241022')
- * @returns {string} Antigravity format model name (e.g., 'claude-sonnet-4-5')
+ * Sentinel value to skip thought signature validation for Gemini models.
+ * Per Google documentation, this value can be used when Claude Code strips
+ * the thoughtSignature field from tool_use blocks in multi-turn requests.
+ * See: https://ai.google.dev/gemini-api/docs/thought-signatures
  */
-export function mapModelName(anthropicModel) {
-    return MODEL_MAPPINGS[anthropicModel] || anthropicModel;
-}
+const GEMINI_SKIP_SIGNATURE = 'skip_thought_signature_validator';
 
 /**
  * Check if a part is a thinking block
@@ -283,7 +283,7 @@ export function reorderAssistantContent(content) {
 /**
  * Convert Anthropic message content to Google Generative AI parts
  */
-function convertContentToParts(content, isClaudeModel = false) {
+function convertContentToParts(content, isClaudeModel = false, isGeminiModel = false) {
     if (typeof content === 'string') {
         return [{ text: content }];
     }
@@ -348,7 +348,19 @@ function convertContentToParts(content, isClaudeModel = false) {
                 functionCall.id = block.id;
             }
 
-            parts.push({ functionCall });
+            // Build the part with functionCall
+            const part = { functionCall };
+
+            // For Gemini models, include thoughtSignature at the part level
+            // This is required by Gemini 3+ for tool calls to work correctly
+            if (isGeminiModel) {
+                // Use thoughtSignature from the block if Claude Code preserved it
+                // Otherwise, use the sentinel value to skip validation (Claude Code strips non-standard fields)
+                // See: https://ai.google.dev/gemini-api/docs/thought-signatures
+                part.thoughtSignature = block.thoughtSignature || GEMINI_SKIP_SIGNATURE;
+            }
+
+            parts.push(part);
         } else if (block.type === 'tool_result') {
             // Convert tool_result to functionResponse (Google format)
             let responseContent = block.content;
@@ -411,8 +423,10 @@ function convertRole(role) {
 export function convertAnthropicToGoogle(anthropicRequest) {
     const { messages, system, max_tokens, temperature, top_p, top_k, stop_sequences, tools, tool_choice, thinking } = anthropicRequest;
     const modelName = anthropicRequest.model || '';
-    const isClaudeModel = modelName.toLowerCase().includes('claude');
-    const isClaudeThinkingModel = isClaudeModel && modelName.toLowerCase().includes('thinking');
+    const modelFamily = getModelFamily(modelName);
+    const isClaudeModel = modelFamily === 'claude';
+    const isGeminiModel = modelFamily === 'gemini';
+    const isThinking = isThinkingModel(modelName);
 
     const googleRequest = {
         contents: [],
@@ -440,7 +454,7 @@ export function convertAnthropicToGoogle(anthropicRequest) {
     }
 
     // Add interleaved thinking hint for Claude thinking models with tools
-    if (isClaudeThinkingModel && tools && tools.length > 0) {
+    if (isClaudeModel && isThinking && tools && tools.length > 0) {
         const hint = 'Interleaved thinking is enabled. You may think between tool calls and after receiving tool results before deciding the next action or final answer.';
         if (!googleRequest.systemInstruction) {
             googleRequest.systemInstruction = { parts: [{ text: hint }] };
@@ -469,7 +483,7 @@ export function convertAnthropicToGoogle(anthropicRequest) {
             msgContent = reorderAssistantContent(msgContent);
         }
 
-        const parts = convertContentToParts(msgContent, isClaudeModel);
+        const parts = convertContentToParts(msgContent, isClaudeModel, isGeminiModel);
         const content = {
             role: convertRole(msg.role),
             parts: parts
@@ -499,29 +513,34 @@ export function convertAnthropicToGoogle(anthropicRequest) {
         googleRequest.generationConfig.stopSequences = stop_sequences;
     }
 
-    // Enable thinking for Claude thinking models
-    if (isClaudeThinkingModel) {
-        const thinkingConfig = {
-            include_thoughts: true
-        };
-
-        // Only set thinking_budget if explicitly provided
-        const thinkingBudget = thinking?.budget_tokens;
-        if (thinkingBudget) {
-            thinkingConfig.thinking_budget = thinkingBudget;
+    // Enable thinking for thinking models (Claude and Gemini 3+)
+    if (isThinking) {
+        if (isClaudeModel) {
+            // Claude thinking config
+            const thinkingConfig = {
+                include_thoughts: true
+            };
 
-            // Ensure maxOutputTokens is large enough when budget is specified
-            if (!googleRequest.generationConfig.maxOutputTokens ||
-                googleRequest.generationConfig.maxOutputTokens <= thinkingBudget) {
-                googleRequest.generationConfig.maxOutputTokens = CLAUDE_THINKING_MAX_OUTPUT_TOKENS;
+            // Only set thinking_budget if explicitly provided
+            const thinkingBudget = thinking?.budget_tokens;
+            if (thinkingBudget) {
+                thinkingConfig.thinking_budget = thinkingBudget;
+                console.log('[FormatConverter] Claude thinking enabled with budget:', thinkingBudget);
+            } else {
+                console.log('[FormatConverter] Claude thinking enabled (no budget specified)');
             }
 
-            console.log('[FormatConverter] Thinking enabled with budget:', thinkingBudget);
-        } else {
-            console.log('[FormatConverter] Thinking enabled (no budget specified)');
-        }
+            googleRequest.generationConfig.thinkingConfig = thinkingConfig;
+        } else if (isGeminiModel) {
+            // Gemini thinking config (uses camelCase)
+            const thinkingConfig = {
+                includeThoughts: true,
+                thinkingBudget: thinking?.budget_tokens || 16000
+            };
+            console.log('[FormatConverter] Gemini thinking enabled with budget:', thinkingConfig.thinkingBudget);
 
-        googleRequest.generationConfig.thinkingConfig = thinkingConfig;
+            googleRequest.generationConfig.thinkingConfig = thinkingConfig;
+        }
     }
 
     // Convert tools to Google format
@@ -541,10 +560,18 @@ export function convertAnthropicToGoogle(anthropicRequest) {
                 || tool.parameters
                 || { type: 'object' };
 
+            // Sanitize schema for general compatibility
+            let parameters = sanitizeSchema(schema);
+
+            // For Gemini models, apply additional cleaning for VALIDATED mode
+            if (isGeminiModel) {
+                parameters = cleanSchemaForGemini(parameters);
+            }
+
             return {
                 name: String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64),
                 description: description,
-                parameters: sanitizeSchema(schema)
+                parameters
             };
         });
 
@@ -552,6 +579,12 @@ export function convertAnthropicToGoogle(anthropicRequest) {
         console.log('[FormatConverter] Tools:', JSON.stringify(googleRequest.tools).substring(0, 300));
     }
 
+    // Cap max tokens for Gemini models
+    if (isGeminiModel && googleRequest.generationConfig.maxOutputTokens > GEMINI_MAX_OUTPUT_TOKENS) {
+        console.log(`[FormatConverter] Capping Gemini max_tokens from ${googleRequest.generationConfig.maxOutputTokens} to ${GEMINI_MAX_OUTPUT_TOKENS}`);
+        googleRequest.generationConfig.maxOutputTokens = GEMINI_MAX_OUTPUT_TOKENS;
+    }
+
     return googleRequest;
 }
 
@@ -638,6 +671,63 @@ function sanitizeSchema(schema) {
     return sanitized;
 }
 
+/**
+ * Cleans JSON schema for Gemini API compatibility.
+ * Removes unsupported fields that cause VALIDATED mode errors.
+ *
+ * Gemini's VALIDATED mode rejects schemas with certain JSON Schema keywords
+ * that are not supported by the Gemini API.
+ *
+ * @param {Object} schema - The JSON schema to clean
+ * @returns {Object} Cleaned schema safe for Gemini API
+ */
+function cleanSchemaForGemini(schema) {
+    if (!schema || typeof schema !== 'object') return schema;
+    if (Array.isArray(schema)) return schema.map(cleanSchemaForGemini);
+
+    const result = { ...schema };
+
+    // Remove unsupported keywords that cause VALIDATED mode errors
+    const unsupported = [
+        'additionalProperties', 'default', '$schema', '$defs',
+        'definitions', '$ref', '$id', '$comment', 'title',
+        'minLength', 'maxLength', 'pattern', 'format',
+        'minItems', 'maxItems', 'examples'
+    ];
+
+    for (const key of unsupported) {
+        delete result[key];
+    }
+
+    // Check for unsupported 'format' in string types
+    if (result.type === 'string' && result.format) {
+        const allowed = ['enum', 'date-time'];
+        if (!allowed.includes(result.format)) {
+            delete result.format;
+        }
+    }
+
+    // Recursively clean nested schemas
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === 'object' && value !== null) {
+            result[key] = cleanSchemaForGemini(value);
+        }
+    }
+
+    // Validate that required array only contains properties that exist
+    // Gemini's VALIDATED mode requires this
+    if (result.required && Array.isArray(result.required) && result.properties) {
+        const definedProps = new Set(Object.keys(result.properties));
+        result.required = result.required.filter(prop => definedProps.has(prop));
+        // If required is now empty, remove it
+        if (result.required.length === 0) {
+            delete result.required;
+        }
+    }
+
+    return result;
+}
+
 /**
  * Convert Google Generative AI response to Anthropic Messages API format
  *
@@ -679,12 +769,20 @@ export function convertGoogleToAnthropic(googleResponse, model) {
         } else if (part.functionCall) {
             // Convert functionCall to tool_use
             // Use the id from the response if available, otherwise generate one
-            anthropicContent.push({
+            const toolId = part.functionCall.id || `toolu_${crypto.randomBytes(12).toString('hex')}`;
+            const toolUseBlock = {
                 type: 'tool_use',
-                id: part.functionCall.id || `toolu_${crypto.randomBytes(12).toString('hex')}`,
+                id: toolId,
                 name: part.functionCall.name,
                 input: part.functionCall.args || {}
-            });
+            };
+
+            // For Gemini 3+, include thoughtSignature from the part level
+            if (part.thoughtSignature && part.thoughtSignature.length >= MIN_SIGNATURE_LENGTH) {
+                toolUseBlock.thoughtSignature = part.thoughtSignature;
+            }
+
+            anthropicContent.push(toolUseBlock);
             hasToolCalls = true;
         }
     }
@@ -725,7 +823,6 @@ export function convertGoogleToAnthropic(googleResponse, model) {
 }
 
 export default {
-    mapModelName,
     convertAnthropicToGoogle,
     convertGoogleToAnthropic
 };

package/src/server.js

@@ -193,7 +193,7 @@ app.get('/account-limits', async (req, res) => {
             }
         }
 
-        const sortedModels = Array.from(allModelIds).filter(m => m.includes('claude')).sort();
+        const sortedModels = Array.from(allModelIds).sort();
 
         // Return ASCII table format
         if (format === 'table') {
@@ -352,8 +352,32 @@ app.post('/refresh-token', async (req, res) => {
 /**
  * List models endpoint (OpenAI-compatible format)
  */
-app.get('/v1/models', (req, res) => {
-    res.json(listModels());
+app.get('/v1/models', async (req, res) => {
+    try {
+        await ensureInitialized();
+        const account = accountManager.pickNext();
+        if (!account) {
+            return res.status(503).json({
+                type: 'error',
+                error: {
+                    type: 'api_error',
+                    message: 'No accounts available'
+                }
+            });
+        }
+        const token = await accountManager.getTokenForAccount(account);
+        const models = await listModels(token);
+        res.json(models);
+    } catch (error) {
+        console.error('[API] Error listing models:', error);
+        res.status(500).json({
+            type: 'error',
+            error: {
+                type: 'api_error',
+                message: error.message
+            }
+        });
+    }
 });
 
 /**