@kamel-ahmed/proxy-claude 1.0.0

package/src/format/content-converter.js

@@ -0,0 +1,193 @@
+/**
+ * Content Converter
+ * Converts Anthropic message content to Google Generative AI parts format
+ */
+
+import { MIN_SIGNATURE_LENGTH, GEMINI_SKIP_SIGNATURE } from '../constants.js';
+import { getCachedSignature, getCachedSignatureFamily } from './signature-cache.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Convert Anthropic role to Google role
+ * @param {string} role - Anthropic role ('user', 'assistant')
+ * @returns {string} Google role ('user', 'model')
+ */
+export function convertRole(role) {
+    if (role === 'assistant') return 'model';
+    if (role === 'user') return 'user';
+    return 'user'; // Default to user
+}
+
+/**
+ * Convert Anthropic message content to Google Generative AI parts
+ * @param {string|Array} content - Anthropic message content
+ * @param {boolean} isClaudeModel - Whether the model is a Claude model
+ * @param {boolean} isGeminiModel - Whether the model is a Gemini model
+ * @returns {Array} Google Generative AI parts array
+ */
+export function convertContentToParts(content, isClaudeModel = false, isGeminiModel = false) {
+    if (typeof content === 'string') {
+        return [{ text: content }];
+    }
+
+    if (!Array.isArray(content)) {
+        return [{ text: String(content) }];
+    }
+
+    const parts = [];
+    const deferredInlineData = []; // Collect inlineData to add at the end (Issue #91)
+
+    for (const block of content) {
+        if (!block) continue;
+
+        if (block.type === 'text') {
+            // Skip empty text blocks - they cause API errors
+            if (block.text && block.text.trim()) {
+                parts.push({ text: block.text });
+            }
+        } else if (block.type === 'image') {
+            // Handle image content
+            if (block.source?.type === 'base64') {
+                // Base64-encoded image
+                parts.push({
+                    inlineData: {
+                        mimeType: block.source.media_type,
+                        data: block.source.data
+                    }
+                });
+            } else if (block.source?.type === 'url') {
+                // URL-referenced image
+                parts.push({
+                    fileData: {
+                        mimeType: block.source.media_type || 'image/jpeg',
+                        fileUri: block.source.url
+                    }
+                });
+            }
+        } else if (block.type === 'document') {
+            // Handle document content (e.g. PDF)
+            if (block.source?.type === 'base64') {
+                parts.push({
+                    inlineData: {
+                        mimeType: block.source.media_type,
+                        data: block.source.data
+                    }
+                });
+            } else if (block.source?.type === 'url') {
+                parts.push({
+                    fileData: {
+                        mimeType: block.source.media_type || 'application/pdf',
+                        fileUri: block.source.url
+                    }
+                });
+            }
+        } else if (block.type === 'tool_use') {
+            // Convert tool_use to functionCall (Google format)
+            // For Claude models, include the id field
+            const functionCall = {
+                name: block.name,
+                args: block.input || {}
+            };
+
+            if (isClaudeModel && block.id) {
+                functionCall.id = block.id;
+            }
+
+            // 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) {
+                // Priority: block.thoughtSignature > cache > GEMINI_SKIP_SIGNATURE
+                let signature = block.thoughtSignature;
+
+                if (!signature && block.id) {
+                    signature = getCachedSignature(block.id);
+                    if (signature) {
+                        logger.debug(`[ContentConverter] Restored signature from cache for: ${block.id}`);
+                    }
+                }
+
+                part.thoughtSignature = signature || GEMINI_SKIP_SIGNATURE;
+            }
+
+            parts.push(part);
+        } else if (block.type === 'tool_result') {
+            // Convert tool_result to functionResponse (Google format)
+            let responseContent = block.content;
+            let imageParts = [];
+
+            if (typeof responseContent === 'string') {
+                responseContent = { result: responseContent };
+            } else if (Array.isArray(responseContent)) {
+                // Extract images from tool results first (e.g., from Read tool reading image files)
+                for (const item of responseContent) {
+                    if (item.type === 'image' && item.source?.type === 'base64') {
+                        imageParts.push({
+                            inlineData: {
+                                mimeType: item.source.media_type,
+                                data: item.source.data
+                            }
+                        });
+                    }
+                }
+
+                // Extract text content
+                const texts = responseContent
+                    .filter(c => c.type === 'text')
+                    .map(c => c.text)
+                    .join('\n');
+                responseContent = { result: texts || (imageParts.length > 0 ? 'Image attached' : '') };
+            }
+
+            const functionResponse = {
+                name: block.tool_use_id || 'unknown',
+                response: responseContent
+            };
+
+            // For Claude models, the id field must match the tool_use_id
+            if (isClaudeModel && block.tool_use_id) {
+                functionResponse.id = block.tool_use_id;
+            }
+
+            parts.push({ functionResponse });
+
+            // 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) {
+                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 (existing behavior)
+        }
+    }
+
+    // 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/index.js

@@ -0,0 +1,20 @@
+/**
+ * Format Converter Module
+ * Converts between Anthropic Messages API format and Google Generative AI format
+ */
+
+// Re-export all from each module
+export * from './request-converter.js';
+export * from './response-converter.js';
+export * from './content-converter.js';
+export * from './schema-sanitizer.js';
+export * from './thinking-utils.js';
+
+// Default export for backward compatibility
+import { convertAnthropicToGoogle } from './request-converter.js';
+import { convertGoogleToAnthropic } from './response-converter.js';
+
+export default {
+    convertAnthropicToGoogle,
+    convertGoogleToAnthropic
+};

package/src/format/request-converter.js

@@ -0,0 +1,248 @@
+/**
+ * Request Converter
+ * Converts Anthropic Messages API requests to Google Generative AI format
+ */
+
+import {
+    GEMINI_MAX_OUTPUT_TOKENS,
+    getModelFamily,
+    isThinkingModel
+} from '../constants.js';
+import { convertContentToParts, convertRole } from './content-converter.js';
+import { sanitizeSchema, cleanSchema } from './schema-sanitizer.js';
+import {
+    restoreThinkingSignatures,
+    removeTrailingThinkingBlocks,
+    reorderAssistantContent,
+    filterUnsignedThinkingBlocks,
+    hasGeminiHistory,
+    hasUnsignedThinkingBlocks,
+    needsThinkingRecovery,
+    closeToolLoopForThinking
+} from './thinking-utils.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Convert Anthropic Messages API request to the format expected by Cloud Code
+ *
+ * Uses Google Generative AI format, but for Claude models:
+ * - Keeps tool_result in Anthropic format (required by Claude API)
+ *
+ * @param {Object} anthropicRequest - Anthropic format request
+ * @returns {Object} Request body for Cloud Code API
+ */
+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 modelFamily = getModelFamily(modelName);
+    const isClaudeModel = modelFamily === 'claude';
+    const isGeminiModel = modelFamily === 'gemini';
+    const isThinking = isThinkingModel(modelName);
+
+    const googleRequest = {
+        contents: [],
+        generationConfig: {}
+    };
+
+    // Handle system instruction
+    if (system) {
+        let systemParts = [];
+        if (typeof system === 'string') {
+            systemParts = [{ text: system }];
+        } else if (Array.isArray(system)) {
+            // Filter for text blocks as system prompts are usually text
+            // Anthropic supports text blocks in system prompts
+            systemParts = system
+                .filter(block => block.type === 'text')
+                .map(block => ({ text: block.text }));
+        }
+
+        if (systemParts.length > 0) {
+            googleRequest.systemInstruction = {
+                parts: systemParts
+            };
+        }
+    }
+
+    // Add interleaved thinking hint for Claude thinking models with tools
+    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 }] };
+        } else {
+            const lastPart = googleRequest.systemInstruction.parts[googleRequest.systemInstruction.parts.length - 1];
+            if (lastPart && lastPart.text) {
+                lastPart.text = `${lastPart.text}\n\n${hint}`;
+            } else {
+                googleRequest.systemInstruction.parts.push({ text: hint });
+            }
+        }
+    }
+
+    // Apply thinking recovery for Gemini thinking models when needed
+    // 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, '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 (const msg of processedMessages) {
+        let msgContent = msg.content;
+
+        // For assistant messages, process thinking blocks and reorder content
+        if ((msg.role === 'assistant' || msg.role === 'model') && Array.isArray(msgContent)) {
+            // First, try to restore signatures for unsigned thinking blocks from cache
+            msgContent = restoreThinkingSignatures(msgContent);
+            // Remove trailing unsigned thinking blocks
+            msgContent = removeTrailingThinkingBlocks(msgContent);
+            // Reorder: thinking first, then text, then tool_use
+            msgContent = reorderAssistantContent(msgContent);
+        }
+
+        const parts = convertContentToParts(msgContent, isClaudeModel, isGeminiModel);
+
+        // 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: '.' });
+        }
+
+        const content = {
+            role: convertRole(msg.role),
+            parts: parts
+        };
+        googleRequest.contents.push(content);
+    }
+
+    // Filter unsigned thinking blocks for Claude models
+    if (isClaudeModel) {
+        googleRequest.contents = filterUnsignedThinkingBlocks(googleRequest.contents);
+    }
+
+    // Generation config
+    if (max_tokens) {
+        googleRequest.generationConfig.maxOutputTokens = max_tokens;
+    }
+    if (temperature !== undefined) {
+        googleRequest.generationConfig.temperature = temperature;
+    }
+    if (top_p !== undefined) {
+        googleRequest.generationConfig.topP = top_p;
+    }
+    if (top_k !== undefined) {
+        googleRequest.generationConfig.topK = top_k;
+    }
+    if (stop_sequences && stop_sequences.length > 0) {
+        googleRequest.generationConfig.stopSequences = stop_sequences;
+    }
+
+    // Enable thinking for thinking models (Claude and Gemini 3+)
+    if (isThinking) {
+        if (isClaudeModel) {
+            // Claude thinking config
+            const thinkingConfig = {
+                include_thoughts: true
+            };
+
+            // Only set thinking_budget if explicitly provided
+            const thinkingBudget = thinking?.budget_tokens;
+            if (thinkingBudget) {
+                thinkingConfig.thinking_budget = thinkingBudget;
+                logger.debug(`[RequestConverter] Claude thinking enabled with budget: ${thinkingBudget}`);
+
+                // Validate max_tokens > thinking_budget as required by the API
+                const currentMaxTokens = googleRequest.generationConfig.maxOutputTokens;
+                if (currentMaxTokens && currentMaxTokens <= thinkingBudget) {
+                    // Bump max_tokens to allow for some response content
+                    // Default to budget + 8192 (standard output buffer)
+                    const adjustedMaxTokens = thinkingBudget + 8192;
+                    logger.warn(`[RequestConverter] max_tokens (${currentMaxTokens}) <= thinking_budget (${thinkingBudget}). Adjusting to ${adjustedMaxTokens} to satisfy API requirements`);
+                    googleRequest.generationConfig.maxOutputTokens = adjustedMaxTokens;
+                }
+            } else {
+                logger.debug('[RequestConverter] Claude 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
+            };
+            logger.debug(`[RequestConverter] Gemini thinking enabled with budget: ${thinkingConfig.thinkingBudget}`);
+
+
+            googleRequest.generationConfig.thinkingConfig = thinkingConfig;
+        }
+    }
+
+    // Convert tools to Google format
+    if (tools && tools.length > 0) {
+        const functionDeclarations = tools.map((tool, idx) => {
+            // Extract name from various possible locations
+            const name = tool.name || tool.function?.name || tool.custom?.name || `tool-${idx}`;
+
+            // Extract description from various possible locations
+            const description = tool.description || tool.function?.description || tool.custom?.description || '';
+
+            // Extract schema from various possible locations
+            const schema = tool.input_schema
+                || tool.function?.input_schema
+                || tool.function?.parameters
+                || tool.custom?.input_schema
+                || tool.parameters
+                || { type: 'object' };
+
+            // Sanitize schema for general compatibility
+            let parameters = sanitizeSchema(schema);
+
+            // Apply Google-format cleaning for ALL models since they all go through
+            // Cloud Code API which validates schemas using Google's protobuf format.
+            // This fixes issue #82: /compact command fails with schema transformation error
+            // "Proto field is not repeating, cannot start list" for Claude models.
+            parameters = cleanSchema(parameters);
+
+            return {
+                name: String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64),
+                description: description,
+                parameters
+            };
+        });
+
+        googleRequest.tools = [{ functionDeclarations }];
+        logger.debug(`[RequestConverter] Tools: ${JSON.stringify(googleRequest.tools).substring(0, 300)}`);
+
+        // For Claude models, set functionCallingConfig.mode = "VALIDATED"
+        // This ensures strict parameter validation (matches opencode-antigravity-auth)
+        if (isClaudeModel) {
+            googleRequest.toolConfig = {
+                functionCallingConfig: {
+                    mode: 'VALIDATED'
+                }
+            };
+        }
+    }
+
+    // Cap max tokens for Gemini models
+    if (isGeminiModel && googleRequest.generationConfig.maxOutputTokens > GEMINI_MAX_OUTPUT_TOKENS) {
+        logger.debug(`[RequestConverter] Capping Gemini max_tokens from ${googleRequest.generationConfig.maxOutputTokens} to ${GEMINI_MAX_OUTPUT_TOKENS}`);
+        googleRequest.generationConfig.maxOutputTokens = GEMINI_MAX_OUTPUT_TOKENS;
+    }
+
+    return googleRequest;
+}

package/src/format/response-converter.js

@@ -0,0 +1,120 @@
+/**
+ * Response Converter
+ * Converts Google Generative AI responses to Anthropic Messages API format
+ */
+
+import crypto from 'crypto';
+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
+ *
+ * @param {Object} googleResponse - Google format response (the inner response object)
+ * @param {string} model - The model name used
+ * @returns {Object} Anthropic format response
+ */
+export function convertGoogleToAnthropic(googleResponse, model) {
+    // Handle the response wrapper
+    const response = googleResponse.response || googleResponse;
+
+    const candidates = response.candidates || [];
+    const firstCandidate = candidates[0] || {};
+    const content = firstCandidate.content || {};
+    const parts = content.parts || [];
+
+    // Convert parts to Anthropic content blocks
+    const anthropicContent = [];
+    let hasToolCalls = false;
+
+    for (const part of parts) {
+        if (part.text !== undefined) {
+            // Handle thinking blocks
+            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',
+                    thinking: part.text,
+                    signature: signature
+                });
+            } else {
+                anthropicContent.push({
+                    type: 'text',
+                    text: part.text
+                });
+            }
+        } else if (part.functionCall) {
+            // Convert functionCall to tool_use
+            // Use the id from the response if available, otherwise generate one
+            const toolId = part.functionCall.id || `toolu_${crypto.randomBytes(12).toString('hex')}`;
+            const toolUseBlock = {
+                type: 'tool_use',
+                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;
+                // Cache for future requests (Claude Code may strip this field)
+                cacheSignature(toolId, part.thoughtSignature);
+            }
+
+            anthropicContent.push(toolUseBlock);
+            hasToolCalls = true;
+        } else if (part.inlineData) {
+            // Handle image content from Google format
+            anthropicContent.push({
+                type: 'image',
+                source: {
+                    type: 'base64',
+                    media_type: part.inlineData.mimeType,
+                    data: part.inlineData.data
+                }
+            });
+        }
+    }
+
+    // Determine stop reason
+    const finishReason = firstCandidate.finishReason;
+    let stopReason = 'end_turn';
+    if (finishReason === 'STOP') {
+        stopReason = 'end_turn';
+    } else if (finishReason === 'MAX_TOKENS') {
+        stopReason = 'max_tokens';
+    } else if (finishReason === 'TOOL_USE' || hasToolCalls) {
+        stopReason = 'tool_use';
+    }
+
+    // Extract usage metadata
+    // Note: Antigravity's promptTokenCount is the TOTAL (includes cached),
+    // but Anthropic's input_tokens excludes cached. We subtract to match.
+    const usageMetadata = response.usageMetadata || {};
+    const promptTokens = usageMetadata.promptTokenCount || 0;
+    const cachedTokens = usageMetadata.cachedContentTokenCount || 0;
+
+    return {
+        id: `msg_${crypto.randomBytes(16).toString('hex')}`,
+        type: 'message',
+        role: 'assistant',
+        content: anthropicContent.length > 0 ? anthropicContent : [{ type: 'text', text: '' }],
+        model: model,
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: {
+            input_tokens: promptTokens - cachedTokens,
+            output_tokens: usageMetadata.candidatesTokenCount || 0,
+            cache_read_input_tokens: cachedTokens,
+            cache_creation_input_tokens: 0
+        }
+    };
+}