@kamel-ahmed/proxy-claude 1.0.0

package/src/cloudcode/rate-limit-parser.js

@@ -0,0 +1,181 @@
+/**
+ * Rate Limit Parser for Cloud Code
+ *
+ * Parses reset times from HTTP headers and error messages.
+ * Supports various formats: Retry-After, x-ratelimit-reset,
+ * quotaResetDelay, quotaResetTimeStamp, and duration strings.
+ */
+
+import { formatDuration } from '../utils/helpers.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Parse reset time from HTTP response or error
+ * Checks headers first, then error message body
+ * Returns milliseconds or null if not found
+ *
+ * @param {Response|Error} responseOrError - HTTP Response object or Error
+ * @param {string} errorText - Optional error body text
+ */
+export function parseResetTime(responseOrError, errorText = '') {
+    let resetMs = null;
+
+    // If it's a Response object, check headers first
+    if (responseOrError && typeof responseOrError.headers?.get === 'function') {
+        const headers = responseOrError.headers;
+
+        // Standard Retry-After header (seconds or HTTP date)
+        const retryAfter = headers.get('retry-after');
+        if (retryAfter) {
+            const seconds = parseInt(retryAfter, 10);
+            if (!isNaN(seconds)) {
+                resetMs = seconds * 1000;
+                logger.debug(`[CloudCode] Retry-After header: ${seconds}s`);
+            } else {
+                // Try parsing as HTTP date
+                const date = new Date(retryAfter);
+                if (!isNaN(date.getTime())) {
+                    resetMs = date.getTime() - Date.now();
+                    if (resetMs > 0) {
+                        logger.debug(`[CloudCode] Retry-After date: ${retryAfter}`);
+                    } else {
+                        resetMs = null;
+                    }
+                }
+            }
+        }
+
+        // x-ratelimit-reset (Unix timestamp in seconds)
+        if (!resetMs) {
+            const ratelimitReset = headers.get('x-ratelimit-reset');
+            if (ratelimitReset) {
+                const resetTimestamp = parseInt(ratelimitReset, 10) * 1000;
+                resetMs = resetTimestamp - Date.now();
+                if (resetMs > 0) {
+                    logger.debug(`[CloudCode] x-ratelimit-reset: ${new Date(resetTimestamp).toISOString()}`);
+                } else {
+                    resetMs = null;
+                }
+            }
+        }
+
+        // x-ratelimit-reset-after (seconds)
+        if (!resetMs) {
+            const resetAfter = headers.get('x-ratelimit-reset-after');
+            if (resetAfter) {
+                const seconds = parseInt(resetAfter, 10);
+                if (!isNaN(seconds) && seconds > 0) {
+                    resetMs = seconds * 1000;
+                    logger.debug(`[CloudCode] x-ratelimit-reset-after: ${seconds}s`);
+                }
+            }
+        }
+    }
+
+    // If no header found, try parsing from error message/body
+    if (!resetMs) {
+        const msg = (responseOrError instanceof Error ? responseOrError.message : errorText) || '';
+
+        // Try to extract "quotaResetDelay" first (e.g. "754.431528ms" or "1.5s")
+        // This is Google's preferred format for rate limit reset delay
+        const quotaDelayMatch = msg.match(/quotaResetDelay[:\s"]+(\d+(?:\.\d+)?)(ms|s)/i);
+        if (quotaDelayMatch) {
+            const value = parseFloat(quotaDelayMatch[1]);
+            const unit = quotaDelayMatch[2].toLowerCase();
+            resetMs = unit === 's' ? Math.ceil(value * 1000) : Math.ceil(value);
+            logger.debug(`[CloudCode] Parsed quotaResetDelay from body: ${resetMs}ms`);
+        }
+
+        // Try to extract "quotaResetTimeStamp" (ISO format like "2025-12-31T07:00:47Z")
+        if (!resetMs) {
+            const quotaTimestampMatch = msg.match(/quotaResetTimeStamp[:\s"]+(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)/i);
+            if (quotaTimestampMatch) {
+                const resetTime = new Date(quotaTimestampMatch[1]).getTime();
+                if (!isNaN(resetTime)) {
+                    resetMs = resetTime - Date.now();
+                    // Even if expired or 0, we found a timestamp, so rely on it.
+                    // But if it's negative, it means "now", so treat as small wait.
+                    logger.debug(`[CloudCode] Parsed quotaResetTimeStamp: ${quotaTimestampMatch[1]} (Delta: ${resetMs}ms)`);
+                }
+            }
+        }
+
+        // Try to extract "retry-after-ms" or "retryDelay" - check seconds format first (e.g. "7739.23s")
+        // Added stricter regex to avoid partial matches
+        if (!resetMs) {
+             const secMatch = msg.match(/(?:retry[-_]?after[-_]?ms|retryDelay)[:\s"]+([\d.]+)(?:s\b|s")/i);
+             if (secMatch) {
+                 resetMs = Math.ceil(parseFloat(secMatch[1]) * 1000);
+                 logger.debug(`[CloudCode] Parsed retry seconds from body (precise): ${resetMs}ms`);
+             }
+        }
+
+        if (!resetMs) {
+            // Check for ms (explicit "ms" suffix or implicit if no suffix)
+            const msMatch = msg.match(/(?:retry[-_]?after[-_]?ms|retryDelay)[:\s"]+(\d+)(?:\s*ms)?(?![\w.])/i);
+            if (msMatch) {
+                resetMs = parseInt(msMatch[1], 10);
+                logger.debug(`[CloudCode] Parsed retry-after-ms from body: ${resetMs}ms`);
+            }
+        }
+
+        // Try to extract seconds value like "retry after 60 seconds"
+        if (!resetMs) {
+            const secMatch = msg.match(/retry\s+(?:after\s+)?(\d+)\s*(?:sec|s\b)/i);
+            if (secMatch) {
+                resetMs = parseInt(secMatch[1], 10) * 1000;
+                logger.debug(`[CloudCode] Parsed retry seconds from body: ${secMatch[1]}s`);
+            }
+        }
+
+        // Try to extract duration like "1h23m45s" or "23m45s" or "45s"
+        if (!resetMs) {
+            const durationMatch = msg.match(/(\d+)h(\d+)m(\d+)s|(\d+)m(\d+)s|(\d+)s/i);
+            if (durationMatch) {
+                if (durationMatch[1]) {
+                    const hours = parseInt(durationMatch[1], 10);
+                    const minutes = parseInt(durationMatch[2], 10);
+                    const seconds = parseInt(durationMatch[3], 10);
+                    resetMs = (hours * 3600 + minutes * 60 + seconds) * 1000;
+                } else if (durationMatch[4]) {
+                    const minutes = parseInt(durationMatch[4], 10);
+                    const seconds = parseInt(durationMatch[5], 10);
+                    resetMs = (minutes * 60 + seconds) * 1000;
+                } else if (durationMatch[6]) {
+                    resetMs = parseInt(durationMatch[6], 10) * 1000;
+                }
+                if (resetMs) {
+                    logger.debug(`[CloudCode] Parsed duration from body: ${formatDuration(resetMs)}`);
+                }
+            }
+        }
+
+        // Try to extract ISO timestamp or Unix timestamp
+        if (!resetMs) {
+            const isoMatch = msg.match(/reset[:\s"]+(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)/i);
+            if (isoMatch) {
+                const resetTime = new Date(isoMatch[1]).getTime();
+                if (!isNaN(resetTime)) {
+                    resetMs = resetTime - Date.now();
+                    if (resetMs > 0) {
+                        logger.debug(`[CloudCode] Parsed ISO reset time: ${isoMatch[1]}`);
+                    } else {
+                        resetMs = null;
+                    }
+                }
+            }
+        }
+    }
+
+    // SANITY CHECK: Enforce strict minimums for found rate limits
+    // If we found a reset time, but it's very small (e.g. < 1s) or negative,
+    // explicitly bump it up to avoid "Available in 0s" loops.
+    if (resetMs !== null) {
+        if (resetMs < 1000) {
+            logger.debug(`[CloudCode] Reset time too small (${resetMs}ms), enforcing 2s buffer`);
+            resetMs = 2000;
+        }
+    }
+
+    return resetMs;
+}

package/src/cloudcode/request-builder.js

@@ -0,0 +1,93 @@
+/**
+ * Request Builder for Cloud Code
+ *
+ * Builds request payloads and headers for the Cloud Code API.
+ */
+
+import crypto from 'crypto';
+import {
+    ANTIGRAVITY_HEADERS,
+    ANTIGRAVITY_SYSTEM_INSTRUCTION,
+    getModelFamily,
+    isThinkingModel
+} from '../constants.js';
+import { convertAnthropicToGoogle } from '../format/index.js';
+import { deriveSessionId } from './session-manager.js';
+
+/**
+ * Build the wrapped request body for Cloud Code API
+ *
+ * @param {Object} anthropicRequest - The Anthropic-format request
+ * @param {string} projectId - The project ID to use
+ * @returns {Object} The Cloud Code API request payload
+ */
+export function buildCloudCodeRequest(anthropicRequest, projectId) {
+    const model = anthropicRequest.model;
+    const googleRequest = convertAnthropicToGoogle(anthropicRequest);
+
+    // Use stable session ID derived from first user message for cache continuity
+    googleRequest.sessionId = deriveSessionId(anthropicRequest);
+
+    // Build system instruction parts array with [ignore] tags to prevent model from
+    // identifying as "Antigravity" (fixes GitHub issue #76)
+    // Reference: CLIProxyAPI, gcli2api, AIClient-2-API all use this approach
+    const systemParts = [
+        { text: ANTIGRAVITY_SYSTEM_INSTRUCTION },
+        { text: `Please ignore the following [ignore]${ANTIGRAVITY_SYSTEM_INSTRUCTION}[/ignore]` }
+    ];
+
+    // Append any existing system instructions from the request
+    if (googleRequest.systemInstruction && googleRequest.systemInstruction.parts) {
+        for (const part of googleRequest.systemInstruction.parts) {
+            if (part.text) {
+                systemParts.push({ text: part.text });
+            }
+        }
+    }
+
+    const payload = {
+        project: projectId,
+        model: model,
+        request: googleRequest,
+        userAgent: 'antigravity',
+        requestType: 'agent',  // CLIProxyAPI v6.6.89 compatibility
+        requestId: 'agent-' + crypto.randomUUID()
+    };
+
+    // Inject systemInstruction with role: "user" at the top level (CLIProxyAPI v6.6.89 behavior)
+    payload.request.systemInstruction = {
+        role: 'user',
+        parts: systemParts
+    };
+
+    return payload;
+}
+
+/**
+ * Build headers for Cloud Code API requests
+ *
+ * @param {string} token - OAuth access token
+ * @param {string} model - Model name
+ * @param {string} accept - Accept header value (default: 'application/json')
+ * @returns {Object} Headers object
+ */
+export function buildHeaders(token, model, accept = 'application/json') {
+    const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        ...ANTIGRAVITY_HEADERS
+    };
+
+    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';
+    }
+
+    if (accept !== 'application/json') {
+        headers['Accept'] = accept;
+    }
+
+    return headers;
+}

package/src/cloudcode/session-manager.js

@@ -0,0 +1,47 @@
+/**
+ * Session Management for Cloud Code
+ *
+ * Handles session ID derivation for prompt caching continuity.
+ * Session IDs are derived from the first user message to ensure
+ * the same conversation uses the same session across turns.
+ */
+
+import crypto from 'crypto';
+
+/**
+ * Derive a stable session ID from the first user message in the conversation.
+ * This ensures the same conversation uses the same session ID across turns,
+ * enabling prompt caching (cache is scoped to session + organization).
+ *
+ * @param {Object} anthropicRequest - The Anthropic-format request
+ * @returns {string} A stable session ID (32 hex characters) or random UUID if no user message
+ */
+export function deriveSessionId(anthropicRequest) {
+    const messages = anthropicRequest.messages || [];
+
+    // Find the first user message
+    for (const msg of messages) {
+        if (msg.role === 'user') {
+            let content = '';
+
+            if (typeof msg.content === 'string') {
+                content = msg.content;
+            } else if (Array.isArray(msg.content)) {
+                // Extract text from content blocks
+                content = msg.content
+                    .filter(block => block.type === 'text' && block.text)
+                    .map(block => block.text)
+                    .join('\n');
+            }
+
+            if (content) {
+                // Hash the content with SHA256, return first 32 hex chars
+                const hash = crypto.createHash('sha256').update(content).digest('hex');
+                return hash.substring(0, 32);
+            }
+        }
+    }
+
+    // Fallback to random UUID if no user message found
+    return crypto.randomUUID();
+}

package/src/cloudcode/sse-parser.js

@@ -0,0 +1,121 @@
+/**
+ * SSE Parser for Cloud Code
+ *
+ * Parses SSE responses for non-streaming thinking models.
+ * Accumulates all parts and returns a single response.
+ */
+
+import { convertGoogleToAnthropic } from '../format/index.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Parse SSE response for thinking models and accumulate all parts
+ *
+ * @param {Response} response - The HTTP response with SSE body
+ * @param {string} originalModel - The original model name
+ * @returns {Promise<Object>} Anthropic-format response object
+ */
+export async function parseThinkingSSEResponse(response, originalModel) {
+    let accumulatedThinkingText = '';
+    let accumulatedThinkingSignature = '';
+    let accumulatedText = '';
+    const finalParts = [];
+    let usageMetadata = {};
+    let finishReason = 'STOP';
+
+    const flushThinking = () => {
+        if (accumulatedThinkingText) {
+            finalParts.push({
+                thought: true,
+                text: accumulatedThinkingText,
+                thoughtSignature: accumulatedThinkingSignature
+            });
+            accumulatedThinkingText = '';
+            accumulatedThinkingSignature = '';
+        }
+    };
+
+    const flushText = () => {
+        if (accumulatedText) {
+            finalParts.push({ text: accumulatedText });
+            accumulatedText = '';
+        }
+    };
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+            if (!line.startsWith('data:')) continue;
+            const jsonText = line.slice(5).trim();
+            if (!jsonText) continue;
+
+            try {
+                const data = JSON.parse(jsonText);
+                const innerResponse = data.response || data;
+
+                if (innerResponse.usageMetadata) {
+                    usageMetadata = innerResponse.usageMetadata;
+                }
+
+                const candidates = innerResponse.candidates || [];
+                const firstCandidate = candidates[0] || {};
+                if (firstCandidate.finishReason) {
+                    finishReason = firstCandidate.finishReason;
+                }
+
+                const parts = firstCandidate.content?.parts || [];
+                for (const part of parts) {
+                    if (part.thought === true) {
+                        flushText();
+                        accumulatedThinkingText += (part.text || '');
+                        if (part.thoughtSignature) {
+                            accumulatedThinkingSignature = part.thoughtSignature;
+                        }
+                    } else if (part.functionCall) {
+                        flushThinking();
+                        flushText();
+                        finalParts.push(part);
+                    } else if (part.text !== undefined) {
+                        if (!part.text) continue;
+                        flushThinking();
+                        accumulatedText += part.text;
+                    } else if (part.inlineData) {
+                        // Handle image content
+                        flushThinking();
+                        flushText();
+                        finalParts.push(part);
+                    }
+                }
+            } catch (e) {
+                logger.debug('[CloudCode] SSE parse warning:', e.message, 'Raw:', jsonText.slice(0, 100));
+            }
+        }
+    }
+
+    flushThinking();
+    flushText();
+
+    const accumulatedResponse = {
+        candidates: [{ content: { parts: finalParts }, finishReason }],
+        usageMetadata
+    };
+
+    const partTypes = finalParts.map(p => p.thought ? 'thought' : (p.functionCall ? 'functionCall' : (p.inlineData ? 'inlineData' : 'text')));
+    logger.debug('[CloudCode] Response received (SSE), part types:', partTypes);
+    if (finalParts.some(p => p.thought)) {
+        const thinkingPart = finalParts.find(p => p.thought);
+        logger.debug('[CloudCode] Thinking signature length:', thinkingPart?.thoughtSignature?.length || 0);
+    }
+
+    return convertGoogleToAnthropic(accumulatedResponse, originalModel);
+}