commons-proxy 2.0.0

package/src/cloudcode/model-api.js

@@ -0,0 +1,248 @@
+/**
+ * Model API for Cloud Code
+ *
+ * Handles model listing and quota retrieval from the Cloud Code API.
+ */
+
+import {
+    ANTIGRAVITY_ENDPOINT_FALLBACKS,
+    ANTIGRAVITY_HEADERS,
+    LOAD_CODE_ASSIST_ENDPOINTS,
+    LOAD_CODE_ASSIST_HEADERS,
+    getModelFamily
+} from '../constants.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Check if a model is supported (Claude or Gemini)
+ * @param {string} modelId - Model ID to check
+ * @returns {boolean} True if model is supported
+ */
+function isSupportedModel(modelId) {
+    const family = getModelFamily(modelId);
+    return family === 'claude' || family === 'gemini';
+}
+
+/**
+ * List available models in Anthropic API format
+ * Fetches models dynamically from the Cloud Code API
+ *
+ * @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 async function listModels(token) {
+    const data = await fetchAvailableModels(token);
+    if (!data || !data.models) {
+        return { object: 'list', data: [] };
+    }
+
+    const modelList = Object.entries(data.models)
+        .filter(([modelId]) => isSupportedModel(modelId))
+        .map(([modelId, modelData]) => ({
+        id: modelId,
+        object: 'model',
+        created: Math.floor(Date.now() / 1000),
+        owned_by: 'anthropic',
+        description: modelData.displayName || modelId
+    }));
+
+    return {
+        object: 'list',
+        data: modelList
+    };
+}
+
+/**
+ * Fetch available models with quota info from Cloud Code API
+ * Returns model quotas including remaining fraction and reset time
+ *
+ * @param {string} token - OAuth access token
+ * @param {string} [projectId] - Optional project ID for accurate quota info
+ * @returns {Promise<Object>} Raw response from fetchAvailableModels API
+ */
+export async function fetchAvailableModels(token, projectId = null) {
+    const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        ...ANTIGRAVITY_HEADERS
+    };
+
+    // Include project ID in body for accurate quota info (per Quotio implementation)
+    const body = projectId ? { project: projectId } : {};
+
+    for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
+        try {
+            const url = `${endpoint}/v1internal:fetchAvailableModels`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body)
+            });
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                logger.warn(`[CloudCode] fetchAvailableModels error at ${endpoint}: ${response.status}`);
+                continue;
+            }
+
+            return await response.json();
+        } catch (error) {
+            logger.warn(`[CloudCode] fetchAvailableModels failed at ${endpoint}:`, error.message);
+        }
+    }
+
+    throw new Error('Failed to fetch available models from all endpoints');
+}
+
+/**
+ * Get model quotas for an account
+ * Extracts quota info (remaining fraction and reset time) for each model
+ *
+ * @param {string} token - OAuth access token
+ * @param {string} [projectId] - Optional project ID for accurate quota info
+ * @returns {Promise<Object>} Map of modelId -> { remainingFraction, resetTime }
+ */
+export async function getModelQuotas(token, projectId = null) {
+    const data = await fetchAvailableModels(token, projectId);
+    if (!data || !data.models) return {};
+
+    const quotas = {};
+    for (const [modelId, modelData] of Object.entries(data.models)) {
+        // Only include Claude and Gemini models
+        if (!isSupportedModel(modelId)) continue;
+
+        if (modelData.quotaInfo) {
+            quotas[modelId] = {
+                // When remainingFraction is missing but resetTime is present, quota is exhausted (0%)
+                remainingFraction: modelData.quotaInfo.remainingFraction ?? (modelData.quotaInfo.resetTime ? 0 : null),
+                resetTime: modelData.quotaInfo.resetTime ?? null
+            };
+        }
+    }
+
+    return quotas;
+}
+
+/**
+ * Parse tier ID string to determine subscription level
+ * @param {string} tierId - The tier ID from the API
+ * @returns {'free' | 'pro' | 'ultra' | 'unknown'} The subscription tier
+ */
+export function parseTierId(tierId) {
+    if (!tierId) return 'unknown';
+    const lower = tierId.toLowerCase();
+
+    if (lower.includes('ultra')) {
+        return 'ultra';
+    }
+    if (lower === 'standard-tier') {
+        // standard-tier = "Gemini Code Assist" (paid, project-based)
+        return 'pro';
+    }
+    if (lower.includes('pro') || lower.includes('premium')) {
+        return 'pro';
+    }
+    if (lower === 'free-tier' || lower.includes('free')) {
+        return 'free';
+    }
+    return 'unknown';
+}
+
+/**
+ * Get subscription tier for an account
+ * Calls loadCodeAssist API to discover project ID and subscription tier
+ *
+ * @param {string} token - OAuth access token
+ * @returns {Promise<{tier: string, projectId: string|null}>} Subscription tier (free/pro/ultra) and project ID
+ */
+export async function getSubscriptionTier(token) {
+    const headers = {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        ...LOAD_CODE_ASSIST_HEADERS
+    };
+
+    for (const endpoint of LOAD_CODE_ASSIST_ENDPOINTS) {
+        try {
+            const url = `${endpoint}/v1internal:loadCodeAssist`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    metadata: {
+                        ideType: 'IDE_UNSPECIFIED',
+                        platform: 'PLATFORM_UNSPECIFIED',
+                        pluginType: 'GEMINI',
+                        duetProject: 'rising-fact-p41fc'
+                    }
+                })
+            });
+
+            if (!response.ok) {
+                logger.warn(`[CloudCode] loadCodeAssist error at ${endpoint}: ${response.status}`);
+                continue;
+            }
+
+            const data = await response.json();
+
+            // Debug: Log all tier-related fields from the response
+            logger.debug(`[CloudCode] loadCodeAssist tier data: paidTier=${JSON.stringify(data.paidTier)}, currentTier=${JSON.stringify(data.currentTier)}, allowedTiers=${JSON.stringify(data.allowedTiers?.map(t => ({ id: t?.id, isDefault: t?.isDefault })))}`);
+
+            // Extract project ID
+            let projectId = null;
+            if (typeof data.cloudaicompanionProject === 'string') {
+                projectId = data.cloudaicompanionProject;
+            } else if (data.cloudaicompanionProject?.id) {
+                projectId = data.cloudaicompanionProject.id;
+            }
+
+            // Extract subscription tier
+            // Priority: paidTier > currentTier > allowedTiers
+            // - paidTier.id: "g1-pro-tier", "g1-ultra-tier" (Google One subscription)
+            // - currentTier.id: "standard-tier" (pro), "free-tier" (free)
+            // - allowedTiers: fallback when currentTier is missing
+            // Note: paidTier is sometimes missing from the response even for Pro accounts
+            let tier = 'unknown';
+            let tierId = null;
+            let tierSource = null;
+
+            // 1. Check paidTier first (Google One AI subscription - most reliable)
+            if (data.paidTier?.id) {
+                tierId = data.paidTier.id;
+                tier = parseTierId(tierId);
+                tierSource = 'paidTier';
+            }
+
+            // 2. Fall back to currentTier if paidTier didn't give us a tier
+            if (tier === 'unknown' && data.currentTier?.id) {
+                tierId = data.currentTier.id;
+                tier = parseTierId(tierId);
+                tierSource = 'currentTier';
+            }
+
+            // 3. Fall back to allowedTiers (find the default or first non-free tier)
+            if (tier === 'unknown' && Array.isArray(data.allowedTiers) && data.allowedTiers.length > 0) {
+                // First look for the default tier
+                let defaultTier = data.allowedTiers.find(t => t?.isDefault);
+                if (!defaultTier) {
+                    defaultTier = data.allowedTiers[0];
+                }
+                if (defaultTier?.id) {
+                    tierId = defaultTier.id;
+                    tier = parseTierId(tierId);
+                    tierSource = 'allowedTiers';
+                }
+            }
+
+            logger.debug(`[CloudCode] Subscription detected: ${tier} (tierId: ${tierId}, source: ${tierSource}), Project: ${projectId}`);
+
+            return { tier, projectId };
+        } catch (error) {
+            logger.warn(`[CloudCode] loadCodeAssist failed at ${endpoint}:`, error.message);
+        }
+    }
+
+    // Fallback: return default values if all endpoints fail
+    logger.warn('[CloudCode] Failed to detect subscription tier from all endpoints. Defaulting to free.');
+    return { tier: 'free', projectId: null };
+}

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

@@ -0,0 +1,235 @@
+/**
+ * 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: Handle very small or negative reset times
+    // For sub-second rate limits (common with per-second quotas), add a small buffer
+    // For negative or zero, use a reasonable minimum
+    if (resetMs !== null) {
+        if (resetMs <= 0) {
+            logger.debug(`[CloudCode] Reset time invalid (${resetMs}ms), using 500ms default`);
+            resetMs = 500;
+        } else if (resetMs < 500) {
+            // Very short reset - add 200ms buffer for network latency
+            logger.debug(`[CloudCode] Short reset time (${resetMs}ms), adding 200ms buffer`);
+            resetMs = resetMs + 200;
+        }
+        // Note: No longer enforcing 2s minimum - this was causing cascading failures
+        // when all accounts had short rate limits simultaneously
+    }
+
+    return resetMs;
+}
+
+/**
+ * Parse the rate limit reason from error text
+ * Used for smart backoff by error type (matches opencode-cloudcode-auth)
+ *
+ * @param {string} errorText - Error message/body text
+ * @returns {'RATE_LIMIT_EXCEEDED' | 'QUOTA_EXHAUSTED' | 'MODEL_CAPACITY_EXHAUSTED' | 'SERVER_ERROR' | 'UNKNOWN'} Error reason
+ */
+export function parseRateLimitReason(errorText) {
+    const lower = (errorText || '').toLowerCase();
+
+    // Check for quota exhaustion (daily/hourly limits)
+    if (lower.includes('quota_exhausted') ||
+        lower.includes('quotaresetdelay') ||
+        lower.includes('quotaresettimestamp') ||
+        lower.includes('resource_exhausted') ||
+        lower.includes('daily limit') ||
+        lower.includes('quota exceeded')) {
+        return 'QUOTA_EXHAUSTED';
+    }
+
+    // Check for model capacity issues (temporary, retry quickly)
+    if (lower.includes('model_capacity_exhausted') ||
+        lower.includes('capacity_exhausted') ||
+        lower.includes('model is currently overloaded') ||
+        lower.includes('service temporarily unavailable')) {
+        return 'MODEL_CAPACITY_EXHAUSTED';
+    }
+
+    // Check for rate limiting (per-minute limits)
+    if (lower.includes('rate_limit_exceeded') ||
+        lower.includes('rate limit') ||
+        lower.includes('too many requests') ||
+        lower.includes('throttl')) {
+        return 'RATE_LIMIT_EXCEEDED';
+    }
+
+    // Check for server errors
+    if (lower.includes('internal server error') ||
+        lower.includes('server error') ||
+        lower.includes('503') ||
+        lower.includes('502') ||
+        lower.includes('504')) {
+        return 'SERVER_ERROR';
+    }
+
+    return 'UNKNOWN';
+}

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: 'commons-proxy',
+        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();
+}