@kamel-ahmed/proxy-claude 1.0.0

package/src/constants.js

@@ -0,0 +1,278 @@
+/**
+ * Constants for Antigravity Cloud Code API integration
+ * Based on: https://github.com/NoeFabris/opencode-antigravity-auth
+ */
+
+import { homedir, platform, arch } from 'os';
+import { join } from 'path';
+import { config } from './config.js';
+
+/**
+ * Get the Antigravity database path based on the current platform.
+ * - macOS: ~/Library/Application Support/Antigravity/...
+ * - Windows: ~/AppData/Roaming/Antigravity/...
+ * - Linux/other: ~/.config/Antigravity/...
+ * @returns {string} Full path to the Antigravity state database
+ */
+function getAntigravityDbPath() {
+    const home = homedir();
+    switch (platform()) {
+        case 'darwin':
+            return join(home, 'Library/Application Support/Antigravity/User/globalStorage/state.vscdb');
+        case 'win32':
+            return join(home, 'AppData/Roaming/Antigravity/User/globalStorage/state.vscdb');
+        default: // linux, freebsd, etc.
+            return join(home, '.config/Antigravity/User/globalStorage/state.vscdb');
+    }
+}
+
+/**
+ * Generate platform-specific User-Agent string.
+ * @returns {string} User-Agent in format "antigravity/version os/arch"
+ */
+function getPlatformUserAgent() {
+    const os = platform();
+    const architecture = arch();
+    return `antigravity/1.11.5 ${os}/${architecture}`;
+}
+
+// Cloud Code API endpoints (in fallback order)
+const ANTIGRAVITY_ENDPOINT_DAILY = 'https://daily-cloudcode-pa.googleapis.com';
+const ANTIGRAVITY_ENDPOINT_PROD = 'https://cloudcode-pa.googleapis.com';
+
+// Endpoint fallback order (daily → prod)
+export const ANTIGRAVITY_ENDPOINT_FALLBACKS = [
+    ANTIGRAVITY_ENDPOINT_DAILY,
+    ANTIGRAVITY_ENDPOINT_PROD
+];
+
+// Required headers for Antigravity API requests
+export const ANTIGRAVITY_HEADERS = {
+    'User-Agent': getPlatformUserAgent(),
+    'X-Goog-Api-Client': 'google-cloud-sdk vscode_cloudshelleditor/0.1',
+    'Client-Metadata': JSON.stringify({
+        ideType: 'IDE_UNSPECIFIED',
+        platform: 'PLATFORM_UNSPECIFIED',
+        pluginType: 'GEMINI'
+    })
+};
+
+// Endpoint order for loadCodeAssist (prod first)
+// loadCodeAssist works better on prod for fresh/unprovisioned accounts
+export const LOAD_CODE_ASSIST_ENDPOINTS = [
+    ANTIGRAVITY_ENDPOINT_PROD,
+    ANTIGRAVITY_ENDPOINT_DAILY
+];
+
+// Endpoint order for onboardUser (same as generateContent fallbacks)
+export const ONBOARD_USER_ENDPOINTS = ANTIGRAVITY_ENDPOINT_FALLBACKS;
+
+// Headers for loadCodeAssist API
+export const LOAD_CODE_ASSIST_HEADERS = ANTIGRAVITY_HEADERS;
+
+// Default project ID if none can be discovered
+export const DEFAULT_PROJECT_ID = 'rising-fact-p41fc';
+
+// Configurable constants - values from config.json take precedence
+export const TOKEN_REFRESH_INTERVAL_MS = config?.tokenCacheTtlMs || (5 * 60 * 1000); // From config or 5 minutes
+export const REQUEST_BODY_LIMIT = config?.requestBodyLimit || '50mb';
+export const ANTIGRAVITY_AUTH_PORT = 9092;
+export const DEFAULT_PORT = config?.port || 8080;
+
+// Multi-account configuration
+export const ACCOUNT_CONFIG_PATH = config?.accountConfigPath || join(
+    homedir(),
+    '.config/antigravity-proxy/accounts.json'
+);
+
+// Usage history persistence path
+export const USAGE_HISTORY_PATH = join(
+    homedir(),
+    '.config/antigravity-proxy/usage-history.json'
+);
+
+// Antigravity app database path (for legacy single-account token extraction)
+// Uses platform-specific path detection
+export const ANTIGRAVITY_DB_PATH = getAntigravityDbPath();
+
+export const DEFAULT_COOLDOWN_MS = config?.defaultCooldownMs || (10 * 1000); // From config or 10 seconds
+export const MAX_RETRIES = config?.maxRetries || 5; // From config or 5
+export const MAX_EMPTY_RESPONSE_RETRIES = 2; // Max retries for empty API responses (from upstream)
+export const MAX_ACCOUNTS = config?.maxAccounts || 10; // From config or 10
+
+// Rate limit wait thresholds
+export const MAX_WAIT_BEFORE_ERROR_MS = config?.maxWaitBeforeErrorMs || 120000; // From config or 2 minutes
+
+// Gap 1: Retry deduplication - prevents thundering herd on concurrent rate limits
+export const RATE_LIMIT_DEDUP_WINDOW_MS = config?.rateLimitDedupWindowMs || 5000; // 5 seconds
+
+// Gap 2: Consecutive failure tracking - extended cooldown after repeated failures
+export const MAX_CONSECUTIVE_FAILURES = config?.maxConsecutiveFailures || 3;
+export const EXTENDED_COOLDOWN_MS = config?.extendedCooldownMs || 60000; // 1 minute
+
+// Gap 4: Capacity exhaustion - shorter retry for model capacity issues (not quota)
+export const CAPACITY_RETRY_DELAY_MS = config?.capacityRetryDelayMs || 2000; // 2 seconds
+export const MAX_CAPACITY_RETRIES = config?.maxCapacityRetries || 3;
+
+// Thinking model constants
+export const MIN_SIGNATURE_LENGTH = 50; // Minimum valid thinking signature length
+
+// Account selection strategies
+export const SELECTION_STRATEGIES = ['sticky', 'round-robin', 'hybrid'];
+export const DEFAULT_SELECTION_STRATEGY = 'hybrid';
+
+// Strategy display labels
+export const STRATEGY_LABELS = {
+    'sticky': 'Sticky (Cache Optimized)',
+    'round-robin': 'Round Robin (Load Balanced)',
+    'hybrid': 'Hybrid (Smart Distribution)'
+};
+
+// Gemini-specific limits
+export const GEMINI_MAX_OUTPUT_TOKENS = 16384;
+
+// Gemini signature handling
+// Sentinel value to skip thought signature validation when Claude Code strips the field
+// See: https://ai.google.dev/gemini-api/docs/thought-signatures
+export const GEMINI_SKIP_SIGNATURE = 'skip_thought_signature_validator';
+
+// Cache TTL for Gemini thoughtSignatures (2 hours)
+export const GEMINI_SIGNATURE_CACHE_TTL_MS = 2 * 60 * 60 * 1000;
+
+/**
+ * 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',
+    clientSecret: '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',
+    authUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+    tokenUrl: 'https://oauth2.googleapis.com/token',
+    userInfoUrl: 'https://www.googleapis.com/oauth2/v1/userinfo',
+    callbackPort: 51121,
+    scopes: [
+        'https://www.googleapis.com/auth/cloud-platform',
+        'https://www.googleapis.com/auth/userinfo.email',
+        'https://www.googleapis.com/auth/userinfo.profile',
+        'https://www.googleapis.com/auth/cclog',
+        'https://www.googleapis.com/auth/experimentsandconfigs'
+    ]
+};
+export const OAUTH_REDIRECT_URI = `http://localhost:${OAUTH_CONFIG.callbackPort}/oauth-callback`;
+
+// Minimal Antigravity system instruction (from CLIProxyAPI)
+// Only includes the essential identity portion to reduce token usage and improve response quality
+// Reference: GitHub issue #76, CLIProxyAPI, gcli2api
+export const ANTIGRAVITY_SYSTEM_INSTRUCTION = `You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**`;
+
+// Model fallback mapping - maps primary model to fallback when quota exhausted
+export const MODEL_FALLBACK_MAP = {
+    'gemini-3-pro-high': 'claude-opus-4-5-thinking',
+    'gemini-3-pro-low': 'claude-sonnet-4-5',
+    'gemini-3-flash': 'claude-sonnet-4-5-thinking',
+    'claude-opus-4-5-thinking': 'gemini-3-pro-high',
+    'claude-sonnet-4-5-thinking': 'gemini-3-flash',
+    'claude-sonnet-4-5': 'gemini-3-flash'
+};
+
+// Default test models for each family (used by test suite)
+export const TEST_MODELS = {
+    claude: 'claude-sonnet-4-5-thinking',
+    gemini: 'gemini-3-flash'
+};
+
+// Default Claude CLI presets (used by WebUI settings)
+export const DEFAULT_PRESETS = [
+    {
+        name: 'Claude Thinking',
+        config: {
+            ANTHROPIC_AUTH_TOKEN: 'test',
+            ANTHROPIC_BASE_URL: 'http://localhost:8080',
+            ANTHROPIC_MODEL: 'claude-opus-4-5-thinking',
+            ANTHROPIC_DEFAULT_OPUS_MODEL: 'claude-opus-4-5-thinking',
+            ANTHROPIC_DEFAULT_SONNET_MODEL: 'claude-sonnet-4-5-thinking',
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: 'gemini-2.5-flash-lite[1m]',
+            CLAUDE_CODE_SUBAGENT_MODEL: 'claude-sonnet-4-5-thinking',
+            ENABLE_EXPERIMENTAL_MCP_CLI: 'true'
+        }
+    },
+    {
+        name: 'Gemini 1M',
+        config: {
+            ANTHROPIC_AUTH_TOKEN: 'test',
+            ANTHROPIC_BASE_URL: 'http://localhost:8080',
+            ANTHROPIC_MODEL: 'gemini-3-pro-high[1m]',
+            ANTHROPIC_DEFAULT_OPUS_MODEL: 'gemini-3-pro-high[1m]',
+            ANTHROPIC_DEFAULT_SONNET_MODEL: 'gemini-3-flash[1m]',
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: 'gemini-2.5-flash-lite[1m]',
+            CLAUDE_CODE_SUBAGENT_MODEL: 'gemini-3-flash[1m]',
+            ENABLE_EXPERIMENTAL_MCP_CLI: 'true'
+        }
+    }
+];
+
+export default {
+    ANTIGRAVITY_ENDPOINT_FALLBACKS,
+    ANTIGRAVITY_HEADERS,
+    LOAD_CODE_ASSIST_ENDPOINTS,
+    ONBOARD_USER_ENDPOINTS,
+    LOAD_CODE_ASSIST_HEADERS,
+    DEFAULT_PROJECT_ID,
+    TOKEN_REFRESH_INTERVAL_MS,
+    REQUEST_BODY_LIMIT,
+    ANTIGRAVITY_AUTH_PORT,
+    DEFAULT_PORT,
+    ACCOUNT_CONFIG_PATH,
+    ANTIGRAVITY_DB_PATH,
+    DEFAULT_COOLDOWN_MS,
+    MAX_RETRIES,
+    MAX_EMPTY_RESPONSE_RETRIES,
+    MAX_ACCOUNTS,
+    MAX_WAIT_BEFORE_ERROR_MS,
+    RATE_LIMIT_DEDUP_WINDOW_MS,
+    MAX_CONSECUTIVE_FAILURES,
+    EXTENDED_COOLDOWN_MS,
+    CAPACITY_RETRY_DELAY_MS,
+    MAX_CAPACITY_RETRIES,
+    MIN_SIGNATURE_LENGTH,
+    GEMINI_MAX_OUTPUT_TOKENS,
+    GEMINI_SKIP_SIGNATURE,
+    GEMINI_SIGNATURE_CACHE_TTL_MS,
+    getModelFamily,
+    isThinkingModel,
+    OAUTH_CONFIG,
+    OAUTH_REDIRECT_URI,
+    STRATEGY_LABELS,
+    MODEL_FALLBACK_MAP,
+    TEST_MODELS,
+    DEFAULT_PRESETS,
+    ANTIGRAVITY_SYSTEM_INSTRUCTION
+};

package/src/errors.js

@@ -0,0 +1,238 @@
+/**
+ * Custom Error Classes
+ *
+ * Provides structured error types for better error handling and classification.
+ * Replaces string-based error detection with proper error class checking.
+ */
+
+/**
+ * Base error class for Antigravity proxy errors
+ */
+export class AntigravityError extends Error {
+    /**
+     * @param {string} message - Error message
+     * @param {string} code - Error code for programmatic handling
+     * @param {boolean} retryable - Whether the error is retryable
+     * @param {Object} metadata - Additional error metadata
+     */
+    constructor(message, code, retryable = false, metadata = {}) {
+        super(message);
+        this.name = 'AntigravityError';
+        this.code = code;
+        this.retryable = retryable;
+        this.metadata = metadata;
+    }
+
+    /**
+     * Convert to JSON for API responses
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            retryable: this.retryable,
+            ...this.metadata
+        };
+    }
+}
+
+/**
+ * Rate limit error (429 / RESOURCE_EXHAUSTED)
+ */
+export class RateLimitError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {number|null} resetMs - Time in ms until rate limit resets
+     * @param {string} accountEmail - Email of the rate-limited account
+     */
+    constructor(message, resetMs = null, accountEmail = null) {
+        super(message, 'RATE_LIMITED', true, { resetMs, accountEmail });
+        this.name = 'RateLimitError';
+        this.resetMs = resetMs;
+        this.accountEmail = accountEmail;
+    }
+}
+
+/**
+ * Authentication error (invalid credentials, token expired, etc.)
+ */
+export class AuthError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {string} accountEmail - Email of the account with auth issues
+     * @param {string} reason - Specific reason for auth failure
+     */
+    constructor(message, accountEmail = null, reason = null) {
+        super(message, 'AUTH_INVALID', false, { accountEmail, reason });
+        this.name = 'AuthError';
+        this.accountEmail = accountEmail;
+        this.reason = reason;
+    }
+}
+
+/**
+ * No accounts available error
+ */
+export class NoAccountsError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {boolean} allRateLimited - Whether all accounts are rate limited
+     */
+    constructor(message = 'No accounts available', allRateLimited = false) {
+        super(message, 'NO_ACCOUNTS', allRateLimited, { allRateLimited });
+        this.name = 'NoAccountsError';
+        this.allRateLimited = allRateLimited;
+    }
+}
+
+/**
+ * Max retries exceeded error
+ */
+export class MaxRetriesError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {number} attempts - Number of attempts made
+     */
+    constructor(message = 'Max retries exceeded', attempts = 0) {
+        super(message, 'MAX_RETRIES', false, { attempts });
+        this.name = 'MaxRetriesError';
+        this.attempts = attempts;
+    }
+}
+
+/**
+ * API error from upstream service
+ */
+export class ApiError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {number} statusCode - HTTP status code
+     * @param {string} errorType - Type of API error
+     */
+    constructor(message, statusCode = 500, errorType = 'api_error') {
+        super(message, errorType.toUpperCase(), statusCode >= 500, { statusCode, errorType });
+        this.name = 'ApiError';
+        this.statusCode = statusCode;
+        this.errorType = errorType;
+    }
+}
+
+/**
+ * Native module error (version mismatch, rebuild required)
+ */
+export class NativeModuleError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {boolean} rebuildSucceeded - Whether auto-rebuild succeeded
+     * @param {boolean} restartRequired - Whether server restart is needed
+     */
+    constructor(message, rebuildSucceeded = false, restartRequired = false) {
+        super(message, 'NATIVE_MODULE_ERROR', false, { rebuildSucceeded, restartRequired });
+        this.name = 'NativeModuleError';
+        this.rebuildSucceeded = rebuildSucceeded;
+        this.restartRequired = restartRequired;
+    }
+}
+
+/**
+ * Empty response error - thrown when API returns no content
+ * Used to trigger retry logic in streaming handler
+ */
+export class EmptyResponseError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     */
+    constructor(message = 'No content received from API') {
+        super(message, 'EMPTY_RESPONSE', true, {});
+        this.name = 'EmptyResponseError';
+    }
+}
+
+/**
+ * Capacity exhausted error - Google's model is at capacity (not user quota)
+ * Should retry on same account with shorter delay, not switch accounts immediately
+ * Different from QUOTA_EXHAUSTED which indicates user's daily/hourly limit
+ */
+export class CapacityExhaustedError extends AntigravityError {
+    /**
+     * @param {string} message - Error message
+     * @param {number|null} retryAfterMs - Suggested retry delay in ms
+     */
+    constructor(message = 'Model capacity exhausted', retryAfterMs = null) {
+        super(message, 'CAPACITY_EXHAUSTED', true, { retryAfterMs });
+        this.name = 'CapacityExhaustedError';
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+
+/**
+ * Check if an error is a rate limit error
+ * Works with both custom error classes and legacy string-based errors
+ * @param {Error} error - Error to check
+ * @returns {boolean}
+ */
+export function isRateLimitError(error) {
+    if (error instanceof RateLimitError) return true;
+    const msg = (error.message || '').toLowerCase();
+    return msg.includes('429') ||
+        msg.includes('resource_exhausted') ||
+        msg.includes('quota_exhausted') ||
+        msg.includes('rate limit');
+}
+
+/**
+ * Check if an error is an authentication error
+ * Works with both custom error classes and legacy string-based errors
+ * @param {Error} error - Error to check
+ * @returns {boolean}
+ */
+export function isAuthError(error) {
+    if (error instanceof AuthError) return true;
+    const msg = (error.message || '').toUpperCase();
+    return msg.includes('AUTH_INVALID') ||
+        msg.includes('INVALID_GRANT') ||
+        msg.includes('TOKEN REFRESH FAILED');
+}
+
+/**
+ * Check if an error is an empty response error
+ * @param {Error} error - Error to check
+ * @returns {boolean}
+ */
+export function isEmptyResponseError(error) {
+    return error instanceof EmptyResponseError ||
+        error?.name === 'EmptyResponseError';
+}
+
+/**
+ * Check if an error is a capacity exhausted error (model overload, not user quota)
+ * This is different from quota exhaustion - capacity issues are temporary infrastructure
+ * limits that should be retried on the SAME account with shorter delays
+ * @param {Error} error - Error to check
+ * @returns {boolean}
+ */
+export function isCapacityExhaustedError(error) {
+    if (error instanceof CapacityExhaustedError) return true;
+    const msg = (error.message || '').toLowerCase();
+    return msg.includes('model_capacity_exhausted') ||
+        msg.includes('capacity_exhausted') ||
+        msg.includes('model is currently overloaded') ||
+        msg.includes('service temporarily unavailable');
+}
+
+export default {
+    AntigravityError,
+    RateLimitError,
+    AuthError,
+    NoAccountsError,
+    MaxRetriesError,
+    ApiError,
+    NativeModuleError,
+    EmptyResponseError,
+    CapacityExhaustedError,
+    isRateLimitError,
+    isAuthError,
+    isEmptyResponseError,
+    isCapacityExhaustedError
+};

package/src/fallback-config.js

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