initial commit

package.json

@@ -6,7 +6,17 @@
   "type": "module",
   "scripts": {
     "start": "node src/index.js",
-    "dev": "node --watch src/index.js"
+    "dev": "node --watch src/index.js",
+    "accounts": "node src/accounts-cli.js",
+    "accounts:add": "node src/accounts-cli.js add",
+    "accounts:list": "node src/accounts-cli.js list",
+    "accounts:verify": "node src/accounts-cli.js verify",
+    "test": "node tests/run-all.cjs",
+    "test:signatures": "node tests/test-thinking-signatures.cjs",
+    "test:multiturn": "node tests/test-multiturn-thinking-tools.cjs",
+    "test:streaming": "node tests/test-multiturn-thinking-tools-streaming.cjs",
+    "test:interleaved": "node tests/test-interleaved-thinking.cjs",
+    "test:images": "node tests/test-images.cjs"
   },
   "keywords": [
     "claude",
@@ -19,7 +29,6 @@
   "license": "MIT",
   "dependencies": {
     "cors": "^2.8.5",
-    "express": "^4.18.2",
+    "express": "^4.18.2"
-    "node-fetch": "^3.3.2"
   }
 }

src/account-manager.js

@@ -0,0 +1,514 @@
+/**
+ * Account Manager
+ * Manages multiple Antigravity accounts with round-robin selection,
+ * automatic failover, and smart cooldown for rate-limited accounts.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { execSync } from 'child_process';
+import { homedir } from 'os';
+import { join } from 'path';
+import {
+    ACCOUNT_CONFIG_PATH,
+    DEFAULT_COOLDOWN_MS,
+    TOKEN_REFRESH_INTERVAL_MS,
+    ANTIGRAVITY_ENDPOINT_FALLBACKS,
+    ANTIGRAVITY_HEADERS,
+    DEFAULT_PROJECT_ID
+} from './constants.js';
+import { refreshAccessToken } from './oauth.js';
+
+// Default Antigravity database path
+const ANTIGRAVITY_DB_PATH = join(
+    homedir(),
+    'Library/Application Support/Antigravity/User/globalStorage/state.vscdb'
+);
+
+/**
+ * Format duration in milliseconds to human-readable string (e.g., "1h23m45s")
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+
+    if (hours > 0) {
+        return `${hours}h${minutes}m${secs}s`;
+    } else if (minutes > 0) {
+        return `${minutes}m${secs}s`;
+    }
+    return `${secs}s`;
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export class AccountManager {
+    #accounts = [];
+    #currentIndex = 0;
+    #configPath;
+    #settings = {};
+    #initialized = false;
+
+    // Per-account caches
+    #tokenCache = new Map(); // email -> { token, extractedAt }
+    #projectCache = new Map(); // email -> projectId
+
+    constructor(configPath = ACCOUNT_CONFIG_PATH) {
+        this.#configPath = configPath;
+    }
+
+    /**
+     * Initialize the account manager by loading config
+     */
+    async initialize() {
+        if (this.#initialized) return;
+
+        try {
+            if (existsSync(this.#configPath)) {
+                const configData = readFileSync(this.#configPath, 'utf-8');
+                const config = JSON.parse(configData);
+
+                this.#accounts = (config.accounts || []).map(acc => ({
+                    ...acc,
+                    isRateLimited: acc.isRateLimited || false,
+                    rateLimitResetTime: acc.rateLimitResetTime || null,
+                    lastUsed: acc.lastUsed || null
+                }));
+
+                this.#settings = config.settings || {};
+                this.#currentIndex = config.activeIndex || 0;
+
+                // Clamp currentIndex to valid range
+                if (this.#currentIndex >= this.#accounts.length) {
+                    this.#currentIndex = 0;
+                }
+
+                console.log(`[AccountManager] Loaded ${this.#accounts.length} account(s) from config`);
+            } else {
+                // No config file - use single account from Antigravity database
+                console.log('[AccountManager] No config file found. Using Antigravity database (single account mode)');
+                await this.#loadDefaultAccount();
+            }
+        } catch (error) {
+            console.error('[AccountManager] Failed to load config:', error.message);
+            // Fall back to default account
+            await this.#loadDefaultAccount();
+        }
+
+        // Clear any expired rate limits
+        this.clearExpiredLimits();
+
+        this.#initialized = true;
+    }
+
+    /**
+     * Load the default account from Antigravity's database
+     */
+    async #loadDefaultAccount() {
+        try {
+            const authData = this.#extractTokenFromDB();
+            if (authData?.apiKey) {
+                this.#accounts = [{
+                    email: authData.email || 'default@antigravity',
+                    source: 'database',
+                    isRateLimited: false,
+                    rateLimitResetTime: null,
+                    lastUsed: null
+                }];
+                // Pre-cache the token
+                this.#tokenCache.set(this.#accounts[0].email, {
+                    token: authData.apiKey,
+                    extractedAt: Date.now()
+                });
+                console.log(`[AccountManager] Loaded default account: ${this.#accounts[0].email}`);
+            }
+        } catch (error) {
+            console.error('[AccountManager] Failed to load default account:', error.message);
+            // Create empty account list - will fail on first request
+            this.#accounts = [];
+        }
+    }
+
+    /**
+     * Extract token from Antigravity's SQLite database
+     */
+    #extractTokenFromDB(dbPath = ANTIGRAVITY_DB_PATH) {
+        const result = execSync(
+            `sqlite3 "${dbPath}" "SELECT value FROM ItemTable WHERE key = 'antigravityAuthStatus';"`,
+            { encoding: 'utf-8', timeout: 5000 }
+        );
+
+        if (!result || !result.trim()) {
+            throw new Error('No auth status found in database');
+        }
+
+        return JSON.parse(result.trim());
+    }
+
+    /**
+     * Get the number of accounts
+     */
+    getAccountCount() {
+        return this.#accounts.length;
+    }
+
+    /**
+     * Check if all accounts are rate-limited
+     */
+    isAllRateLimited() {
+        if (this.#accounts.length === 0) return true;
+        return this.#accounts.every(acc => acc.isRateLimited);
+    }
+
+    /**
+     * Get list of available (non-rate-limited, non-invalid) accounts
+     */
+    getAvailableAccounts() {
+        return this.#accounts.filter(acc => !acc.isRateLimited && !acc.isInvalid);
+    }
+
+    /**
+     * Get list of invalid accounts
+     */
+    getInvalidAccounts() {
+        return this.#accounts.filter(acc => acc.isInvalid);
+    }
+
+    /**
+     * Clear expired rate limits
+     */
+    clearExpiredLimits() {
+        const now = Date.now();
+        let cleared = 0;
+
+        for (const account of this.#accounts) {
+            if (account.isRateLimited && account.rateLimitResetTime && account.rateLimitResetTime <= now) {
+                account.isRateLimited = false;
+                account.rateLimitResetTime = null;
+                cleared++;
+                console.log(`[AccountManager] Rate limit expired for: ${account.email}`);
+            }
+        }
+
+        if (cleared > 0) {
+            this.saveToDisk();
+        }
+
+        return cleared;
+    }
+
+    /**
+     * Pick the next available account (round-robin)
+     */
+    pickNext() {
+        this.clearExpiredLimits();
+
+        const available = this.getAvailableAccounts();
+        if (available.length === 0) {
+            return null;
+        }
+
+        // Find next available account starting from current index
+        for (let i = 0; i < this.#accounts.length; i++) {
+            const idx = (this.#currentIndex + i) % this.#accounts.length;
+            const account = this.#accounts[idx];
+
+            if (!account.isRateLimited && !account.isInvalid) {
+                this.#currentIndex = (idx + 1) % this.#accounts.length;
+                account.lastUsed = Date.now();
+
+                const position = this.#accounts.indexOf(account) + 1;
+                const total = this.#accounts.length;
+                console.log(`[AccountManager] Using account: ${account.email} (${position}/${total})`);
+
+                return account;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Mark an account as rate-limited
+     */
+    markRateLimited(email, resetMs = null) {
+        const account = this.#accounts.find(a => a.email === email);
+        if (!account) return;
+
+        account.isRateLimited = true;
+        const cooldownMs = resetMs || this.#settings.cooldownDurationMs || DEFAULT_COOLDOWN_MS;
+        account.rateLimitResetTime = Date.now() + cooldownMs;
+
+        console.log(
+            `[AccountManager] Rate limited: ${email}. Available in ${formatDuration(cooldownMs)}`
+        );
+
+        this.saveToDisk();
+    }
+
+    /**
+     * Mark an account as invalid (credentials need re-authentication)
+     */
+    markInvalid(email, reason = 'Unknown error') {
+        const account = this.#accounts.find(a => a.email === email);
+        if (!account) return;
+
+        account.isInvalid = true;
+        account.invalidReason = reason;
+        account.invalidAt = Date.now();
+
+        console.log(
+            `[AccountManager] ⚠ Account INVALID: ${email}`
+        );
+        console.log(
+            `[AccountManager]   Reason: ${reason}`
+        );
+        console.log(
+            `[AccountManager]   Run 'npm run accounts' to re-authenticate this account`
+        );
+
+        this.saveToDisk();
+    }
+
+    /**
+     * Get the minimum wait time until any account becomes available
+     */
+    getMinWaitTimeMs() {
+        if (!this.isAllRateLimited()) return 0;
+
+        const now = Date.now();
+        let minWait = Infinity;
+        let soonestAccount = null;
+
+        for (const account of this.#accounts) {
+            if (account.rateLimitResetTime) {
+                const wait = account.rateLimitResetTime - now;
+                if (wait > 0 && wait < minWait) {
+                    minWait = wait;
+                    soonestAccount = account;
+                }
+            }
+        }
+
+        if (soonestAccount) {
+            console.log(`[AccountManager] Shortest wait: ${formatDuration(minWait)} (account: ${soonestAccount.email})`);
+        }
+
+        return minWait === Infinity ? DEFAULT_COOLDOWN_MS : minWait;
+    }
+
+    /**
+     * Get OAuth token for an account
+     */
+    async getTokenForAccount(account) {
+        // Check cache first
+        const cached = this.#tokenCache.get(account.email);
+        if (cached && (Date.now() - cached.extractedAt) < TOKEN_REFRESH_INTERVAL_MS) {
+            return cached.token;
+        }
+
+        // Get fresh token based on source
+        let token;
+
+        if (account.source === 'oauth' && account.refreshToken) {
+            // OAuth account - use refresh token to get new access token
+            try {
+                const tokens = await refreshAccessToken(account.refreshToken);
+                token = tokens.accessToken;
+                // Clear invalid flag on success
+                if (account.isInvalid) {
+                    account.isInvalid = false;
+                    account.invalidReason = null;
+                    this.saveToDisk();
+                }
+                console.log(`[AccountManager] Refreshed OAuth token for: ${account.email}`);
+            } catch (error) {
+                console.error(`[AccountManager] Failed to refresh token for ${account.email}:`, error.message);
+                // Mark account as invalid (credentials need re-auth)
+                this.markInvalid(account.email, error.message);
+                throw new Error(`AUTH_INVALID: ${account.email}: ${error.message}`);
+            }
+        } else if (account.source === 'manual' && account.apiKey) {
+            token = account.apiKey;
+        } else {
+            // Extract from database
+            const dbPath = account.dbPath || ANTIGRAVITY_DB_PATH;
+            const authData = this.#extractTokenFromDB(dbPath);
+            token = authData.apiKey;
+        }
+
+        // Cache the token
+        this.#tokenCache.set(account.email, {
+            token,
+            extractedAt: Date.now()
+        });
+
+        return token;
+    }
+
+    /**
+     * Get project ID for an account
+     */
+    async getProjectForAccount(account, token) {
+        // Check cache first
+        const cached = this.#projectCache.get(account.email);
+        if (cached) {
+            return cached;
+        }
+
+        // OAuth or manual accounts may have projectId specified
+        if (account.projectId) {
+            this.#projectCache.set(account.email, account.projectId);
+            return account.projectId;
+        }
+
+        // Discover project via loadCodeAssist API
+        const project = await this.#discoverProject(token);
+        this.#projectCache.set(account.email, project);
+        return project;
+    }
+
+    /**
+     * Discover project ID via Cloud Code API
+     */
+    async #discoverProject(token) {
+        for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
+            try {
+                const response = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Content-Type': 'application/json',
+                        ...ANTIGRAVITY_HEADERS
+                    },
+                    body: JSON.stringify({
+                        metadata: {
+                            ideType: 'IDE_UNSPECIFIED',
+                            platform: 'PLATFORM_UNSPECIFIED',
+                            pluginType: 'GEMINI'
+                        }
+                    })
+                });
+
+                if (!response.ok) continue;
+
+                const data = await response.json();
+
+                if (typeof data.cloudaicompanionProject === 'string') {
+                    return data.cloudaicompanionProject;
+                }
+                if (data.cloudaicompanionProject?.id) {
+                    return data.cloudaicompanionProject.id;
+                }
+            } catch (error) {
+                console.log(`[AccountManager] Project discovery failed at ${endpoint}:`, error.message);
+            }
+        }
+
+        console.log(`[AccountManager] Using default project: ${DEFAULT_PROJECT_ID}`);
+        return DEFAULT_PROJECT_ID;
+    }
+
+    /**
+     * Clear project cache for an account (useful on auth errors)
+     */
+    clearProjectCache(email = null) {
+        if (email) {
+            this.#projectCache.delete(email);
+        } else {
+            this.#projectCache.clear();
+        }
+    }
+
+    /**
+     * Clear token cache for an account (useful on auth errors)
+     */
+    clearTokenCache(email = null) {
+        if (email) {
+            this.#tokenCache.delete(email);
+        } else {
+            this.#tokenCache.clear();
+        }
+    }
+
+    /**
+     * Save current state to disk
+     */
+    saveToDisk() {
+        try {
+            // Ensure directory exists
+            const dir = dirname(this.#configPath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+
+            const config = {
+                accounts: this.#accounts.map(acc => ({
+                    email: acc.email,
+                    source: acc.source,
+                    dbPath: acc.dbPath || null,
+                    refreshToken: acc.source === 'oauth' ? acc.refreshToken : undefined,
+                    apiKey: acc.source === 'manual' ? acc.apiKey : undefined,
+                    projectId: acc.projectId || undefined,
+                    addedAt: acc.addedAt || undefined,
+                    isRateLimited: acc.isRateLimited,
+                    rateLimitResetTime: acc.rateLimitResetTime,
+                    isInvalid: acc.isInvalid || false,
+                    invalidReason: acc.invalidReason || null,
+                    lastUsed: acc.lastUsed
+                })),
+                settings: this.#settings,
+                activeIndex: this.#currentIndex
+            };
+
+            writeFileSync(this.#configPath, JSON.stringify(config, null, 2));
+        } catch (error) {
+            console.error('[AccountManager] Failed to save config:', error.message);
+        }
+    }
+
+    /**
+     * Get status object for logging/API
+     */
+    getStatus() {
+        const available = this.getAvailableAccounts();
+        const rateLimited = this.#accounts.filter(a => a.isRateLimited);
+        const invalid = this.getInvalidAccounts();
+
+        return {
+            total: this.#accounts.length,
+            available: available.length,
+            rateLimited: rateLimited.length,
+            invalid: invalid.length,
+            summary: `${this.#accounts.length} total, ${available.length} available, ${rateLimited.length} rate-limited, ${invalid.length} invalid`,
+            accounts: this.#accounts.map(a => ({
+                email: a.email,
+                source: a.source,
+                isRateLimited: a.isRateLimited,
+                rateLimitResetTime: a.rateLimitResetTime,
+                isInvalid: a.isInvalid || false,
+                invalidReason: a.invalidReason || null,
+                lastUsed: a.lastUsed
+            }))
+        };
+    }
+
+    /**
+     * Get settings
+     */
+    getSettings() {
+        return { ...this.#settings };
+    }
+}
+
+// Export helper functions
+export { formatDuration, sleep };
+
+export default AccountManager;

src/accounts-cli.js

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+
+/**
+ * Account Management CLI
+ *
+ * Interactive CLI for adding and managing Google accounts
+ * for the Antigravity Claude Proxy.
+ *
+ * Usage:
+ *   node src/accounts-cli.js          # Interactive mode
+ *   node src/accounts-cli.js add      # Add new account(s)
+ *   node src/accounts-cli.js list     # List all accounts
+ *   node src/accounts-cli.js clear    # Remove all accounts
+ */
+
+import { createInterface } from 'readline/promises';
+import { stdin, stdout } from 'process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { exec } from 'child_process';
+import { ACCOUNT_CONFIG_PATH } from './constants.js';
+import {
+    getAuthorizationUrl,
+    startCallbackServer,
+    completeOAuthFlow,
+    refreshAccessToken,
+    getUserEmail
+} from './oauth.js';
+
+const MAX_ACCOUNTS = 10;
+
+/**
+ * Create readline interface
+ */
+function createRL() {
+    return createInterface({ input: stdin, output: stdout });
+}
+
+/**
+ * Open URL in default browser
+ */
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+
+    if (platform === 'darwin') {
+        command = `open "${url}"`;
+    } else if (platform === 'win32') {
+        command = `start "" "${url}"`;
+    } else {
+        command = `xdg-open "${url}"`;
+    }
+
+    exec(command, (error) => {
+        if (error) {
+            console.log('\n⚠ Could not open browser automatically.');
+            console.log('Please open this URL manually:', url);
+        }
+    });
+}
+
+/**
+ * Load existing accounts from config
+ */
+function loadAccounts() {
+    try {
+        if (existsSync(ACCOUNT_CONFIG_PATH)) {
+            const data = readFileSync(ACCOUNT_CONFIG_PATH, 'utf-8');
+            const config = JSON.parse(data);
+            return config.accounts || [];
+        }
+    } catch (error) {
+        console.error('Error loading accounts:', error.message);
+    }
+    return [];
+}
+
+/**
+ * Save accounts to config
+ */
+function saveAccounts(accounts, settings = {}) {
+    try {
+        const dir = dirname(ACCOUNT_CONFIG_PATH);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+
+        const config = {
+            accounts: accounts.map(acc => ({
+                email: acc.email,
+                source: 'oauth',
+                refreshToken: acc.refreshToken,
+                projectId: acc.projectId,
+                addedAt: acc.addedAt || new Date().toISOString(),
+                lastUsed: acc.lastUsed || null,
+                isRateLimited: acc.isRateLimited || false,
+                rateLimitResetTime: acc.rateLimitResetTime || null
+            })),
+            settings: {
+                cooldownDurationMs: 60000,
+                maxRetries: 5,
+                ...settings
+            },
+            activeIndex: 0
+        };
+
+        writeFileSync(ACCOUNT_CONFIG_PATH, JSON.stringify(config, null, 2));
+        console.log(`\n✓ Saved ${accounts.length} account(s) to ${ACCOUNT_CONFIG_PATH}`);
+    } catch (error) {
+        console.error('Error saving accounts:', error.message);
+        throw error;
+    }
+}
+
+/**
+ * Display current accounts
+ */
+function displayAccounts(accounts) {
+    if (accounts.length === 0) {
+        console.log('\nNo accounts configured.');
+        return;
+    }
+
+    console.log(`\n${accounts.length} account(s) saved:`);
+    accounts.forEach((acc, i) => {
+        const status = acc.isRateLimited ? ' (rate-limited)' : '';
+        console.log(`  ${i + 1}. ${acc.email}${status}`);
+    });
+}
+
+/**
+ * Add a new account via OAuth with automatic callback
+ */
+async function addAccount(existingAccounts) {
+    console.log('\n=== Add Google Account ===\n');
+
+    // Generate authorization URL
+    const { url, verifier, state } = getAuthorizationUrl();
+
+    console.log('Opening browser for Google sign-in...');
+    console.log('(If browser does not open, copy this URL manually)\n');
+    console.log(`   ${url}\n`);
+
+    // Open browser
+    openBrowser(url);
+
+    // Start callback server and wait for code
+    console.log('Waiting for authentication (timeout: 2 minutes)...\n');
+
+    try {
+        const code = await startCallbackServer(state);
+
+        console.log('Received authorization code. Exchanging for tokens...');
+        const result = await completeOAuthFlow(code, verifier);
+
+        // Check if account already exists
+        const existing = existingAccounts.find(a => a.email === result.email);
+        if (existing) {
+            console.log(`\n⚠ Account ${result.email} already exists. Updating tokens.`);
+            existing.refreshToken = result.refreshToken;
+            existing.projectId = result.projectId;
+            existing.addedAt = new Date().toISOString();
+            return null; // Don't add duplicate
+        }
+
+        console.log(`\n✓ Successfully authenticated: ${result.email}`);
+        if (result.projectId) {
+            console.log(`  Project ID: ${result.projectId}`);
+        }
+
+        return {
+            email: result.email,
+            refreshToken: result.refreshToken,
+            projectId: result.projectId,
+            addedAt: new Date().toISOString(),
+            isRateLimited: false,
+            rateLimitResetTime: null
+        };
+    } catch (error) {
+        console.error(`\n✗ Authentication failed: ${error.message}`);
+        return null;
+    }
+}
+
+/**
+ * Interactive add accounts flow
+ */
+async function interactiveAdd(rl) {
+    const accounts = loadAccounts();
+
+    if (accounts.length > 0) {
+        displayAccounts(accounts);
+
+        const choice = await rl.question('\n(a)dd new account(s) or (f)resh start? [a/f]: ');
+
+        if (choice.toLowerCase() === 'f') {
+            console.log('\nStarting fresh - existing accounts will be replaced.');
+            accounts.length = 0;
+        } else {
+            console.log('\nAdding to existing accounts.');
+        }
+    }
+
+    // Add accounts loop
+    while (accounts.length < MAX_ACCOUNTS) {
+        const newAccount = await addAccount(accounts);
+        if (newAccount) {
+            accounts.push(newAccount);
+            // Auto-save after each successful add to prevent data loss
+            saveAccounts(accounts);
+        } else if (accounts.length > 0) {
+            // Even if newAccount is null (duplicate update), save the updated accounts
+            saveAccounts(accounts);
+        }
+
+        if (accounts.length >= MAX_ACCOUNTS) {
+            console.log(`\nMaximum of ${MAX_ACCOUNTS} accounts reached.`);
+            break;
+        }
+
+        const addMore = await rl.question('\nAdd another account? [y/N]: ');
+        if (addMore.toLowerCase() !== 'y') {
+            break;
+        }
+    }
+
+    if (accounts.length > 0) {
+        displayAccounts(accounts);
+    } else {
+        console.log('\nNo accounts to save.');
+    }
+}
+
+/**
+ * List accounts
+ */
+async function listAccounts() {
+    const accounts = loadAccounts();
+    displayAccounts(accounts);
+
+    if (accounts.length > 0) {
+        console.log(`\nConfig file: ${ACCOUNT_CONFIG_PATH}`);
+    }
+}
+
+/**
+ * Clear all accounts
+ */
+async function clearAccounts(rl) {
+    const accounts = loadAccounts();
+
+    if (accounts.length === 0) {
+        console.log('No accounts to clear.');
+        return;
+    }
+
+    displayAccounts(accounts);
+
+    const confirm = await rl.question('\nAre you sure you want to remove all accounts? [y/N]: ');
+    if (confirm.toLowerCase() === 'y') {
+        saveAccounts([]);
+        console.log('All accounts removed.');
+    } else {
+        console.log('Cancelled.');
+    }
+}
+
+/**
+ * Verify accounts (test refresh tokens)
+ */
+async function verifyAccounts() {
+    const accounts = loadAccounts();
+
+    if (accounts.length === 0) {
+        console.log('No accounts to verify.');
+        return;
+    }
+
+    console.log('\nVerifying accounts...\n');
+
+    for (const account of accounts) {
+        try {
+            const tokens = await refreshAccessToken(account.refreshToken);
+            const email = await getUserEmail(tokens.accessToken);
+            console.log(`  ✓ ${email} - OK`);
+        } catch (error) {
+            console.log(`  ✗ ${account.email} - ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Main CLI
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || 'add';
+
+    console.log('╔════════════════════════════════════════╗');
+    console.log('║   Antigravity Proxy Account Manager    ║');
+    console.log('╚════════════════════════════════════════╝');
+
+    const rl = createRL();
+
+    try {
+        switch (command) {
+            case 'add':
+                await interactiveAdd(rl);
+                break;
+            case 'list':
+                await listAccounts();
+                break;
+            case 'clear':
+                await clearAccounts(rl);
+                break;
+            case 'verify':
+                await verifyAccounts();
+                break;
+            case 'help':
+                console.log('\nUsage:');
+                console.log('  node src/accounts-cli.js add     Add new account(s)');
+                console.log('  node src/accounts-cli.js list    List all accounts');
+                console.log('  node src/accounts-cli.js verify  Verify account tokens');
+                console.log('  node src/accounts-cli.js clear   Remove all accounts');
+                console.log('  node src/accounts-cli.js help    Show this help');
+                break;
+            default:
+                console.log(`Unknown command: ${command}`);
+                console.log('Run with "help" for usage information.');
+        }
+    } finally {
+        rl.close();
+    }
+}
+
+main().catch(console.error);

src/cloudcode-client.js

@@ -4,105 +4,170 @@
  * Communicates with Google's Cloud Code internal API using the
  * v1internal:streamGenerateContent endpoint with proper request wrapping.
  *
+ * Supports multi-account load balancing with automatic failover.
+ *
  * Based on: https://github.com/NoeFabris/opencode-antigravity-auth
  */
 
 import crypto from 'crypto';
-import { getToken, refreshToken } from './token-extractor.js';
 import {
     ANTIGRAVITY_ENDPOINT_FALLBACKS,
     ANTIGRAVITY_HEADERS,
     AVAILABLE_MODELS,
-    DEFAULT_PROJECT_ID,
+    MAX_RETRIES
-    STREAMING_CHUNK_SIZE
 } from './constants.js';
 import {
     mapModelName,
     convertAnthropicToGoogle,
-    convertGoogleToAnthropic,
+    convertGoogleToAnthropic
-    convertStreamingChunk
 } from './format-converter.js';
-
+import { formatDuration, sleep } from './account-manager.js';
-// Cache the project ID
-let cachedProject = null;
 
 /**
- * Get the user's cloudaicompanion project from the API
+ * Check if an error is a rate limit error (429 or RESOURCE_EXHAUSTED)
  */
-export async function getProject(token) {
+function is429Error(error) {
-    if (cachedProject) {
+    const msg = (error.message || '').toLowerCase();
-        return cachedProject;
+    return msg.includes('429') ||
-    }
+        msg.includes('resource_exhausted') ||
-
+        msg.includes('quota_exhausted') ||
-    console.log('[CloudCode] Getting project from loadCodeAssist...');
+        msg.includes('rate limit');
-
-    // Try each endpoint
-    for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
-        try {
-            const response = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${token}`,
-                    'Content-Type': 'application/json',
-                    ...ANTIGRAVITY_HEADERS
-                },
-                body: JSON.stringify({
-                    metadata: {
-                        ideType: 'IDE_UNSPECIFIED',
-                        platform: 'PLATFORM_UNSPECIFIED',
-                        pluginType: 'GEMINI'
-                    }
-                })
-            });
-
-            if (!response.ok) {
-                console.log(`[CloudCode] loadCodeAssist failed at ${endpoint}: ${response.status}`);
-                continue;
-            }
-
-            const data = await response.json();
-
-            // Extract project ID from response
-            if (typeof data.cloudaicompanionProject === 'string' && data.cloudaicompanionProject) {
-                cachedProject = data.cloudaicompanionProject;
-                console.log(`[CloudCode] Got project: ${cachedProject}`);
-                return cachedProject;
-            }
-
-            if (data.cloudaicompanionProject?.id) {
-                cachedProject = data.cloudaicompanionProject.id;
-                console.log(`[CloudCode] Got project: ${cachedProject}`);
-                return cachedProject;
-            }
-
-            console.log(`[CloudCode] No project in response from ${endpoint}`);
-        } catch (error) {
-            console.log(`[CloudCode] Error at ${endpoint}:`, error.message);
-        }
-    }
-
-    // Use default project if discovery fails
-    console.log(`[CloudCode] Using default project: ${DEFAULT_PROJECT_ID}`);
-    cachedProject = DEFAULT_PROJECT_ID;
-    return cachedProject;
 }
 
 /**
- * Clear the cached project
+ * Check if an error is an auth-invalid error (credentials need re-authentication)
  */
-export function clearProjectCache() {
+function isAuthInvalidError(error) {
-    cachedProject = null;
+    const msg = (error.message || '').toUpperCase();
+    return msg.includes('AUTH_INVALID') ||
+        msg.includes('INVALID_GRANT') ||
+        msg.includes('TOKEN REFRESH FAILED');
 }
 
 /**
- * Refresh token and get project - helper to avoid duplicate logic
+ * 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
  */
-async function refreshAndGetProject() {
+function parseResetTime(responseOrError, errorText = '') {
-    await refreshToken();
+    let resetMs = null;
-    const token = await getToken();
+
-    clearProjectCache();
+    // If it's a Response object, check headers first
-    const project = await getProject(token);
+    if (responseOrError && typeof responseOrError.headers?.get === 'function') {
-    return { token, project };
+        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;
+                console.log(`[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) {
+                        console.log(`[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) {
+                    console.log(`[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;
+                    console.log(`[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 "retry-after-ms" or "retryDelay" in ms
+        const msMatch = msg.match(/retry[-_]?after[-_]?ms[:\s"]+(\d+)/i) ||
+                        msg.match(/retryDelay[:\s"]+(\d+)/i);
+        if (msMatch) {
+            resetMs = parseInt(msMatch[1], 10);
+            console.log(`[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;
+                console.log(`[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) {
+                    console.log(`[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) {
+                        console.log(`[CloudCode] Parsed ISO reset time: ${isoMatch[1]}`);
+                    } else {
+                        resetMs = null;
+                    }
+                }
+            }
+        }
+    }
+
+    return resetMs;
 }
 
 /**
@@ -112,8 +177,8 @@ function buildCloudCodeRequest(anthropicRequest, projectId) {
     const model = mapModelName(anthropicRequest.model);
     const googleRequest = convertAnthropicToGoogle(anthropicRequest);
 
-    // Add session ID
+    // Use random session ID for API tracking
-    googleRequest.sessionId = '-' + Math.floor(Math.random() * 9000000000000000000).toString();
+    googleRequest.sessionId = crypto.randomUUID();
 
     const payload = {
         project: projectId,
@@ -132,20 +197,74 @@ function buildCloudCodeRequest(anthropicRequest, projectId) {
 }
 
 /**
- * Send a non-streaming request to Cloud Code
+ * Build headers for Cloud Code API requests
  */
-export async function sendMessage(anthropicRequest) {
+function buildHeaders(token, model, accept = 'application/json') {
-    let token = await getToken();
+    const headers = {
-    let project;
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        ...ANTIGRAVITY_HEADERS
+    };
 
-    try {
+    // Add interleaved thinking header for Claude thinking models
-        project = await getProject(token);
+    const isThinkingModel = model.toLowerCase().includes('thinking');
-    } catch (err) {
+    if (isThinkingModel) {
-        console.log('[CloudCode] Project fetch failed, refreshing token...');
+        headers['anthropic-beta'] = 'interleaved-thinking-2025-05-14';
-        ({ token, project } = await refreshAndGetProject());
     }
 
+    if (accept !== 'application/json') {
+        headers['Accept'] = accept;
+    }
+
+    return headers;
+}
+
+/**
+ * Send a non-streaming request to Cloud Code with multi-account support
+ * Uses SSE endpoint for thinking models (non-streaming doesn't return thinking blocks)
+ *
+ * @param {Object} anthropicRequest - The Anthropic-format request
+ * @param {AccountManager} accountManager - The account manager instance
+ */
+export async function sendMessage(anthropicRequest, accountManager) {
     const model = mapModelName(anthropicRequest.model);
+    const isThinkingModel = model.toLowerCase().includes('thinking');
+
+    // Retry loop with account failover
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        // Get next available account
+        let account = accountManager.pickNext();
+
+        // Handle all accounts rate-limited
+        if (!account) {
+            if (accountManager.isAllRateLimited()) {
+                const waitMs = accountManager.getMinWaitTimeMs();
+
+                if (accountManager.getAccountCount() === 1) {
+                    // Single account mode: wait for reset
+                    console.log(`[CloudCode] Single account rate-limited. Waiting ${formatDuration(waitMs)}...`);
+                    await sleep(waitMs);
+                    accountManager.clearExpiredLimits();
+                    account = accountManager.pickNext();
+                } else {
+                    // Multi-account: all exhausted - throw proper error
+                    const resetTime = new Date(Date.now() + waitMs).toISOString();
+                    throw new Error(
+                        `RESOURCE_EXHAUSTED: All ${accountManager.getAccountCount()} accounts rate-limited. ` +
+                        `quota will reset after ${formatDuration(waitMs)}. Next available: ${resetTime}`
+                    );
+                }
+            }
+
+            if (!account) {
+                throw new Error('No accounts available');
+            }
+        }
+
+        try {
+            // Get token and project for this account
+            const token = await accountManager.getTokenForAccount(account);
+            const project = await accountManager.getProjectForAccount(account, token);
             const payload = buildCloudCodeRequest(anthropicRequest, project);
 
             console.log(`[CloudCode] Sending request for model: ${model}`);
@@ -154,15 +273,13 @@ export async function sendMessage(anthropicRequest) {
             let lastError = null;
             for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
                 try {
-            const url = `${endpoint}/v1internal:generateContent`;
+                    const url = isThinkingModel
+                        ? `${endpoint}/v1internal:streamGenerateContent?alt=sse`
+                        : `${endpoint}/v1internal:generateContent`;
 
                     const response = await fetch(url, {
                         method: 'POST',
-                headers: {
+                        headers: buildHeaders(token, model, isThinkingModel ? 'text/event-stream' : 'application/json'),
-                    'Authorization': `Bearer ${token}`,
-                    'Content-Type': 'application/json',
-                    ...ANTIGRAVITY_HEADERS
-                },
                         body: JSON.stringify(payload)
                     });
 
@@ -170,146 +287,552 @@ export async function sendMessage(anthropicRequest) {
                         const errorText = await response.text();
                         console.log(`[CloudCode] Error at ${endpoint}: ${response.status} - ${errorText}`);
 
-                // Handle auth errors
                         if (response.status === 401) {
+                            // Auth error - clear caches and retry with fresh token
                             console.log('[CloudCode] Auth error, refreshing token...');
-                    ({ token, project } = await refreshAndGetProject());
+                            accountManager.clearTokenCache(account.email);
-                    // Retry with new token
+                            accountManager.clearProjectCache(account.email);
-                    payload.project = project;
                             continue;
                         }
 
-                // Handle rate limiting
                         if (response.status === 429) {
-                    lastError = new Error(`Rate limited: ${errorText}`);
+                            // Rate limited on this endpoint - try next endpoint first (DAILY → PROD)
+                            console.log(`[CloudCode] Rate limited at ${endpoint}, trying next endpoint...`);
+                            const resetMs = parseResetTime(response, errorText);
+                            // Keep minimum reset time across all 429 responses
+                            if (!lastError?.is429 || (resetMs && (!lastError.resetMs || resetMs < lastError.resetMs))) {
+                                lastError = { is429: true, response, errorText, resetMs };
+                            }
                             continue;
                         }
 
-                // Try next endpoint for 4xx/5xx errors
                         if (response.status >= 400) {
                             lastError = new Error(`API error ${response.status}: ${errorText}`);
                             continue;
                         }
                     }
 
+                    // For thinking models, parse SSE and accumulate all parts
+                    if (isThinkingModel) {
+                        return await parseThinkingSSEResponse(response, anthropicRequest.model);
+                    }
+
+                    // Non-thinking models use regular JSON
                     const data = await response.json();
                     console.log('[CloudCode] Response received');
-
                     return convertGoogleToAnthropic(data, anthropicRequest.model);
 
-        } catch (error) {
+                } catch (endpointError) {
-            console.log(`[CloudCode] Error at ${endpoint}:`, error.message);
+                    if (is429Error(endpointError)) {
-            lastError = error;
+                        throw endpointError; // Re-throw to trigger account switch
+                    }
+                    console.log(`[CloudCode] Error at ${endpoint}:`, endpointError.message);
+                    lastError = endpointError;
                 }
             }
 
-    throw lastError || new Error('All endpoints failed');
+            // If all endpoints failed for this account
+            if (lastError) {
+                // If all endpoints returned 429, mark account as rate-limited
+                if (lastError.is429) {
+                    console.log(`[CloudCode] All endpoints rate-limited for ${account.email}`);
+                    accountManager.markRateLimited(account.email, lastError.resetMs);
+                    throw new Error(`Rate limited: ${lastError.errorText}`);
+                }
+                throw lastError;
+            }
+
+        } catch (error) {
+            if (is429Error(error)) {
+                // Rate limited - already marked, continue to next account
+                console.log(`[CloudCode] Account ${account.email} rate-limited, trying next...`);
+                continue;
+            }
+            if (isAuthInvalidError(error)) {
+                // Auth invalid - already marked, continue to next account
+                console.log(`[CloudCode] Account ${account.email} has invalid credentials, trying next...`);
+                continue;
+            }
+            // Non-rate-limit error: throw immediately
+            throw error;
+        }
+    }
+
+    throw new Error('Max retries exceeded');
 }
 
 /**
- * Send a streaming request to Cloud Code
+ * Parse SSE response for thinking models and accumulate all parts
- * Note: Antigravity's streaming API doesn't actually stream text incrementally,
- * so we use the non-streaming API and simulate SSE events for client compatibility.
  */
-export async function* sendMessageStream(anthropicRequest) {
+async function parseThinkingSSEResponse(response, originalModel) {
-    // Get the full response first
+    let accumulatedThinkingText = '';
-    const fullResponse = await sendMessage(anthropicRequest);
+    let accumulatedThinkingSignature = '';
+    let accumulatedText = '';
+    const finalParts = [];
+    let usageMetadata = {};
+    let finishReason = 'STOP';
 
-    console.log('[CloudCode] Simulating stream from full response');
+    const flushThinking = () => {
-
+        if (accumulatedThinkingText) {
-    // Emit message_start
+            finalParts.push({
-    yield {
+                thought: true,
-        type: 'message_start',
+                text: accumulatedThinkingText,
-        message: {
+                thoughtSignature: accumulatedThinkingSignature
-            id: fullResponse.id,
+            });
-            type: 'message',
+            accumulatedThinkingText = '';
-            role: 'assistant',
+            accumulatedThinkingSignature = '';
-            content: [],
-            model: fullResponse.model,
-            stop_reason: null,
-            stop_sequence: null,
-            usage: { input_tokens: fullResponse.usage?.input_tokens || 0, output_tokens: 0 }
         }
     };
 
-    // Process each content block
+    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;
+                    }
+                }
+            } catch (e) { /* skip parse errors */ }
+        }
+    }
+
+    flushThinking();
+    flushText();
+
+    const accumulatedResponse = {
+        candidates: [{ content: { parts: finalParts }, finishReason }],
+        usageMetadata
+    };
+
+    const partTypes = finalParts.map(p => p.thought ? 'thought' : (p.functionCall ? 'functionCall' : 'text'));
+    console.log('[CloudCode] Response received (SSE), part types:', partTypes);
+    if (finalParts.some(p => p.thought)) {
+        const thinkingPart = finalParts.find(p => p.thought);
+        console.log('[CloudCode] Thinking signature length:', thinkingPart?.thoughtSignature?.length || 0);
+    }
+
+    return convertGoogleToAnthropic(accumulatedResponse, originalModel);
+}
+
+/**
+ * Send a streaming request to Cloud Code with multi-account support
+ * Streams events in real-time as they arrive from the server
+ *
+ * @param {Object} anthropicRequest - The Anthropic-format request
+ * @param {AccountManager} accountManager - The account manager instance
+ */
+export async function* sendMessageStream(anthropicRequest, accountManager) {
+    const model = mapModelName(anthropicRequest.model);
+
+    // Retry loop with account failover
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        // Get next available account
+        let account = accountManager.pickNext();
+
+        // Handle all accounts rate-limited
+        if (!account) {
+            if (accountManager.isAllRateLimited()) {
+                const waitMs = accountManager.getMinWaitTimeMs();
+
+                if (accountManager.getAccountCount() === 1) {
+                    // Single account mode: wait for reset
+                    console.log(`[CloudCode] Single account rate-limited. Waiting ${formatDuration(waitMs)}...`);
+                    await sleep(waitMs);
+                    accountManager.clearExpiredLimits();
+                    account = accountManager.pickNext();
+                } else {
+                    // Multi-account: all exhausted - throw proper error
+                    const resetTime = new Date(Date.now() + waitMs).toISOString();
+                    throw new Error(
+                        `RESOURCE_EXHAUSTED: All ${accountManager.getAccountCount()} accounts rate-limited. ` +
+                        `quota will reset after ${formatDuration(waitMs)}. Next available: ${resetTime}`
+                    );
+                }
+            }
+
+            if (!account) {
+                throw new Error('No accounts available');
+            }
+        }
+
+        try {
+            // Get token and project for this account
+            const token = await accountManager.getTokenForAccount(account);
+            const project = await accountManager.getProjectForAccount(account, token);
+            const payload = buildCloudCodeRequest(anthropicRequest, project);
+
+            console.log(`[CloudCode] Starting stream for model: ${model}`);
+
+            // Try each endpoint for streaming
+            let lastError = null;
+            for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
+                try {
+                    const url = `${endpoint}/v1internal:streamGenerateContent?alt=sse`;
+
+                    const response = await fetch(url, {
+                        method: 'POST',
+                        headers: buildHeaders(token, model, 'text/event-stream'),
+                        body: JSON.stringify(payload)
+                    });
+
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        console.log(`[CloudCode] Stream error at ${endpoint}: ${response.status} - ${errorText}`);
+
+                        if (response.status === 401) {
+                            // Auth error - clear caches and retry
+                            accountManager.clearTokenCache(account.email);
+                            accountManager.clearProjectCache(account.email);
+                            continue;
+                        }
+
+                        if (response.status === 429) {
+                            // Rate limited on this endpoint - try next endpoint first (DAILY → PROD)
+                            console.log(`[CloudCode] Stream rate limited at ${endpoint}, trying next endpoint...`);
+                            const resetMs = parseResetTime(response, errorText);
+                            // Keep minimum reset time across all 429 responses
+                            if (!lastError?.is429 || (resetMs && (!lastError.resetMs || resetMs < lastError.resetMs))) {
+                                lastError = { is429: true, response, errorText, resetMs };
+                            }
+                            continue;
+                        }
+
+                        lastError = new Error(`API error ${response.status}: ${errorText}`);
+                        continue;
+                    }
+
+                    // Stream the response - yield events as they arrive
+                    yield* streamSSEResponse(response, anthropicRequest.model);
+
+                    console.log('[CloudCode] Stream completed');
+                    return;
+
+                } catch (endpointError) {
+                    if (is429Error(endpointError)) {
+                        throw endpointError; // Re-throw to trigger account switch
+                    }
+                    console.log(`[CloudCode] Stream error at ${endpoint}:`, endpointError.message);
+                    lastError = endpointError;
+                }
+            }
+
+            // If all endpoints failed for this account
+            if (lastError) {
+                // If all endpoints returned 429, mark account as rate-limited
+                if (lastError.is429) {
+                    console.log(`[CloudCode] All endpoints rate-limited for ${account.email}`);
+                    accountManager.markRateLimited(account.email, lastError.resetMs);
+                    throw new Error(`Rate limited: ${lastError.errorText}`);
+                }
+                throw lastError;
+            }
+
+        } catch (error) {
+            if (is429Error(error)) {
+                // Rate limited - already marked, continue to next account
+                console.log(`[CloudCode] Account ${account.email} rate-limited, trying next...`);
+                continue;
+            }
+            if (isAuthInvalidError(error)) {
+                // Auth invalid - already marked, continue to next account
+                console.log(`[CloudCode] Account ${account.email} has invalid credentials, trying next...`);
+                continue;
+            }
+            // Non-rate-limit error: throw immediately
+            throw error;
+        }
+    }
+
+    throw new Error('Max retries exceeded');
+}
+
+/**
+ * Stream SSE response and yield Anthropic-format events
+ */
+async function* streamSSEResponse(response, originalModel) {
+    const messageId = `msg_${crypto.randomBytes(16).toString('hex')}`;
+    let hasEmittedStart = false;
     let blockIndex = 0;
-    for (const block of fullResponse.content) {
+    let currentBlockType = null;
-        if (block.type === 'text') {
+    let currentThinkingSignature = '';
-            // content_block_start
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let stopReason = 'end_turn';
+
+    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;
+
+                // Extract usage metadata
+                const usage = innerResponse.usageMetadata;
+                if (usage) {
+                    inputTokens = usage.promptTokenCount || inputTokens;
+                    outputTokens = usage.candidatesTokenCount || outputTokens;
+                }
+
+                const candidates = innerResponse.candidates || [];
+                const firstCandidate = candidates[0] || {};
+                const content = firstCandidate.content || {};
+                const parts = content.parts || [];
+
+                // Emit message_start on first data
+                if (!hasEmittedStart && parts.length > 0) {
+                    hasEmittedStart = true;
+                    yield {
+                        type: 'message_start',
+                        message: {
+                            id: messageId,
+                            type: 'message',
+                            role: 'assistant',
+                            content: [],
+                            model: originalModel,
+                            stop_reason: null,
+                            stop_sequence: null,
+                            usage: { input_tokens: inputTokens, output_tokens: 0 }
+                        }
+                    };
+                }
+
+                // Process each part
+                for (const part of parts) {
+                    if (part.thought === true) {
+                        // Handle thinking block
+                        const text = part.text || '';
+                        const signature = part.thoughtSignature || '';
+
+                        if (currentBlockType !== 'thinking') {
+                            if (currentBlockType !== null) {
+                                yield { type: 'content_block_stop', index: blockIndex };
+                                blockIndex++;
+                            }
+                            currentBlockType = 'thinking';
+                            currentThinkingSignature = '';
+                            yield {
+                                type: 'content_block_start',
+                                index: blockIndex,
+                                content_block: { type: 'thinking', thinking: '' }
+                            };
+                        }
+
+                        if (signature && signature.length >= 50) {
+                            currentThinkingSignature = signature;
+                        }
+
+                        yield {
+                            type: 'content_block_delta',
+                            index: blockIndex,
+                            delta: { type: 'thinking_delta', thinking: text }
+                        };
+
+                    } else if (part.text !== undefined) {
+                        // Skip empty text parts
+                        if (!part.text || part.text.trim().length === 0) {
+                            continue;
+                        }
+
+                        // Handle regular text
+                        if (currentBlockType !== 'text') {
+                            if (currentBlockType === 'thinking' && currentThinkingSignature) {
+                                yield {
+                                    type: 'content_block_delta',
+                                    index: blockIndex,
+                                    delta: { type: 'signature_delta', signature: currentThinkingSignature }
+                                };
+                                currentThinkingSignature = '';
+                            }
+                            if (currentBlockType !== null) {
+                                yield { type: 'content_block_stop', index: blockIndex };
+                                blockIndex++;
+                            }
+                            currentBlockType = 'text';
                             yield {
                                 type: 'content_block_start',
                                 index: blockIndex,
                                 content_block: { type: 'text', text: '' }
                             };
+                        }
 
-            // Stream text in chunks for a more realistic streaming experience
-            const text = block.text;
-
-            for (let i = 0; i < text.length; i += STREAMING_CHUNK_SIZE) {
-                const chunk = text.slice(i, i + STREAMING_CHUNK_SIZE);
                         yield {
                             type: 'content_block_delta',
                             index: blockIndex,
-                    delta: { type: 'text_delta', text: chunk }
+                            delta: { type: 'text_delta', text: part.text }
                         };
-            }
 
-            // content_block_stop
+                    } else if (part.functionCall) {
+                        // Handle tool use
+                        if (currentBlockType === 'thinking' && currentThinkingSignature) {
                             yield {
-                type: 'content_block_stop',
+                                type: 'content_block_delta',
-                index: blockIndex
+                                index: blockIndex,
+                                delta: { type: 'signature_delta', signature: currentThinkingSignature }
                             };
-
+                            currentThinkingSignature = '';
+                        }
+                        if (currentBlockType !== null) {
+                            yield { type: 'content_block_stop', index: blockIndex };
                             blockIndex++;
+                        }
+                        currentBlockType = 'tool_use';
+                        stopReason = 'tool_use';
+
+                        const toolId = part.functionCall.id || `toolu_${crypto.randomBytes(12).toString('hex')}`;
 
-        } else if (block.type === 'tool_use') {
-            // content_block_start for tool_use
                         yield {
                             type: 'content_block_start',
                             index: blockIndex,
                             content_block: {
                                 type: 'tool_use',
-                    id: block.id,
+                                id: toolId,
-                    name: block.name,
+                                name: part.functionCall.name,
                                 input: {}
                             }
                         };
 
-            // Send input as delta
                         yield {
                             type: 'content_block_delta',
                             index: blockIndex,
                             delta: {
                                 type: 'input_json_delta',
-                    partial_json: JSON.stringify(block.input)
+                                partial_json: JSON.stringify(part.functionCall.args || {})
                             }
                         };
+                    }
+                }
 
-            // content_block_stop
+                // Check finish reason
+                if (firstCandidate.finishReason) {
+                    if (firstCandidate.finishReason === 'MAX_TOKENS') {
+                        stopReason = 'max_tokens';
+                    } else if (firstCandidate.finishReason === 'STOP') {
+                        stopReason = 'end_turn';
+                    }
+                }
+
+            } catch (parseError) {
+                console.log('[CloudCode] SSE parse error:', parseError.message);
+            }
+        }
+    }
+
+    // Handle no content received
+    if (!hasEmittedStart) {
+        console.log('[CloudCode] WARNING: No content parts received, emitting empty message');
         yield {
-                type: 'content_block_stop',
+            type: 'message_start',
-                index: blockIndex
+            message: {
+                id: messageId,
+                type: 'message',
+                role: 'assistant',
+                content: [],
+                model: originalModel,
+                stop_reason: null,
+                stop_sequence: null,
+                usage: { input_tokens: inputTokens, output_tokens: 0 }
+            }
         };
 
-            blockIndex++;
+        yield {
+            type: 'content_block_start',
+            index: 0,
+            content_block: { type: 'text', text: '' }
+        };
+        yield {
+            type: 'content_block_delta',
+            index: 0,
+            delta: { type: 'text_delta', text: '[No response received from API]' }
+        };
+        yield { type: 'content_block_stop', index: 0 };
+    } else {
+        // Close any open block
+        if (currentBlockType !== null) {
+            if (currentBlockType === 'thinking' && currentThinkingSignature) {
+                yield {
+                    type: 'content_block_delta',
+                    index: blockIndex,
+                    delta: { type: 'signature_delta', signature: currentThinkingSignature }
+                };
+            }
+            yield { type: 'content_block_stop', index: blockIndex };
         }
     }
 
-    // message_delta
+    // Emit message_delta and message_stop
     yield {
         type: 'message_delta',
-        delta: {
+        delta: { stop_reason: stopReason, stop_sequence: null },
-            stop_reason: fullResponse.stop_reason,
+        usage: { output_tokens: outputTokens }
-            stop_sequence: fullResponse.stop_sequence
-        },
-        usage: { output_tokens: fullResponse.usage?.output_tokens || 0 }
     };
 
-    // message_stop
     yield { type: 'message_stop' };
 }
 
+
 /**
  * List available models
  */
@@ -329,7 +852,5 @@ export function listModels() {
 export default {
     sendMessage,
     sendMessageStream,
-    listModels,
+    listModels
-    clearProjectCache,
-    getProject
 };

src/constants.js

@@ -3,21 +3,19 @@
  * Based on: https://github.com/NoeFabris/opencode-antigravity-auth
  */
 
-// Cloud Code API endpoints (in fallback order)
+import { homedir } from 'os';
-export const ANTIGRAVITY_ENDPOINT_DAILY = 'https://daily-cloudcode-pa.sandbox.googleapis.com';
+import { join } from 'path';
-export const ANTIGRAVITY_ENDPOINT_AUTOPUSH = 'https://autopush-cloudcode-pa.sandbox.googleapis.com';
-export const ANTIGRAVITY_ENDPOINT_PROD = 'https://cloudcode-pa.googleapis.com';
 
-// Endpoint fallback order (daily → autopush → prod)
+// Cloud Code API endpoints (in fallback order)
+const ANTIGRAVITY_ENDPOINT_DAILY = 'https://daily-cloudcode-pa.sandbox.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_AUTOPUSH,
     ANTIGRAVITY_ENDPOINT_PROD
 ];
 
-// Primary endpoint
-export const ANTIGRAVITY_ENDPOINT = ANTIGRAVITY_ENDPOINT_DAILY;
-
 // Required headers for Antigravity API requests
 export const ANTIGRAVITY_HEADERS = {
     'User-Agent': 'antigravity/1.11.5 darwin/arm64',
@@ -70,23 +68,30 @@ export const AVAILABLE_MODELS = [
 // Default project ID if none can be discovered
 export const DEFAULT_PROJECT_ID = 'rising-fact-p41fc';
 
-// Centralized configuration constants
-export const STREAMING_CHUNK_SIZE = 20;
 export const TOKEN_REFRESH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 export const REQUEST_BODY_LIMIT = '50mb';
 export const ANTIGRAVITY_AUTH_PORT = 9092;
 export const DEFAULT_PORT = 8080;
 
+// Multi-account configuration
+export const ACCOUNT_CONFIG_PATH = join(
+    homedir(),
+    '.config/antigravity-proxy/accounts.json'
+);
+export const DEFAULT_COOLDOWN_MS = 60 * 1000; // 1 minute default cooldown
+export const MAX_RETRIES = 5; // Max retry attempts across accounts
+
 export default {
-    ANTIGRAVITY_ENDPOINT,
     ANTIGRAVITY_ENDPOINT_FALLBACKS,
     ANTIGRAVITY_HEADERS,
     MODEL_MAPPINGS,
     AVAILABLE_MODELS,
     DEFAULT_PROJECT_ID,
-    STREAMING_CHUNK_SIZE,
     TOKEN_REFRESH_INTERVAL_MS,
     REQUEST_BODY_LIMIT,
     ANTIGRAVITY_AUTH_PORT,
-    DEFAULT_PORT
+    DEFAULT_PORT,
+    ACCOUNT_CONFIG_PATH,
+    DEFAULT_COOLDOWN_MS,
+    MAX_RETRIES
 };

src/format-converter.js

@@ -10,6 +10,11 @@
 import crypto from 'crypto';
 import { MODEL_MAPPINGS } from './constants.js';
 
+// Default thinking budget (16K tokens)
+const DEFAULT_THINKING_BUDGET = 16000;
+// Claude thinking models need larger max output tokens
+const CLAUDE_THINKING_MAX_OUTPUT_TOKENS = 64000;
+
 /**
  * Map Anthropic model name to Antigravity model name
  */
@@ -17,6 +22,208 @@ export function mapModelName(anthropicModel) {
     return MODEL_MAPPINGS[anthropicModel] || anthropicModel;
 }
 
+/**
+ * Check if a part is a thinking block
+ */
+function isThinkingPart(part) {
+    return part.type === 'thinking' ||
+        part.type === 'redacted_thinking' ||
+        part.thinking !== undefined ||
+        part.thought === true;
+}
+
+/**
+ * Check if a thinking part has a valid signature (>= 50 chars)
+ */
+function hasValidSignature(part) {
+    const signature = part.thought === true ? part.thoughtSignature : part.signature;
+    return typeof signature === 'string' && signature.length >= 50;
+}
+
+/**
+ * Sanitize a thinking part by keeping only allowed fields
+ */
+function sanitizeThinkingPart(part) {
+    // Gemini-style thought blocks: { thought: true, text, thoughtSignature }
+    if (part.thought === true) {
+        const sanitized = { thought: true };
+        if (part.text !== undefined) sanitized.text = part.text;
+        if (part.thoughtSignature !== undefined) sanitized.thoughtSignature = part.thoughtSignature;
+        return sanitized;
+    }
+
+    // Anthropic-style thinking blocks: { type: "thinking", thinking, signature }
+    if (part.type === 'thinking' || part.thinking !== undefined) {
+        const sanitized = { type: 'thinking' };
+        if (part.thinking !== undefined) sanitized.thinking = part.thinking;
+        if (part.signature !== undefined) sanitized.signature = part.signature;
+        return sanitized;
+    }
+
+    return part;
+}
+
+/**
+ * Filter content array, keeping only thinking blocks with valid signatures.
+ * Since signature_delta transmits signatures properly, cache is no longer needed.
+ */
+function filterContentArray(contentArray) {
+    const filtered = [];
+
+    for (const item of contentArray) {
+        if (!item || typeof item !== 'object') {
+            filtered.push(item);
+            continue;
+        }
+
+        if (!isThinkingPart(item)) {
+            filtered.push(item);
+            continue;
+        }
+
+        // Keep items with valid signatures
+        if (hasValidSignature(item)) {
+            filtered.push(sanitizeThinkingPart(item));
+            continue;
+        }
+
+        // Drop unsigned thinking blocks
+        console.log('[FormatConverter] Dropping unsigned thinking block');
+    }
+
+    return filtered;
+}
+
+/**
+ * Filter unsigned thinking blocks from contents (Gemini format)
+ */
+export function filterUnsignedThinkingBlocks(contents) {
+    return contents.map(content => {
+        if (!content || typeof content !== 'object') return content;
+
+        if (Array.isArray(content.parts)) {
+            return { ...content, parts: filterContentArray(content.parts) };
+        }
+
+        return content;
+    });
+}
+
+/**
+ * Remove trailing unsigned thinking blocks from assistant messages.
+ * Claude/Gemini APIs require that assistant messages don't end with unsigned thinking blocks.
+ * This function removes thinking blocks from the end of content arrays.
+ */
+export function removeTrailingThinkingBlocks(content) {
+    if (!Array.isArray(content)) return content;
+    if (content.length === 0) return content;
+
+    // Work backwards from the end, removing thinking blocks
+    let endIndex = content.length;
+    for (let i = content.length - 1; i >= 0; i--) {
+        const block = content[i];
+        if (!block || typeof block !== 'object') break;
+
+        // Check if it's a thinking block (any format)
+        const isThinking = isThinkingPart(block);
+
+        if (isThinking) {
+            // Check if it has a valid signature
+            if (!hasValidSignature(block)) {
+                endIndex = i;
+            } else {
+                break; // Stop at signed thinking block
+            }
+        } else {
+            break; // Stop at first non-thinking block
+        }
+    }
+
+    if (endIndex < content.length) {
+        console.log('[FormatConverter] Removed', content.length - endIndex, 'trailing unsigned thinking blocks');
+        return content.slice(0, endIndex);
+    }
+
+    return content;
+}
+
+/**
+ * Filter thinking blocks: keep only those with valid signatures.
+ * Blocks without signatures are dropped (API requires signatures).
+ */
+export function restoreThinkingSignatures(content) {
+    if (!Array.isArray(content)) return content;
+
+    const originalLength = content.length;
+    const filtered = content.filter(block => {
+        if (!block || block.type !== 'thinking') return true;
+
+        // Keep blocks with valid signatures (>= 50 chars)
+        return block.signature && block.signature.length >= 50;
+    });
+
+    if (filtered.length < originalLength) {
+        console.log(`[FormatConverter] Dropped ${originalLength - filtered.length} unsigned thinking block(s)`);
+    }
+
+    return filtered;
+}
+
+/**
+ * Reorder content so that:
+ * 1. Thinking blocks come first (required when thinking is enabled)
+ * 2. Text blocks come in the middle (filtering out empty/useless ones)
+ * 3. Tool_use blocks come at the end (required before tool_result)
+ *
+ * Claude API requires that when thinking is enabled, assistant messages must start with thinking.
+ */
+export function reorderAssistantContent(content) {
+    if (!Array.isArray(content)) return content;
+    if (content.length <= 1) return content;
+
+    const thinkingBlocks = [];
+    const textBlocks = [];
+    const toolUseBlocks = [];
+    let droppedEmptyBlocks = 0;
+
+    for (const block of content) {
+        if (!block) continue;
+
+        if (block.type === 'thinking') {
+            thinkingBlocks.push(block);
+        } else if (block.type === 'tool_use') {
+            toolUseBlocks.push(block);
+        } else if (block.type === 'text') {
+            // Only keep text blocks with meaningful content
+            if (block.text && block.text.trim().length > 0) {
+                textBlocks.push(block);
+            } else {
+                droppedEmptyBlocks++;
+            }
+        } else {
+            // Other block types go in the text position
+            textBlocks.push(block);
+        }
+    }
+
+    if (droppedEmptyBlocks > 0) {
+        console.log(`[FormatConverter] Dropped ${droppedEmptyBlocks} empty text block(s)`);
+    }
+
+    const reordered = [...thinkingBlocks, ...textBlocks, ...toolUseBlocks];
+
+    // Log only if actual reordering happened (not just filtering)
+    if (reordered.length === content.length) {
+        const originalOrder = content.map(b => b?.type || 'unknown').join(',');
+        const newOrder = reordered.map(b => b?.type || 'unknown').join(',');
+        if (originalOrder !== newOrder) {
+            console.log('[FormatConverter] Reordered assistant content');
+        }
+    }
+
+    return reordered;
+}
+
 /**
  * Convert Anthropic message content to Google Generative AI parts
  */
@@ -33,7 +240,10 @@ function convertContentToParts(content, isClaudeModel = false) {
 
     for (const block of content) {
         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') {
@@ -107,19 +317,21 @@ function convertContentToParts(content, isClaudeModel = false) {
             }
 
             parts.push({ functionResponse });
-        } else if (block.type === 'thinking' || block.type === 'redacted_thinking') {
+        } else if (block.type === 'thinking') {
-            // Skip thinking blocks for Claude models - thinking is handled by the model itself
+            // Handle thinking blocks - only those with valid signatures
-            // For non-Claude models, convert to Google's thought format
+            if (block.signature && block.signature.length >= 50) {
-            if (!isClaudeModel && block.type === 'thinking') {
+                // Convert to Gemini format with signature
                 parts.push({
                     text: block.thinking,
-                    thought: true
+                    thought: true,
+                    thoughtSignature: block.signature
                 });
             }
+            // Unsigned thinking blocks are dropped upstream
         }
     }
 
-    return parts.length > 0 ? parts : [{ text: '' }];
+    return parts;
 }
 
 /**
@@ -142,7 +354,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 isClaudeModel = (anthropicRequest.model || '').toLowerCase().includes('claude');
+    const modelName = anthropicRequest.model || '';
+    const isClaudeModel = modelName.toLowerCase().includes('claude');
+    const isClaudeThinkingModel = isClaudeModel && modelName.toLowerCase().includes('thinking');
+
 
     const googleRequest = {
         contents: [],
@@ -169,9 +384,36 @@ export function convertAnthropicToGoogle(anthropicRequest) {
         }
     }
 
-    // Convert messages to contents
+    // Add interleaved thinking hint for Claude thinking models with tools
+    if (isClaudeThinkingModel && 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 });
+            }
+        }
+    }
+
+    // Convert messages to contents, then filter unsigned thinking blocks
     for (const msg of messages) {
-        const parts = convertContentToParts(msg.content, isClaudeModel);
+        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);
         const content = {
             role: convertRole(msg.role),
             parts: parts
@@ -179,6 +421,11 @@ export function convertAnthropicToGoogle(anthropicRequest) {
         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;
@@ -196,9 +443,24 @@ export function convertAnthropicToGoogle(anthropicRequest) {
         googleRequest.generationConfig.stopSequences = stop_sequences;
     }
 
-    // Extended thinking is disabled for Claude models
+    // Enable thinking for Claude thinking models
-    // The model itself (e.g., claude-opus-4-5-thinking) handles thinking internally
+    if (isClaudeThinkingModel) {
-    // Enabling thinkingConfig causes signature issues in multi-turn conversations
+        // Get budget from request or use default
+        const thinkingBudget = thinking?.budget_tokens || DEFAULT_THINKING_BUDGET;
+
+        googleRequest.generationConfig.thinkingConfig = {
+            include_thoughts: true,
+            thinking_budget: thinkingBudget
+        };
+
+        // Ensure maxOutputTokens is large enough for thinking models
+        if (!googleRequest.generationConfig.maxOutputTokens ||
+            googleRequest.generationConfig.maxOutputTokens <= thinkingBudget) {
+            googleRequest.generationConfig.maxOutputTokens = CLAUDE_THINKING_MAX_OUTPUT_TOKENS;
+        }
+
+        console.log('[FormatConverter] Thinking enabled with budget:', thinkingBudget);
+    }
 
     // Convert tools to Google format
     if (tools && tools.length > 0) {
@@ -232,54 +494,48 @@ export function convertAnthropicToGoogle(anthropicRequest) {
 }
 
 /**
- * Sanitize JSON schema for Google API compatibility
+ * Sanitize JSON Schema for Antigravity API compatibility.
- * Removes unsupported fields like additionalProperties
+ * Uses allowlist approach - only permit known-safe JSON Schema features.
+ * Converts "const" to equivalent "enum" for compatibility.
+ * Generates placeholder schema for empty tool schemas.
  */
 function sanitizeSchema(schema) {
     if (!schema || typeof schema !== 'object') {
-        return schema;
+        // Empty/missing schema - generate placeholder with reason property
+        return {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Reason for calling this tool'
+                }
+            },
+            required: ['reason']
+        };
     }
 
-    // Fields to skip entirely - not compatible with Claude's JSON Schema 2020-12
+    // Allowlist of permitted JSON Schema fields
-    const UNSUPPORTED_FIELDS = new Set([
+    const ALLOWED_FIELDS = new Set([
-        '$schema',
+        'type',
-        'additionalProperties',
+        'description',
-        'default',
+        'properties',
-        'anyOf',
+        'required',
-        'allOf',
+        'items',
-        'oneOf',
+        'enum',
-        'minLength',
+        'title'
-        'maxLength',
-        'pattern',
-        'format',
-        'minimum',
-        'maximum',
-        'exclusiveMinimum',
-        'exclusiveMaximum',
-        'minItems',
-        'maxItems',
-        'uniqueItems',
-        'minProperties',
-        'maxProperties',
-        '$id',
-        '$ref',
-        '$defs',
-        'definitions',
-        'patternProperties',
-        'unevaluatedProperties',
-        'unevaluatedItems',
-        'if',
-        'then',
-        'else',
-        'not',
-        'contentEncoding',
-        'contentMediaType'
     ]);
 
     const sanitized = {};
+
     for (const [key, value] of Object.entries(schema)) {
-        // Skip unsupported fields
+        // Convert "const" to "enum" for compatibility
-        if (UNSUPPORTED_FIELDS.has(key)) {
+        if (key === 'const') {
+            sanitized.enum = [value];
+            continue;
+        }
+
+        // Skip fields not in allowlist
+        if (!ALLOWED_FIELDS.has(key)) {
             continue;
         }
 
@@ -289,23 +545,34 @@ function sanitizeSchema(schema) {
                 sanitized.properties[propKey] = sanitizeSchema(propValue);
             }
         } else if (key === 'items' && value && typeof value === 'object') {
-            // Handle items - could be object or array
             if (Array.isArray(value)) {
                 sanitized.items = value.map(item => sanitizeSchema(item));
-            } else if (value.anyOf || value.allOf || value.oneOf) {
-                // Replace complex items with permissive type
-                sanitized.items = {};
             } else {
                 sanitized.items = sanitizeSchema(value);
             }
         } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            // Recursively sanitize nested objects that aren't properties/items
             sanitized[key] = sanitizeSchema(value);
         } else {
             sanitized[key] = value;
         }
     }
 
+    // Ensure we have at least a type
+    if (!sanitized.type) {
+        sanitized.type = 'object';
+    }
+
+    // If object type with no properties, add placeholder
+    if (sanitized.type === 'object' && (!sanitized.properties || Object.keys(sanitized.properties).length === 0)) {
+        sanitized.properties = {
+            reason: {
+                type: 'string',
+                description: 'Reason for calling this tool'
+            }
+        };
+        sanitized.required = ['reason'];
+    }
+
     return sanitized;
 }
 
@@ -314,13 +581,13 @@ function sanitizeSchema(schema) {
  *
  * @param {Object} googleResponse - Google format response (the inner response object)
  * @param {string} model - The model name used
- * @param {boolean} isStreaming - Whether this is a streaming response
  * @returns {Object} Anthropic format response
  */
-export function convertGoogleToAnthropic(googleResponse, model, isStreaming = false) {
+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 || {};
@@ -328,18 +595,26 @@ export function convertGoogleToAnthropic(googleResponse, model, isStreaming = fa
 
     // Convert parts to Anthropic content blocks
     const anthropicContent = [];
-    let toolCallCounter = 0;
+    let hasToolCalls = false;
 
     for (const part of parts) {
         if (part.text !== undefined) {
-            // Skip thinking blocks (thought: true) - the model handles thinking internally
+            // Handle thinking blocks
             if (part.thought === true) {
-                continue;
+                const signature = part.thoughtSignature || '';
-            }
+
+                // 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
@@ -349,7 +624,7 @@ export function convertGoogleToAnthropic(googleResponse, model, isStreaming = fa
                 name: part.functionCall.name,
                 input: part.functionCall.args || {}
             });
-            toolCallCounter++;
+            hasToolCalls = true;
         }
     }
 
@@ -360,7 +635,7 @@ export function convertGoogleToAnthropic(googleResponse, model, isStreaming = fa
         stopReason = 'end_turn';
     } else if (finishReason === 'MAX_TOKENS') {
         stopReason = 'max_tokens';
-    } else if (finishReason === 'TOOL_USE' || toolCallCounter > 0) {
+    } else if (finishReason === 'TOOL_USE' || hasToolCalls) {
         stopReason = 'tool_use';
     }
 
@@ -382,108 +657,8 @@ export function convertGoogleToAnthropic(googleResponse, model, isStreaming = fa
     };
 }
 
-/**
- * Parse SSE data and extract the response object
- */
-export function parseSSEResponse(data) {
-    if (!data || !data.startsWith('data:')) {
-        return null;
-    }
-
-    const jsonStr = data.slice(5).trim();
-    if (!jsonStr) {
-        return null;
-    }
-
-    try {
-        return JSON.parse(jsonStr);
-    } catch (e) {
-        console.error('[FormatConverter] Failed to parse SSE data:', e.message);
-        return null;
-    }
-}
-
-/**
- * Convert a streaming chunk to Anthropic SSE format
- */
-export function convertStreamingChunk(googleChunk, model, index, isFirst, isLast) {
-    const events = [];
-    const response = googleChunk.response || googleChunk;
-    const candidates = response.candidates || [];
-    const firstCandidate = candidates[0] || {};
-    const content = firstCandidate.content || {};
-    const parts = content.parts || [];
-
-    if (isFirst) {
-        // message_start event
-        events.push({
-            type: 'message_start',
-            message: {
-                id: `msg_${crypto.randomBytes(16).toString('hex')}`,
-                type: 'message',
-                role: 'assistant',
-                content: [],
-                model: model,
-                stop_reason: null,
-                stop_sequence: null,
-                usage: { input_tokens: 0, output_tokens: 0 }
-            }
-        });
-
-        // content_block_start event
-        events.push({
-            type: 'content_block_start',
-            index: 0,
-            content_block: { type: 'text', text: '' }
-        });
-    }
-
-    // Extract text from parts and emit as delta
-    for (const part of parts) {
-        if (part.text !== undefined) {
-            events.push({
-                type: 'content_block_delta',
-                index: 0,
-                delta: { type: 'text_delta', text: part.text }
-            });
-        }
-    }
-
-    if (isLast) {
-        // content_block_stop event
-        events.push({
-            type: 'content_block_stop',
-            index: 0
-        });
-
-        // Determine stop reason
-        const finishReason = firstCandidate.finishReason;
-        let stopReason = 'end_turn';
-        if (finishReason === 'MAX_TOKENS') {
-            stopReason = 'max_tokens';
-        }
-
-        // Extract usage
-        const usageMetadata = response.usageMetadata || {};
-
-        // message_delta event
-        events.push({
-            type: 'message_delta',
-            delta: { stop_reason: stopReason, stop_sequence: null },
-            usage: { output_tokens: usageMetadata.candidatesTokenCount || 0 }
-        });
-
-        // message_stop event
-        events.push({ type: 'message_stop' });
-    }
-
-    return events;
-}
-
 export default {
     mapModelName,
     convertAnthropicToGoogle,
-    convertGoogleToAnthropic,
+    convertGoogleToAnthropic
-    parseSSEResponse,
-    convertStreamingChunk
 };

src/index.js

@@ -20,6 +20,7 @@ app.listen(PORT, () => {
 ║    POST /v1/messages  - Anthropic Messages API               ║
 ║    GET  /v1/models    - List available models                ║
 ║    GET  /health       - Health check                         ║
+║    GET  /accounts     - Account pool status                  ║
 ║    POST /refresh-token - Force token refresh                 ║
 ║                                                              ║
 ║  Usage with Claude Code:                                     ║
@@ -27,7 +28,10 @@ app.listen(PORT, () => {
 ║    export ANTHROPIC_API_KEY=dummy                            ║
 ║    claude                                                    ║
 ║                                                              ║
-║  Prerequisites:                                              ║
+║  Add Google accounts:                                        ║
+║    npm run accounts                                          ║
+║                                                              ║
+║  Prerequisites (if no accounts configured):                  ║
 ║    - Antigravity must be running                             ║
 ║    - Have a chat panel open in Antigravity                   ║
 ║                                                              ║

src/oauth.js

@@ -0,0 +1,338 @@
+/**
+ * Google OAuth with PKCE for Antigravity
+ *
+ * Implements the same OAuth flow as opencode-antigravity-auth
+ * to obtain refresh tokens for multiple Google accounts.
+ * Uses a local callback server to automatically capture the auth code.
+ */
+
+import crypto from 'crypto';
+import http from 'http';
+import { ANTIGRAVITY_ENDPOINT_FALLBACKS, ANTIGRAVITY_HEADERS } from './constants.js';
+
+// Google OAuth configuration (from opencode-antigravity-auth)
+const GOOGLE_CLIENT_ID = '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
+const GOOGLE_CLIENT_SECRET = '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';
+const GOOGLE_AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
+const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const GOOGLE_USERINFO_URL = 'https://www.googleapis.com/oauth2/v1/userinfo';
+
+// Local callback server configuration
+const CALLBACK_PORT = 51121;
+const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}/oauth-callback`;
+
+// Scopes needed for Cloud Code access (matching Antigravity)
+const 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'
+].join(' ');
+
+/**
+ * Generate PKCE code verifier and challenge
+ */
+function generatePKCE() {
+    const verifier = crypto.randomBytes(32).toString('base64url');
+    const challenge = crypto
+        .createHash('sha256')
+        .update(verifier)
+        .digest('base64url');
+    return { verifier, challenge };
+}
+
+/**
+ * Generate authorization URL for Google OAuth
+ * Returns the URL and the PKCE verifier (needed for token exchange)
+ */
+export function getAuthorizationUrl() {
+    const { verifier, challenge } = generatePKCE();
+    const state = crypto.randomBytes(16).toString('hex');
+
+    const params = new URLSearchParams({
+        client_id: GOOGLE_CLIENT_ID,
+        redirect_uri: REDIRECT_URI,
+        response_type: 'code',
+        scope: SCOPES,
+        access_type: 'offline',
+        prompt: 'consent',
+        code_challenge: challenge,
+        code_challenge_method: 'S256',
+        state: state
+    });
+
+    return {
+        url: `${GOOGLE_AUTH_URL}?${params.toString()}`,
+        verifier,
+        state
+    };
+}
+
+/**
+ * Start a local server to receive the OAuth callback
+ * Returns a promise that resolves with the authorization code
+ */
+export function startCallbackServer(expectedState, timeoutMs = 120000) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);
+
+            if (url.pathname !== '/oauth-callback') {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+
+            const code = url.searchParams.get('code');
+            const state = url.searchParams.get('state');
+            const error = url.searchParams.get('error');
+
+            if (error) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end(`
+                    <html>
+                    <head><title>Authentication Failed</title></head>
+                    <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                        <h1 style="color: #dc3545;">❌ Authentication Failed</h1>
+                        <p>Error: ${error}</p>
+                        <p>You can close this window.</p>
+                    </body>
+                    </html>
+                `);
+                server.close();
+                reject(new Error(`OAuth error: ${error}`));
+                return;
+            }
+
+            if (state !== expectedState) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end(`
+                    <html>
+                    <head><title>Authentication Failed</title></head>
+                    <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                        <h1 style="color: #dc3545;">❌ Authentication Failed</h1>
+                        <p>State mismatch - possible CSRF attack.</p>
+                        <p>You can close this window.</p>
+                    </body>
+                    </html>
+                `);
+                server.close();
+                reject(new Error('State mismatch'));
+                return;
+            }
+
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end(`
+                    <html>
+                    <head><title>Authentication Failed</title></head>
+                    <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                        <h1 style="color: #dc3545;">❌ Authentication Failed</h1>
+                        <p>No authorization code received.</p>
+                        <p>You can close this window.</p>
+                    </body>
+                    </html>
+                `);
+                server.close();
+                reject(new Error('No authorization code'));
+                return;
+            }
+
+            // Success!
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`
+                <html>
+                <head><title>Authentication Successful</title></head>
+                <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                    <h1 style="color: #28a745;">✅ Authentication Successful!</h1>
+                    <p>You can close this window and return to the terminal.</p>
+                    <script>setTimeout(() => window.close(), 2000);</script>
+                </body>
+                </html>
+            `);
+
+            server.close();
+            resolve(code);
+        });
+
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${CALLBACK_PORT} is already in use. Close any other OAuth flows and try again.`));
+            } else {
+                reject(err);
+            }
+        });
+
+        server.listen(CALLBACK_PORT, () => {
+            console.log(`[OAuth] Callback server listening on port ${CALLBACK_PORT}`);
+        });
+
+        // Timeout after specified duration
+        setTimeout(() => {
+            server.close();
+            reject(new Error('OAuth callback timeout - no response received'));
+        }, timeoutMs);
+    });
+}
+
+/**
+ * Exchange authorization code for tokens
+ */
+export async function exchangeCode(code, verifier) {
+    const response = await fetch(GOOGLE_TOKEN_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams({
+            client_id: GOOGLE_CLIENT_ID,
+            client_secret: GOOGLE_CLIENT_SECRET,
+            code: code,
+            code_verifier: verifier,
+            grant_type: 'authorization_code',
+            redirect_uri: REDIRECT_URI
+        })
+    });
+
+    if (!response.ok) {
+        const error = await response.text();
+        console.error('[OAuth] Token exchange failed:', response.status, error);
+        throw new Error(`Token exchange failed: ${error}`);
+    }
+
+    const tokens = await response.json();
+
+    if (!tokens.access_token) {
+        console.error('[OAuth] No access token in response:', tokens);
+        throw new Error('No access token received');
+    }
+
+    console.log('[OAuth] Token exchange successful, access_token length:', tokens.access_token?.length);
+
+    return {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresIn: tokens.expires_in
+    };
+}
+
+/**
+ * Refresh access token using refresh token
+ */
+export async function refreshAccessToken(refreshToken) {
+    const response = await fetch(GOOGLE_TOKEN_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams({
+            client_id: GOOGLE_CLIENT_ID,
+            client_secret: GOOGLE_CLIENT_SECRET,
+            refresh_token: refreshToken,
+            grant_type: 'refresh_token'
+        })
+    });
+
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Token refresh failed: ${error}`);
+    }
+
+    const tokens = await response.json();
+    return {
+        accessToken: tokens.access_token,
+        expiresIn: tokens.expires_in
+    };
+}
+
+/**
+ * Get user email from access token
+ */
+export async function getUserEmail(accessToken) {
+    const response = await fetch(GOOGLE_USERINFO_URL, {
+        headers: {
+            'Authorization': `Bearer ${accessToken}`
+        }
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        console.error('[OAuth] getUserEmail failed:', response.status, errorText);
+        throw new Error(`Failed to get user info: ${response.status}`);
+    }
+
+    const userInfo = await response.json();
+    return userInfo.email;
+}
+
+/**
+ * Discover project ID for the authenticated user
+ */
+export async function discoverProjectId(accessToken) {
+    for (const endpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
+        try {
+            const response = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`,
+                    'Content-Type': 'application/json',
+                    ...ANTIGRAVITY_HEADERS
+                },
+                body: JSON.stringify({
+                    metadata: {
+                        ideType: 'IDE_UNSPECIFIED',
+                        platform: 'PLATFORM_UNSPECIFIED',
+                        pluginType: 'GEMINI'
+                    }
+                })
+            });
+
+            if (!response.ok) continue;
+
+            const data = await response.json();
+
+            if (typeof data.cloudaicompanionProject === 'string') {
+                return data.cloudaicompanionProject;
+            }
+            if (data.cloudaicompanionProject?.id) {
+                return data.cloudaicompanionProject.id;
+            }
+        } catch (error) {
+            console.log(`[OAuth] Project discovery failed at ${endpoint}:`, error.message);
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Complete OAuth flow: exchange code and get all account info
+ */
+export async function completeOAuthFlow(code, verifier) {
+    // Exchange code for tokens
+    const tokens = await exchangeCode(code, verifier);
+
+    // Get user email
+    const email = await getUserEmail(tokens.accessToken);
+
+    // Discover project ID
+    const projectId = await discoverProjectId(tokens.accessToken);
+
+    return {
+        email,
+        refreshToken: tokens.refreshToken,
+        accessToken: tokens.accessToken,
+        projectId
+    };
+}
+
+export default {
+    getAuthorizationUrl,
+    startCallbackServer,
+    exchangeCode,
+    refreshAccessToken,
+    getUserEmail,
+    discoverProjectId,
+    completeOAuthFlow
+};

src/server.js

@@ -1,16 +1,43 @@
 /**
  * Express Server - Anthropic-compatible API
  * Proxies to Google Cloud Code via Antigravity
+ * Supports multi-account load balancing
  */
 
 import express from 'express';
 import cors from 'cors';
-import { sendMessage, sendMessageStream, listModels, clearProjectCache, getProject } from './cloudcode-client.js';
+import { sendMessage, sendMessageStream, listModels } from './cloudcode-client.js';
-import { getToken, forceRefresh } from './token-extractor.js';
+import { forceRefresh } from './token-extractor.js';
-import { AVAILABLE_MODELS, REQUEST_BODY_LIMIT } from './constants.js';
+import { REQUEST_BODY_LIMIT } from './constants.js';
+import { AccountManager } from './account-manager.js';
 
 const app = express();
 
+// Initialize account manager (will be fully initialized on first request or startup)
+const accountManager = new AccountManager();
+
+// Track initialization status
+let isInitialized = false;
+let initError = null;
+
+/**
+ * Ensure account manager is initialized
+ */
+async function ensureInitialized() {
+    if (isInitialized) return;
+
+    try {
+        await accountManager.initialize();
+        isInitialized = true;
+        const status = accountManager.getStatus();
+        console.log(`[Server] Account pool initialized: ${status.summary}`);
+    } catch (error) {
+        initError = error;
+        console.error('[Server] Failed to initialize account manager:', error.message);
+        throw error;
+    }
+}
+
 // Middleware
 app.use(cors());
 app.use(express.json({ limit: REQUEST_BODY_LIMIT }));
@@ -27,13 +54,20 @@ function parseError(error) {
         errorType = 'authentication_error';
         statusCode = 401;
         errorMessage = 'Authentication failed. Make sure Antigravity is running with a valid token.';
-    } else if (error.message.includes('429') || error.message.includes('RESOURCE_EXHAUSTED')) {
+    } else if (error.message.includes('429') || error.message.includes('RESOURCE_EXHAUSTED') || error.message.includes('QUOTA_EXHAUSTED')) {
-        errorType = 'rate_limit_error';
+        errorType = 'overloaded_error';  // Claude Code recognizes this type
-        statusCode = 429;
+        statusCode = 529;  // Use 529 for overloaded (Claude API convention)
-        const resetMatch = error.message.match(/quota will reset after (\d+h\d+m\d+s|\d+s)/i);
+
-        errorMessage = resetMatch
+        // Try to extract the quota reset time from the error
-            ? `Rate limited. Quota will reset after ${resetMatch[1]}.`
+        const resetMatch = error.message.match(/quota will reset after (\d+h\d+m\d+s|\d+m\d+s|\d+s)/i);
-            : 'Rate limited. Please wait and try again.';
+        const modelMatch = error.message.match(/"model":\s*"([^"]+)"/);
+        const model = modelMatch ? modelMatch[1] : 'the model';
+
+        if (resetMatch) {
+            errorMessage = `You have exhausted your capacity on ${model}. Quota will reset after ${resetMatch[1]}.`;
+        } else {
+            errorMessage = `You have exhausted your capacity on ${model}. Please wait for your quota to reset.`;
+        }
     } else if (error.message.includes('invalid_request_error') || error.message.includes('INVALID_ARGUMENT')) {
         errorType = 'invalid_request_error';
         statusCode = 400;
@@ -63,19 +97,15 @@ app.use((req, res, next) => {
  */
 app.get('/health', async (req, res) => {
     try {
-        const token = await getToken();
+        await ensureInitialized();
-        let project = null;
+        const status = accountManager.getStatus();
-        try {
-            project = await getProject(token);
-        } catch (e) {
-            // Project fetch might fail if token just refreshed
-        }
 
         res.json({
             status: 'ok',
-            hasToken: !!token,
+            accounts: status.summary,
-            tokenPrefix: token ? token.substring(0, 10) + '...' : null,
+            available: status.available,
-            project: project || 'unknown',
+            rateLimited: status.rateLimited,
+            invalid: status.invalid,
             timestamp: new Date().toISOString()
         });
     } catch (error) {
@@ -87,16 +117,55 @@ app.get('/health', async (req, res) => {
     }
 });
 
+/**
+ * Account pool status endpoint
+ */
+app.get('/accounts', async (req, res) => {
+    try {
+        await ensureInitialized();
+        const status = accountManager.getStatus();
+
+        res.json({
+            total: status.total,
+            available: status.available,
+            rateLimited: status.rateLimited,
+            invalid: status.invalid,
+            accounts: status.accounts.map(a => ({
+                email: a.email,
+                source: a.source,
+                isRateLimited: a.isRateLimited,
+                rateLimitResetTime: a.rateLimitResetTime
+                    ? new Date(a.rateLimitResetTime).toISOString()
+                    : null,
+                isInvalid: a.isInvalid,
+                invalidReason: a.invalidReason,
+                lastUsed: a.lastUsed
+                    ? new Date(a.lastUsed).toISOString()
+                    : null
+            }))
+        });
+    } catch (error) {
+        res.status(500).json({
+            status: 'error',
+            error: error.message
+        });
+    }
+});
+
 /**
  * Force token refresh endpoint
  */
 app.post('/refresh-token', async (req, res) => {
     try {
-        clearProjectCache();
+        await ensureInitialized();
+        // Clear all caches
+        accountManager.clearTokenCache();
+        accountManager.clearProjectCache();
+        // Force refresh default token
         const token = await forceRefresh();
         res.json({
             status: 'ok',
-            message: 'Token refreshed successfully',
+            message: 'Token caches cleared and refreshed',
             tokenPrefix: token.substring(0, 10) + '...'
         });
     } catch (error) {
@@ -119,6 +188,9 @@ app.get('/v1/models', (req, res) => {
  */
 app.post('/v1/messages', async (req, res) => {
     try {
+        // Ensure account manager is initialized
+        await ensureInitialized();
+
         const {
             model,
             messages,
@@ -161,6 +233,15 @@ app.post('/v1/messages', async (req, res) => {
 
         console.log(`[API] Request for model: ${request.model}, stream: ${!!stream}`);
 
+        // Debug: Log message structure to diagnose tool_use/tool_result ordering
+        console.log('[API] Message structure:');
+        messages.forEach((msg, i) => {
+            const contentTypes = Array.isArray(msg.content)
+                ? msg.content.map(c => c.type || 'text').join(', ')
+                : (typeof msg.content === 'string' ? 'text' : 'unknown');
+            console.log(`  [${i}] ${msg.role}: ${contentTypes}`);
+        });
+
         if (stream) {
             // Handle streaming response
             res.setHeader('Content-Type', 'text/event-stream');
@@ -168,10 +249,15 @@ app.post('/v1/messages', async (req, res) => {
             res.setHeader('Connection', 'keep-alive');
             res.setHeader('X-Accel-Buffering', 'no');
 
+            // Flush headers immediately to start the stream
+            res.flushHeaders();
+
             try {
-                // Use the streaming generator
+                // Use the streaming generator with account manager
-                for await (const event of sendMessageStream(request)) {
+                for await (const event of sendMessageStream(request, accountManager)) {
                     res.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+                    // Flush after each event for real-time streaming
+                    if (res.flush) res.flush();
                 }
                 res.end();
 
@@ -189,7 +275,7 @@ app.post('/v1/messages', async (req, res) => {
 
         } else {
             // Handle non-streaming response
-            const response = await sendMessage(request);
+            const response = await sendMessage(request, accountManager);
             res.json(response);
         }
 
@@ -202,7 +288,8 @@ app.post('/v1/messages', async (req, res) => {
         if (errorType === 'authentication_error') {
             console.log('[API] Token might be expired, attempting refresh...');
             try {
-                clearProjectCache();
+                accountManager.clearProjectCache();
+                accountManager.clearTokenCache();
                 await forceRefresh();
                 errorMessage = 'Token was expired and has been refreshed. Please retry your request.';
             } catch (refreshError) {
@@ -210,6 +297,17 @@ app.post('/v1/messages', async (req, res) => {
             }
         }
 
+        console.log(`[API] Returning error response: ${statusCode} ${errorType} - ${errorMessage}`);
+
+        // Check if headers have already been sent (for streaming that failed mid-way)
+        if (res.headersSent) {
+            console.log('[API] Headers already sent, writing error as SSE event');
+            res.write(`event: error\ndata: ${JSON.stringify({
+                type: 'error',
+                error: { type: errorType, message: errorMessage }
+            })}\n\n`);
+            res.end();
+        } else {
             res.status(statusCode).json({
                 type: 'error',
                 error: {
@@ -218,6 +316,7 @@ app.post('/v1/messages', async (req, res) => {
                 }
             });
         }
+    }
 });
 
 /**

src/token-extractor.js

@@ -9,7 +9,6 @@
 import { execSync } from 'child_process';
 import { homedir } from 'os';
 import { join } from 'path';
-import fetch from 'node-fetch';
 import { TOKEN_REFRESH_INTERVAL_MS, ANTIGRAVITY_AUTH_PORT } from './constants.js';
 
 // Cache for the extracted token
@@ -138,27 +137,6 @@ export async function getToken() {
     return cachedToken;
 }
 
-/**
- * Get the full configuration from Antigravity
- */
-export async function getConfig() {
-    if (needsRefresh()) {
-        await getToken(); // This will refresh the cache
-    }
-    return cachedConfig;
-}
-
-/**
- * Get available models from the cached config
- */
-export async function getAvailableModels() {
-    const config = await getConfig();
-    if (!config?.initialUserStatus?.cascadeModelConfigData?.clientModelConfigs) {
-        return [];
-    }
-    return config.initialUserStatus.cascadeModelConfigData.clientModelConfigs;
-}
-
 /**
  * Force refresh the token (useful if requests start failing)
  */
@@ -169,13 +147,7 @@ export async function forceRefresh() {
     return getToken();
 }
 
-// Alias for forceRefresh
-export const refreshToken = forceRefresh;
-
 export default {
     getToken,
-    getConfig,
+    forceRefresh
-    getAvailableModels,
-    forceRefresh,
-    refreshToken
 };

test_pdf_payload.json

@@ -1,18 +0,0 @@
-{
-    "model": "claude-sonnet-4-5",
-    "messages": [{
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "What does this document contain?"},
-        {
-          "type": "document",
-          "source": {
-            "type": "base64",
-            "media_type": "application/pdf",
-            "data": "JVBERi0xLgoxIDAgb2JqPDwvUGFnZXMgMiAwIFI+PmVuZG9iagoyIDAgb2JqPDwvS2lkc1szIDAgUl0vQ291bnQgMT4+ZW5kb2JqCjMgMCBvYmo8PC9QYXJlbnQgMiAwIFI+PmVuZG9iagp0cmFpbGVyPDwvUm9vdCAxIDAgUj4+Cg=="
-          }
-        }
-      ]
-    }],
-    "max_tokens": 100
-}

tests/run-all.cjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * Test Runner
+ *
+ * Runs all tests in sequence and reports results.
+ * Usage: node tests/run-all.cjs
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+
+const tests = [
+    { name: 'Thinking Signatures', file: 'test-thinking-signatures.cjs' },
+    { name: 'Multi-turn Tools (Non-Streaming)', file: 'test-multiturn-thinking-tools.cjs' },
+    { name: 'Multi-turn Tools (Streaming)', file: 'test-multiturn-thinking-tools-streaming.cjs' },
+    { name: 'Interleaved Thinking', file: 'test-interleaved-thinking.cjs' },
+    { name: 'Image Support', file: 'test-images.cjs' }
+];
+
+async function runTest(test) {
+    return new Promise((resolve) => {
+        const testPath = path.join(__dirname, test.file);
+        const child = spawn('node', [testPath], {
+            stdio: 'inherit'
+        });
+
+        child.on('close', (code) => {
+            resolve({ ...test, passed: code === 0 });
+        });
+
+        child.on('error', (err) => {
+            console.error(`Error running ${test.name}:`, err);
+            resolve({ ...test, passed: false });
+        });
+    });
+}
+
+async function main() {
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║              ANTIGRAVITY PROXY TEST SUITE                    ║');
+    console.log('╚══════════════════════════════════════════════════════════════╝');
+    console.log('');
+    console.log('Make sure the server is running on port 8080 before running tests.');
+    console.log('');
+
+    // Check if running specific test
+    const specificTest = process.argv[2];
+    let testsToRun = tests;
+
+    if (specificTest) {
+        testsToRun = tests.filter(t =>
+            t.file.includes(specificTest) || t.name.toLowerCase().includes(specificTest.toLowerCase())
+        );
+        if (testsToRun.length === 0) {
+            console.log(`No test found matching: ${specificTest}`);
+            console.log('\nAvailable tests:');
+            tests.forEach(t => console.log(`  - ${t.name} (${t.file})`));
+            process.exit(1);
+        }
+    }
+
+    const results = [];
+
+    for (const test of testsToRun) {
+        console.log('\n');
+        console.log('╔' + '═'.repeat(60) + '╗');
+        console.log('║ Running: ' + test.name.padEnd(50) + '║');
+        console.log('╚' + '═'.repeat(60) + '╝');
+        console.log('');
+
+        const result = await runTest(test);
+        results.push(result);
+
+        console.log('\n');
+    }
+
+    // Summary
+    console.log('╔══════════════════════════════════════════════════════════════╗');
+    console.log('║                      FINAL RESULTS                           ║');
+    console.log('╠══════════════════════════════════════════════════════════════╣');
+
+    let allPassed = true;
+    for (const result of results) {
+        const status = result.passed ? '✓ PASS' : '✗ FAIL';
+        const statusColor = result.passed ? '' : '';
+        console.log(`║ ${status.padEnd(8)} ${result.name.padEnd(50)} ║`);
+        if (!result.passed) allPassed = false;
+    }
+
+    console.log('╠══════════════════════════════════════════════════════════════╣');
+    const overallStatus = allPassed ? '✓ ALL TESTS PASSED' : '✗ SOME TESTS FAILED';
+    console.log(`║ ${overallStatus.padEnd(60)} ║`);
+    console.log('╚══════════════════════════════════════════════════════════════╝');
+
+    process.exit(allPassed ? 0 : 1);
+}
+
+main().catch(err => {
+    console.error('Test runner failed:', err);
+    process.exit(1);
+});

tests/test-images.cjs

@@ -0,0 +1,240 @@
+/**
+ * Image Support Test
+ *
+ * Tests that images can be sent to the API with thinking models.
+ * Simulates Claude Code sending screenshots or images for analysis.
+ */
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const BASE_URL = 'localhost';
+const PORT = 8080;
+
+// Load test image from disk
+const TEST_IMAGE_PATH = path.join(__dirname, 'utils', 'test_image.jpeg');
+const TEST_IMAGE_BASE64 = fs.readFileSync(TEST_IMAGE_PATH).toString('base64');
+
+function streamRequest(body) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const req = http.request({
+            host: BASE_URL,
+            port: PORT,
+            path: '/v1/messages',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': 'test',
+                'anthropic-version': '2023-06-01',
+                'anthropic-beta': 'interleaved-thinking-2025-05-14',
+                'Content-Length': Buffer.byteLength(data)
+            }
+        }, res => {
+            const events = [];
+            let fullData = '';
+
+            res.on('data', chunk => {
+                fullData += chunk.toString();
+            });
+
+            res.on('end', () => {
+                const parts = fullData.split('\n\n').filter(e => e.trim());
+                for (const part of parts) {
+                    const lines = part.split('\n');
+                    const eventLine = lines.find(l => l.startsWith('event:'));
+                    const dataLine = lines.find(l => l.startsWith('data:'));
+                    if (eventLine && dataLine) {
+                        try {
+                            const eventType = eventLine.replace('event:', '').trim();
+                            const eventData = JSON.parse(dataLine.replace('data:', '').trim());
+                            events.push({ type: eventType, data: eventData });
+                        } catch (e) { }
+                    }
+                }
+
+                const content = [];
+                let currentBlock = null;
+
+                for (const event of events) {
+                    if (event.type === 'content_block_start') {
+                        currentBlock = { ...event.data.content_block };
+                        if (currentBlock.type === 'thinking') {
+                            currentBlock.thinking = '';
+                            currentBlock.signature = '';
+                        }
+                        if (currentBlock.type === 'text') currentBlock.text = '';
+                    } else if (event.type === 'content_block_delta') {
+                        const delta = event.data.delta;
+                        if (delta.type === 'thinking_delta' && currentBlock) {
+                            currentBlock.thinking += delta.thinking || '';
+                        }
+                        if (delta.type === 'signature_delta' && currentBlock) {
+                            currentBlock.signature += delta.signature || '';
+                        }
+                        if (delta.type === 'text_delta' && currentBlock) {
+                            currentBlock.text += delta.text || '';
+                        }
+                    } else if (event.type === 'content_block_stop') {
+                        if (currentBlock) content.push(currentBlock);
+                        currentBlock = null;
+                    }
+                }
+
+                const errorEvent = events.find(e => e.type === 'error');
+                if (errorEvent) {
+                    resolve({ content, events, error: errorEvent.data.error, statusCode: res.statusCode });
+                } else {
+                    resolve({ content, events, statusCode: res.statusCode });
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+
+async function runTests() {
+    console.log('='.repeat(60));
+    console.log('IMAGE SUPPORT TEST');
+    console.log('Tests image processing with thinking models');
+    console.log('='.repeat(60));
+    console.log('');
+
+    let allPassed = true;
+    const results = [];
+
+    // ===== TEST 1: Single image with question =====
+    console.log('TEST 1: Single image with question');
+    console.log('-'.repeat(40));
+
+    const result1 = await streamRequest({
+        model: 'claude-sonnet-4-5-thinking',
+        max_tokens: 2048,
+        stream: true,
+        thinking: { type: 'enabled', budget_tokens: 8000 },
+        messages: [{
+            role: 'user',
+            content: [
+                {
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: 'image/jpeg',
+                        data: TEST_IMAGE_BASE64
+                    }
+                },
+                {
+                    type: 'text',
+                    text: 'What do you see in this image? Describe it briefly.'
+                }
+            ]
+        }]
+    });
+
+    if (result1.error) {
+        console.log(`  ERROR: ${result1.error.message}`);
+        allPassed = false;
+        results.push({ name: 'Single image processing', passed: false });
+    } else {
+        const thinking = result1.content.filter(b => b.type === 'thinking');
+        const text = result1.content.filter(b => b.type === 'text');
+
+        console.log(`  Thinking: ${thinking.length > 0 ? 'YES' : 'NO'}`);
+        console.log(`  Text response: ${text.length > 0 ? 'YES' : 'NO'}`);
+
+        if (thinking.length > 0) {
+            console.log(`  Thinking: "${thinking[0].thinking?.substring(0, 60)}..."`);
+        }
+        if (text.length > 0) {
+            console.log(`  Response: "${text[0].text?.substring(0, 100)}..."`);
+        }
+
+        const passed = thinking.length > 0 && text.length > 0;
+        results.push({ name: 'Single image processing', passed });
+        if (!passed) allPassed = false;
+    }
+
+    // ===== TEST 2: Image + text in multi-turn =====
+    console.log('\nTEST 2: Image in multi-turn conversation');
+    console.log('-'.repeat(40));
+
+    const result2 = await streamRequest({
+        model: 'claude-sonnet-4-5-thinking',
+        max_tokens: 2048,
+        stream: true,
+        thinking: { type: 'enabled', budget_tokens: 8000 },
+        messages: [
+            {
+                role: 'user',
+                content: 'I will show you an image.'
+            },
+            {
+                role: 'assistant',
+                content: [{
+                    type: 'text',
+                    text: 'Sure, please share the image and I\'ll help analyze it.'
+                }]
+            },
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: 'image/jpeg',
+                            data: TEST_IMAGE_BASE64
+                        }
+                    },
+                    {
+                        type: 'text',
+                        text: 'Here is the image. What do you see?'
+                    }
+                ]
+            }
+        ]
+    });
+
+    if (result2.error) {
+        console.log(`  ERROR: ${result2.error.message}`);
+        allPassed = false;
+        results.push({ name: 'Image in multi-turn', passed: false });
+    } else {
+        const thinking = result2.content.filter(b => b.type === 'thinking');
+        const text = result2.content.filter(b => b.type === 'text');
+
+        console.log(`  Thinking: ${thinking.length > 0 ? 'YES' : 'NO'}`);
+        console.log(`  Text response: ${text.length > 0 ? 'YES' : 'NO'}`);
+
+        if (text.length > 0) {
+            console.log(`  Response: "${text[0].text?.substring(0, 80)}..."`);
+        }
+
+        const passed = text.length > 0;
+        results.push({ name: 'Image in multi-turn', passed });
+        if (!passed) allPassed = false;
+    }
+
+    // ===== Summary =====
+    console.log('\n' + '='.repeat(60));
+    console.log('SUMMARY');
+    console.log('='.repeat(60));
+
+    for (const result of results) {
+        const status = result.passed ? 'PASS' : 'FAIL';
+        console.log(`  [${status}] ${result.name}`);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`OVERALL: ${allPassed ? 'ALL TESTS PASSED' : 'SOME TESTS FAILED'}`);
+    console.log('='.repeat(60));
+
+    process.exit(allPassed ? 0 : 1);
+}
+
+runTests().catch(err => {
+    console.error('Test failed with error:', err);
+    process.exit(1);
+});

tests/test-interleaved-thinking.cjs

@@ -0,0 +1,285 @@
+/**
+ * Interleaved Thinking Test
+ *
+ * Tests that interleaved thinking works correctly:
+ * - Multiple thinking blocks can appear in a single response
+ * - Thinking blocks between tool calls
+ * - Thinking after tool results
+ *
+ * This simulates complex Claude Code scenarios where the model
+ * thinks multiple times during a single turn.
+ */
+const http = require('http');
+
+const BASE_URL = 'localhost';
+const PORT = 8080;
+
+function streamRequest(body) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const req = http.request({
+            host: BASE_URL,
+            port: PORT,
+            path: '/v1/messages',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': 'test',
+                'anthropic-version': '2023-06-01',
+                'anthropic-beta': 'interleaved-thinking-2025-05-14',
+                'Content-Length': Buffer.byteLength(data)
+            }
+        }, res => {
+            const events = [];
+            let fullData = '';
+
+            res.on('data', chunk => {
+                fullData += chunk.toString();
+            });
+
+            res.on('end', () => {
+                const parts = fullData.split('\n\n').filter(e => e.trim());
+                for (const part of parts) {
+                    const lines = part.split('\n');
+                    const eventLine = lines.find(l => l.startsWith('event:'));
+                    const dataLine = lines.find(l => l.startsWith('data:'));
+                    if (eventLine && dataLine) {
+                        try {
+                            const eventType = eventLine.replace('event:', '').trim();
+                            const eventData = JSON.parse(dataLine.replace('data:', '').trim());
+                            events.push({ type: eventType, data: eventData });
+                        } catch (e) { }
+                    }
+                }
+
+                const content = [];
+                let currentBlock = null;
+
+                for (const event of events) {
+                    if (event.type === 'content_block_start') {
+                        currentBlock = { ...event.data.content_block };
+                        if (currentBlock.type === 'thinking') {
+                            currentBlock.thinking = '';
+                            currentBlock.signature = '';
+                        }
+                        if (currentBlock.type === 'text') currentBlock.text = '';
+                    } else if (event.type === 'content_block_delta') {
+                        const delta = event.data.delta;
+                        if (delta.type === 'thinking_delta' && currentBlock) {
+                            currentBlock.thinking += delta.thinking || '';
+                        }
+                        if (delta.type === 'signature_delta' && currentBlock) {
+                            currentBlock.signature += delta.signature || '';
+                        }
+                        if (delta.type === 'text_delta' && currentBlock) {
+                            currentBlock.text += delta.text || '';
+                        }
+                        if (delta.type === 'input_json_delta' && currentBlock) {
+                            currentBlock.partial_json = (currentBlock.partial_json || '') + delta.partial_json;
+                        }
+                    } else if (event.type === 'content_block_stop') {
+                        if (currentBlock?.type === 'tool_use' && currentBlock.partial_json) {
+                            try { currentBlock.input = JSON.parse(currentBlock.partial_json); } catch (e) { }
+                            delete currentBlock.partial_json;
+                        }
+                        if (currentBlock) content.push(currentBlock);
+                        currentBlock = null;
+                    }
+                }
+
+                const errorEvent = events.find(e => e.type === 'error');
+                if (errorEvent) {
+                    resolve({ content, events, error: errorEvent.data.error, statusCode: res.statusCode });
+                } else {
+                    resolve({ content, events, statusCode: res.statusCode });
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+
+// Multiple tools to encourage interleaved thinking
+const tools = [{
+    name: 'read_file',
+    description: 'Read a file',
+    input_schema: {
+        type: 'object',
+        properties: { path: { type: 'string' } },
+        required: ['path']
+    }
+}, {
+    name: 'write_file',
+    description: 'Write to a file',
+    input_schema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string' },
+            content: { type: 'string' }
+        },
+        required: ['path', 'content']
+    }
+}, {
+    name: 'run_tests',
+    description: 'Run test suite',
+    input_schema: {
+        type: 'object',
+        properties: { pattern: { type: 'string' } },
+        required: ['pattern']
+    }
+}];
+
+async function runTests() {
+    console.log('='.repeat(60));
+    console.log('INTERLEAVED THINKING TEST');
+    console.log('Tests complex multi-step reasoning with tools');
+    console.log('='.repeat(60));
+    console.log('');
+
+    let allPassed = true;
+    const results = [];
+
+    // ===== TEST 1: Complex task requiring multiple steps =====
+    console.log('TEST 1: Complex task - read, modify, write, test');
+    console.log('-'.repeat(40));
+
+    const result = await streamRequest({
+        model: 'claude-opus-4-5-thinking',
+        max_tokens: 8192,
+        stream: true,
+        tools,
+        thinking: { type: 'enabled', budget_tokens: 16000 },
+        messages: [{
+            role: 'user',
+            content: `I need you to:
+1. Read the file src/config.js
+2. Add a new config option "debug: true"
+3. Write the updated file
+4. Run the tests to make sure nothing broke
+
+Please do this step by step, reading each file before modifying.`
+        }]
+    });
+
+    if (result.error) {
+        console.log(`  ERROR: ${result.error.message}`);
+        allPassed = false;
+        results.push({ name: 'Complex multi-step task', passed: false });
+    } else {
+        const thinking = result.content.filter(b => b.type === 'thinking');
+        const toolUse = result.content.filter(b => b.type === 'tool_use');
+        const text = result.content.filter(b => b.type === 'text');
+
+        console.log(`  Thinking blocks: ${thinking.length}`);
+        console.log(`  Tool use blocks: ${toolUse.length}`);
+        console.log(`  Text blocks: ${text.length}`);
+
+        // Check signatures
+        const signedThinking = thinking.filter(t => t.signature && t.signature.length >= 50);
+        console.log(`  Signed thinking blocks: ${signedThinking.length}`);
+
+        // Analyze block order
+        const blockOrder = result.content.map(b => b.type).join(' -> ');
+        console.log(`  Block order: ${blockOrder}`);
+
+        // Show thinking previews
+        thinking.forEach((t, i) => {
+            console.log(`  Thinking ${i + 1}: "${(t.thinking || '').substring(0, 50)}..."`);
+        });
+
+        // Show tool calls
+        toolUse.forEach((t, i) => {
+            console.log(`  Tool ${i + 1}: ${t.name}(${JSON.stringify(t.input).substring(0, 50)}...)`);
+        });
+
+        // Expect at least one thinking block (ideally multiple for complex task)
+        const passed = thinking.length >= 1 && signedThinking.length >= 1 && toolUse.length >= 1;
+        results.push({ name: 'Thinking + Tools in complex task', passed });
+        if (!passed) allPassed = false;
+    }
+
+    // ===== TEST 2: Multiple tool calls in sequence =====
+    console.log('\nTEST 2: Tool result followed by more thinking');
+    console.log('-'.repeat(40));
+
+    // Start with previous result and add tool result
+    if (result.content && result.content.some(b => b.type === 'tool_use')) {
+        const toolUseBlock = result.content.find(b => b.type === 'tool_use');
+
+        const result2 = await streamRequest({
+            model: 'claude-opus-4-5-thinking',
+            max_tokens: 8192,
+            stream: true,
+            tools,
+            thinking: { type: 'enabled', budget_tokens: 16000 },
+            messages: [
+                {
+                    role: 'user',
+                    content: `Read src/config.js and tell me if debug mode is enabled.`
+                },
+                { role: 'assistant', content: result.content },
+                {
+                    role: 'user',
+                    content: [{
+                        type: 'tool_result',
+                        tool_use_id: toolUseBlock.id,
+                        content: `module.exports = {
+    port: 3000,
+    host: 'localhost',
+    debug: false
+};`
+                    }]
+                }
+            ]
+        });
+
+        if (result2.error) {
+            console.log(`  ERROR: ${result2.error.message}`);
+            allPassed = false;
+            results.push({ name: 'Thinking after tool result', passed: false });
+        } else {
+            const thinking2 = result2.content.filter(b => b.type === 'thinking');
+            const text2 = result2.content.filter(b => b.type === 'text');
+            const toolUse2 = result2.content.filter(b => b.type === 'tool_use');
+
+            console.log(`  Thinking blocks: ${thinking2.length}`);
+            console.log(`  Text blocks: ${text2.length}`);
+            console.log(`  Tool use blocks: ${toolUse2.length}`);
+
+            if (text2.length > 0) {
+                console.log(`  Response: "${text2[0].text?.substring(0, 80)}..."`);
+            }
+
+            // Should have thinking after receiving tool result
+            const passed = thinking2.length >= 1 && (text2.length > 0 || toolUse2.length > 0);
+            results.push({ name: 'Thinking after tool result', passed });
+            if (!passed) allPassed = false;
+        }
+    } else {
+        console.log('  SKIPPED - No tool use in previous test');
+        results.push({ name: 'Thinking after tool result', passed: false, skipped: true });
+    }
+
+    // ===== Summary =====
+    console.log('\n' + '='.repeat(60));
+    console.log('SUMMARY');
+    console.log('='.repeat(60));
+
+    for (const result of results) {
+        const status = result.skipped ? 'SKIP' : (result.passed ? 'PASS' : 'FAIL');
+        console.log(`  [${status}] ${result.name}`);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`OVERALL: ${allPassed ? 'ALL TESTS PASSED' : 'SOME TESTS FAILED'}`);
+    console.log('='.repeat(60));
+
+    process.exit(allPassed ? 0 : 1);
+}
+
+runTests().catch(err => {
+    console.error('Test failed with error:', err);
+    process.exit(1);
+});

tests/test-multiturn-thinking-tools-streaming.cjs

@@ -0,0 +1,301 @@
+/**
+ * Multi-Turn Tool Call Test (Streaming)
+ *
+ * Simulates Claude Code's streaming multi-turn conversation pattern.
+ * Same flow as non-streaming but verifies:
+ * - SSE events are properly formatted
+ * - signature_delta events are present
+ * - Thinking blocks accumulate correctly across deltas
+ */
+const http = require('http');
+
+const BASE_URL = 'localhost';
+const PORT = 8080;
+
+function streamRequest(body) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const req = http.request({
+            host: BASE_URL,
+            port: PORT,
+            path: '/v1/messages',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': 'test',
+                'anthropic-version': '2023-06-01',
+                'anthropic-beta': 'interleaved-thinking-2025-05-14',
+                'Content-Length': Buffer.byteLength(data)
+            }
+        }, res => {
+            const events = [];
+            let fullData = '';
+
+            res.on('data', chunk => {
+                fullData += chunk.toString();
+            });
+
+            res.on('end', () => {
+                // Parse SSE events
+                const parts = fullData.split('\n\n').filter(e => e.trim());
+                for (const part of parts) {
+                    const lines = part.split('\n');
+                    const eventLine = lines.find(l => l.startsWith('event:'));
+                    const dataLine = lines.find(l => l.startsWith('data:'));
+                    if (eventLine && dataLine) {
+                        try {
+                            const eventType = eventLine.replace('event:', '').trim();
+                            const eventData = JSON.parse(dataLine.replace('data:', '').trim());
+                            events.push({ type: eventType, data: eventData });
+                        } catch (e) { }
+                    }
+                }
+
+                // Build content from events
+                const content = [];
+                let currentBlock = null;
+
+                for (const event of events) {
+                    if (event.type === 'content_block_start') {
+                        currentBlock = { ...event.data.content_block };
+                        if (currentBlock.type === 'thinking') {
+                            currentBlock.thinking = '';
+                            currentBlock.signature = '';
+                        }
+                        if (currentBlock.type === 'text') currentBlock.text = '';
+                    } else if (event.type === 'content_block_delta') {
+                        const delta = event.data.delta;
+                        if (delta.type === 'thinking_delta' && currentBlock) {
+                            currentBlock.thinking += delta.thinking || '';
+                        }
+                        if (delta.type === 'signature_delta' && currentBlock) {
+                            currentBlock.signature += delta.signature || '';
+                        }
+                        if (delta.type === 'text_delta' && currentBlock) {
+                            currentBlock.text += delta.text || '';
+                        }
+                        if (delta.type === 'input_json_delta' && currentBlock) {
+                            currentBlock.partial_json = (currentBlock.partial_json || '') + delta.partial_json;
+                        }
+                    } else if (event.type === 'content_block_stop') {
+                        if (currentBlock?.type === 'tool_use' && currentBlock.partial_json) {
+                            try { currentBlock.input = JSON.parse(currentBlock.partial_json); } catch (e) { }
+                            delete currentBlock.partial_json;
+                        }
+                        if (currentBlock) content.push(currentBlock);
+                        currentBlock = null;
+                    }
+                }
+
+                // Check for errors
+                const errorEvent = events.find(e => e.type === 'error');
+                if (errorEvent) {
+                    resolve({
+                        content,
+                        events,
+                        error: errorEvent.data.error,
+                        statusCode: res.statusCode,
+                        raw: fullData
+                    });
+                } else {
+                    resolve({ content, events, statusCode: res.statusCode, raw: fullData });
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+
+const tools = [{
+    name: 'execute_command',
+    description: 'Execute a shell command',
+    input_schema: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Command to execute' },
+            cwd: { type: 'string', description: 'Working directory' }
+        },
+        required: ['command']
+    }
+}];
+
+function analyzeContent(content) {
+    const thinking = content.filter(b => b.type === 'thinking');
+    const toolUse = content.filter(b => b.type === 'tool_use');
+    const text = content.filter(b => b.type === 'text');
+
+    return {
+        thinking,
+        toolUse,
+        text,
+        hasThinking: thinking.length > 0,
+        hasToolUse: toolUse.length > 0,
+        hasText: text.length > 0,
+        thinkingHasSignature: thinking.some(t => t.signature && t.signature.length >= 50)
+    };
+}
+
+function analyzeEvents(events) {
+    return {
+        messageStart: events.filter(e => e.type === 'message_start').length,
+        blockStart: events.filter(e => e.type === 'content_block_start').length,
+        blockDelta: events.filter(e => e.type === 'content_block_delta').length,
+        blockStop: events.filter(e => e.type === 'content_block_stop').length,
+        messageDelta: events.filter(e => e.type === 'message_delta').length,
+        messageStop: events.filter(e => e.type === 'message_stop').length,
+        thinkingDeltas: events.filter(e => e.data?.delta?.type === 'thinking_delta').length,
+        signatureDeltas: events.filter(e => e.data?.delta?.type === 'signature_delta').length,
+        textDeltas: events.filter(e => e.data?.delta?.type === 'text_delta').length,
+        inputJsonDeltas: events.filter(e => e.data?.delta?.type === 'input_json_delta').length
+    };
+}
+
+async function runTests() {
+    console.log('='.repeat(60));
+    console.log('MULTI-TURN TOOL CALL TEST (STREAMING)');
+    console.log('Simulates Claude Code streaming conversation');
+    console.log('='.repeat(60));
+    console.log('');
+
+    let messages = [];
+    let allPassed = true;
+    const results = [];
+
+    // ===== TURN 1: Initial request =====
+    console.log('TURN 1: User asks to run a command');
+    console.log('-'.repeat(40));
+
+    messages.push({
+        role: 'user',
+        content: 'Run "ls -la" in the current directory and tell me what files exist.'
+    });
+
+    const turn1 = await streamRequest({
+        model: 'claude-sonnet-4-5-thinking',
+        max_tokens: 4096,
+        stream: true,
+        tools,
+        thinking: { type: 'enabled', budget_tokens: 10000 },
+        messages
+    });
+
+    if (turn1.error) {
+        console.log(`  ERROR: ${turn1.error.message}`);
+        allPassed = false;
+        results.push({ name: 'Turn 1: Streaming request', passed: false });
+    } else {
+        const content = analyzeContent(turn1.content);
+        const events = analyzeEvents(turn1.events);
+
+        console.log('  Content:');
+        console.log(`    Thinking: ${content.hasThinking ? 'YES' : 'NO'} (${content.thinking.length} blocks)`);
+        console.log(`    Signature: ${content.thinkingHasSignature ? 'YES' : 'NO'}`);
+        console.log(`    Tool Use: ${content.hasToolUse ? 'YES' : 'NO'} (${content.toolUse.length} calls)`);
+
+        console.log('  Events:');
+        console.log(`    message_start: ${events.messageStart}`);
+        console.log(`    content_block_start/stop: ${events.blockStart}/${events.blockStop}`);
+        console.log(`    thinking_delta: ${events.thinkingDeltas}`);
+        console.log(`    signature_delta: ${events.signatureDeltas}`);
+        console.log(`    input_json_delta: ${events.inputJsonDeltas}`);
+
+        if (content.hasThinking && content.thinking[0].thinking) {
+            console.log(`  Thinking: "${content.thinking[0].thinking.substring(0, 60)}..."`);
+        }
+        if (content.hasToolUse) {
+            console.log(`  Tool: ${content.toolUse[0].name}(${JSON.stringify(content.toolUse[0].input)})`);
+        }
+
+        const passed = content.hasThinking && content.thinkingHasSignature &&
+                       events.signatureDeltas > 0 && content.hasToolUse;
+        results.push({ name: 'Turn 1: Thinking + Signature + Tool Use + Events', passed });
+        if (!passed) allPassed = false;
+
+        if (content.hasToolUse) {
+            messages.push({ role: 'assistant', content: turn1.content });
+        }
+    }
+
+    // ===== TURN 2: Provide tool result =====
+    if (messages.length >= 2) {
+        console.log('\nTURN 2: Provide command output, expect summary');
+        console.log('-'.repeat(40));
+
+        const lastAssistant = messages[messages.length - 1];
+        const toolUseBlock = lastAssistant.content.find(b => b.type === 'tool_use');
+
+        messages.push({
+            role: 'user',
+            content: [{
+                type: 'tool_result',
+                tool_use_id: toolUseBlock.id,
+                content: `total 32
+drwxr-xr-x  10 user  staff   320 Dec 19 10:00 .
+drwxr-xr-x   5 user  staff   160 Dec 19 09:00 ..
+-rw-r--r--   1 user  staff  1024 Dec 19 10:00 package.json
+-rw-r--r--   1 user  staff  2048 Dec 19 10:00 README.md
+drwxr-xr-x   8 user  staff   256 Dec 19 10:00 src
+drwxr-xr-x   4 user  staff   128 Dec 19 10:00 tests`
+            }]
+        });
+
+        const turn2 = await streamRequest({
+            model: 'claude-sonnet-4-5-thinking',
+            max_tokens: 4096,
+            stream: true,
+            tools,
+            thinking: { type: 'enabled', budget_tokens: 10000 },
+            messages
+        });
+
+        if (turn2.error) {
+            console.log(`  ERROR: ${turn2.error.message}`);
+            allPassed = false;
+            results.push({ name: 'Turn 2: After tool result', passed: false });
+        } else {
+            const content = analyzeContent(turn2.content);
+            const events = analyzeEvents(turn2.events);
+
+            console.log('  Content:');
+            console.log(`    Thinking: ${content.hasThinking ? 'YES' : 'NO'} (${content.thinking.length} blocks)`);
+            console.log(`    Signature: ${content.thinkingHasSignature ? 'YES' : 'NO'}`);
+            console.log(`    Text: ${content.hasText ? 'YES' : 'NO'}`);
+
+            console.log('  Events:');
+            console.log(`    thinking_delta: ${events.thinkingDeltas}`);
+            console.log(`    signature_delta: ${events.signatureDeltas}`);
+            console.log(`    text_delta: ${events.textDeltas}`);
+
+            if (content.hasText && content.text[0].text) {
+                console.log(`  Response: "${content.text[0].text.substring(0, 100)}..."`);
+            }
+
+            const passed = content.hasThinking && content.hasText && events.textDeltas > 0;
+            results.push({ name: 'Turn 2: Thinking + Text response', passed });
+            if (!passed) allPassed = false;
+        }
+    }
+
+    // ===== Summary =====
+    console.log('\n' + '='.repeat(60));
+    console.log('SUMMARY');
+    console.log('='.repeat(60));
+
+    for (const result of results) {
+        const status = result.passed ? 'PASS' : 'FAIL';
+        console.log(`  [${status}] ${result.name}`);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`OVERALL: ${allPassed ? 'ALL TESTS PASSED' : 'SOME TESTS FAILED'}`);
+    console.log('='.repeat(60));
+
+    process.exit(allPassed ? 0 : 1);
+}
+
+runTests().catch(err => {
+    console.error('Test failed with error:', err);
+    process.exit(1);
+});

tests/test-multiturn-thinking-tools.cjs

@@ -0,0 +1,278 @@
+/**
+ * Multi-Turn Tool Call Test (Non-Streaming)
+ *
+ * Simulates Claude Code's actual multi-turn conversation pattern:
+ * 1. User asks question requiring tool
+ * 2. Assistant responds with thinking + tool_use
+ * 3. User provides tool_result
+ * 4. Assistant responds with thinking + final answer
+ *
+ * Key aspects tested:
+ * - Thinking blocks with signatures are preserved across turns
+ * - Tool use/result flow works correctly
+ * - Interleaved thinking with tools
+ */
+const http = require('http');
+
+const BASE_URL = 'localhost';
+const PORT = 8080;
+
+function makeRequest(body) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const req = http.request({
+            host: BASE_URL,
+            port: PORT,
+            path: '/v1/messages',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': 'test',
+                'anthropic-version': '2023-06-01',
+                'anthropic-beta': 'interleaved-thinking-2025-05-14',
+                'Content-Length': Buffer.byteLength(data)
+            }
+        }, res => {
+            let fullData = '';
+            res.on('data', chunk => fullData += chunk.toString());
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(fullData);
+                    resolve({ ...parsed, statusCode: res.statusCode });
+                } catch (e) {
+                    reject(new Error(`Parse error: ${e.message}\nRaw: ${fullData.substring(0, 500)}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+
+const tools = [{
+    name: 'search_files',
+    description: 'Search for files matching a pattern',
+    input_schema: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern to search' },
+            path: { type: 'string', description: 'Directory to search in' }
+        },
+        required: ['pattern']
+    }
+}, {
+    name: 'read_file',
+    description: 'Read contents of a file',
+    input_schema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to file' }
+        },
+        required: ['path']
+    }
+}];
+
+function analyzeContent(content) {
+    const thinking = content.filter(b => b.type === 'thinking');
+    const toolUse = content.filter(b => b.type === 'tool_use');
+    const text = content.filter(b => b.type === 'text');
+
+    return {
+        thinking,
+        toolUse,
+        text,
+        hasThinking: thinking.length > 0,
+        hasToolUse: toolUse.length > 0,
+        hasText: text.length > 0,
+        thinkingHasSignature: thinking.some(t => t.signature && t.signature.length >= 50)
+    };
+}
+
+async function runTests() {
+    console.log('='.repeat(60));
+    console.log('MULTI-TURN TOOL CALL TEST (NON-STREAMING)');
+    console.log('Simulates Claude Code conversation pattern');
+    console.log('='.repeat(60));
+    console.log('');
+
+    let messages = [];
+    let allPassed = true;
+    const results = [];
+
+    // ===== TURN 1: Initial request =====
+    console.log('TURN 1: User asks to find and read a config file');
+    console.log('-'.repeat(40));
+
+    messages.push({
+        role: 'user',
+        content: 'Find the package.json file and tell me what dependencies it has. Use search_files first.'
+    });
+
+    const turn1 = await makeRequest({
+        model: 'claude-sonnet-4-5-thinking',
+        max_tokens: 4096,
+        stream: false,
+        tools,
+        thinking: { type: 'enabled', budget_tokens: 10000 },
+        messages
+    });
+
+    if (turn1.statusCode !== 200 || turn1.error) {
+        console.log(`  ERROR: ${turn1.error?.message || `Status ${turn1.statusCode}`}`);
+        allPassed = false;
+        results.push({ name: 'Turn 1: Initial request', passed: false });
+    } else {
+        const analysis = analyzeContent(turn1.content || []);
+        console.log(`  Thinking: ${analysis.hasThinking ? 'YES' : 'NO'} (${analysis.thinking.length} blocks)`);
+        console.log(`  Signature: ${analysis.thinkingHasSignature ? 'YES' : 'NO'}`);
+        console.log(`  Tool Use: ${analysis.hasToolUse ? 'YES' : 'NO'} (${analysis.toolUse.length} calls)`);
+        console.log(`  Text: ${analysis.hasText ? 'YES' : 'NO'}`);
+
+        if (analysis.hasThinking && analysis.thinking[0].thinking) {
+            console.log(`  Thinking: "${analysis.thinking[0].thinking.substring(0, 60)}..."`);
+        }
+        if (analysis.hasToolUse) {
+            console.log(`  Tool: ${analysis.toolUse[0].name}(${JSON.stringify(analysis.toolUse[0].input)})`);
+        }
+
+        const passed = analysis.hasThinking && analysis.thinkingHasSignature && analysis.hasToolUse;
+        results.push({ name: 'Turn 1: Thinking + Signature + Tool Use', passed });
+        if (!passed) allPassed = false;
+
+        // Prepare for turn 2
+        if (analysis.hasToolUse) {
+            messages.push({ role: 'assistant', content: turn1.content });
+        }
+    }
+
+    // ===== TURN 2: Provide tool result =====
+    if (messages.length >= 2) {
+        console.log('\nTURN 2: Provide tool result, expect another tool call');
+        console.log('-'.repeat(40));
+
+        const lastAssistant = messages[messages.length - 1];
+        const toolUseBlock = lastAssistant.content.find(b => b.type === 'tool_use');
+
+        messages.push({
+            role: 'user',
+            content: [{
+                type: 'tool_result',
+                tool_use_id: toolUseBlock.id,
+                content: 'Found files:\n- /project/package.json\n- /project/packages/core/package.json'
+            }]
+        });
+
+        const turn2 = await makeRequest({
+            model: 'claude-sonnet-4-5-thinking',
+            max_tokens: 4096,
+            stream: false,
+            tools,
+            thinking: { type: 'enabled', budget_tokens: 10000 },
+            messages
+        });
+
+        if (turn2.statusCode !== 200 || turn2.error) {
+            console.log(`  ERROR: ${turn2.error?.message || `Status ${turn2.statusCode}`}`);
+            allPassed = false;
+            results.push({ name: 'Turn 2: After tool result', passed: false });
+        } else {
+            const analysis = analyzeContent(turn2.content || []);
+            console.log(`  Thinking: ${analysis.hasThinking ? 'YES' : 'NO'} (${analysis.thinking.length} blocks)`);
+            console.log(`  Signature: ${analysis.thinkingHasSignature ? 'YES' : 'NO'}`);
+            console.log(`  Tool Use: ${analysis.hasToolUse ? 'YES' : 'NO'} (${analysis.toolUse.length} calls)`);
+            console.log(`  Text: ${analysis.hasText ? 'YES' : 'NO'}`);
+
+            if (analysis.hasThinking && analysis.thinking[0].thinking) {
+                console.log(`  Thinking: "${analysis.thinking[0].thinking.substring(0, 60)}..."`);
+            }
+            if (analysis.hasToolUse) {
+                console.log(`  Tool: ${analysis.toolUse[0].name}(${JSON.stringify(analysis.toolUse[0].input)})`);
+            }
+
+            // Either tool use (to read file) or text response is acceptable
+            const passed = analysis.hasThinking && (analysis.hasToolUse || analysis.hasText);
+            results.push({ name: 'Turn 2: Thinking + (Tool or Text)', passed });
+            if (!passed) allPassed = false;
+
+            if (analysis.hasToolUse) {
+                messages.push({ role: 'assistant', content: turn2.content });
+            }
+        }
+    }
+
+    // ===== TURN 3: Final tool result and response =====
+    if (messages.length >= 4) {
+        const lastAssistant = messages[messages.length - 1];
+        const toolUseBlock = lastAssistant.content?.find(b => b.type === 'tool_use');
+
+        if (toolUseBlock) {
+            console.log('\nTURN 3: Provide file content, expect final response');
+            console.log('-'.repeat(40));
+
+            messages.push({
+                role: 'user',
+                content: [{
+                    type: 'tool_result',
+                    tool_use_id: toolUseBlock.id,
+                    content: JSON.stringify({
+                        name: 'my-project',
+                        dependencies: {
+                            express: '^4.18.2',
+                            cors: '^2.8.5'
+                        }
+                    }, null, 2)
+                }]
+            });
+
+            const turn3 = await makeRequest({
+                model: 'claude-sonnet-4-5-thinking',
+                max_tokens: 4096,
+                stream: false,
+                tools,
+                thinking: { type: 'enabled', budget_tokens: 10000 },
+                messages
+            });
+
+            if (turn3.statusCode !== 200 || turn3.error) {
+                console.log(`  ERROR: ${turn3.error?.message || `Status ${turn3.statusCode}`}`);
+                allPassed = false;
+                results.push({ name: 'Turn 3: Final response', passed: false });
+            } else {
+                const analysis = analyzeContent(turn3.content || []);
+                console.log(`  Thinking: ${analysis.hasThinking ? 'YES' : 'NO'} (${analysis.thinking.length} blocks)`);
+                console.log(`  Signature: ${analysis.thinkingHasSignature ? 'YES' : 'NO'}`);
+                console.log(`  Text: ${analysis.hasText ? 'YES' : 'NO'}`);
+
+                if (analysis.hasText && analysis.text[0].text) {
+                    console.log(`  Response: "${analysis.text[0].text.substring(0, 100)}..."`);
+                }
+
+                const passed = analysis.hasThinking && analysis.hasText;
+                results.push({ name: 'Turn 3: Thinking + Text response', passed });
+                if (!passed) allPassed = false;
+            }
+        }
+    }
+
+    // ===== Summary =====
+    console.log('\n' + '='.repeat(60));
+    console.log('SUMMARY');
+    console.log('='.repeat(60));
+
+    for (const result of results) {
+        const status = result.passed ? 'PASS' : 'FAIL';
+        console.log(`  [${status}] ${result.name}`);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`OVERALL: ${allPassed ? 'ALL TESTS PASSED' : 'SOME TESTS FAILED'}`);
+    console.log('='.repeat(60));
+
+    process.exit(allPassed ? 0 : 1);
+}
+
+runTests().catch(err => {
+    console.error('Test failed with error:', err);
+    process.exit(1);
+});

tests/test-thinking-signatures.cjs

@@ -0,0 +1,272 @@
+/**
+ * Thinking Signature Test
+ *
+ * Tests that thinking blocks with signatures are properly handled in multi-turn
+ * conversations, simulating how Claude Code sends requests.
+ *
+ * Claude Code sends assistant messages with thinking blocks that include signatures.
+ * These signatures must be preserved and sent back to the API.
+ */
+const http = require('http');
+
+const BASE_URL = 'localhost';
+const PORT = 8080;
+
+function streamRequest(body) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const req = http.request({
+            host: BASE_URL,
+            port: PORT,
+            path: '/v1/messages',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': 'test',
+                'anthropic-version': '2023-06-01',
+                'anthropic-beta': 'interleaved-thinking-2025-05-14',
+                'Content-Length': Buffer.byteLength(data)
+            }
+        }, res => {
+            const events = [];
+            let fullData = '';
+
+            res.on('data', chunk => {
+                fullData += chunk.toString();
+            });
+
+            res.on('end', () => {
+                // Parse SSE events
+                const parts = fullData.split('\n\n').filter(e => e.trim());
+                for (const part of parts) {
+                    const lines = part.split('\n');
+                    const eventLine = lines.find(l => l.startsWith('event:'));
+                    const dataLine = lines.find(l => l.startsWith('data:'));
+                    if (eventLine && dataLine) {
+                        try {
+                            const eventType = eventLine.replace('event:', '').trim();
+                            const eventData = JSON.parse(dataLine.replace('data:', '').trim());
+                            events.push({ type: eventType, data: eventData });
+                        } catch (e) { }
+                    }
+                }
+
+                // Build content from events
+                const content = [];
+                let currentBlock = null;
+
+                for (const event of events) {
+                    if (event.type === 'content_block_start') {
+                        currentBlock = { ...event.data.content_block };
+                        if (currentBlock.type === 'thinking') {
+                            currentBlock.thinking = '';
+                            currentBlock.signature = '';
+                        }
+                        if (currentBlock.type === 'text') currentBlock.text = '';
+                    } else if (event.type === 'content_block_delta') {
+                        const delta = event.data.delta;
+                        if (delta.type === 'thinking_delta' && currentBlock) {
+                            currentBlock.thinking += delta.thinking || '';
+                        }
+                        if (delta.type === 'signature_delta' && currentBlock) {
+                            currentBlock.signature += delta.signature || '';
+                        }
+                        if (delta.type === 'text_delta' && currentBlock) {
+                            currentBlock.text += delta.text || '';
+                        }
+                        if (delta.type === 'input_json_delta' && currentBlock) {
+                            currentBlock.partial_json = (currentBlock.partial_json || '') + delta.partial_json;
+                        }
+                    } else if (event.type === 'content_block_stop') {
+                        if (currentBlock?.type === 'tool_use' && currentBlock.partial_json) {
+                            try { currentBlock.input = JSON.parse(currentBlock.partial_json); } catch (e) { }
+                            delete currentBlock.partial_json;
+                        }
+                        if (currentBlock) content.push(currentBlock);
+                        currentBlock = null;
+                    }
+                }
+
+                resolve({ content, events, statusCode: res.statusCode, raw: fullData });
+            });
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+
+const tools = [{
+    name: 'get_weather',
+    description: 'Get the current weather for a location',
+    input_schema: {
+        type: 'object',
+        properties: {
+            location: { type: 'string', description: 'City name' }
+        },
+        required: ['location']
+    }
+}];
+
+async function runTests() {
+    console.log('='.repeat(60));
+    console.log('THINKING SIGNATURE TEST');
+    console.log('Simulates Claude Code multi-turn with thinking blocks');
+    console.log('='.repeat(60));
+    console.log('');
+
+    let allPassed = true;
+    const results = [];
+
+    // ===== TEST 1: First turn - get thinking block with signature =====
+    console.log('TEST 1: Initial request with thinking model');
+    console.log('-'.repeat(40));
+
+    const turn1Messages = [
+        { role: 'user', content: 'What is the weather in Paris? Use the get_weather tool.' }
+    ];
+
+    const turn1Result = await streamRequest({
+        model: 'claude-sonnet-4-5-thinking',
+        max_tokens: 4096,
+        stream: true,
+        tools,
+        thinking: { type: 'enabled', budget_tokens: 10000 },
+        messages: turn1Messages
+    });
+
+    const turn1Thinking = turn1Result.content.filter(b => b.type === 'thinking');
+    const turn1ToolUse = turn1Result.content.filter(b => b.type === 'tool_use');
+    const turn1Text = turn1Result.content.filter(b => b.type === 'text');
+
+    console.log(`  Thinking blocks: ${turn1Thinking.length}`);
+    console.log(`  Tool use blocks: ${turn1ToolUse.length}`);
+    console.log(`  Text blocks: ${turn1Text.length}`);
+
+    // Check thinking has signature
+    let turn1HasSignature = false;
+    if (turn1Thinking.length > 0) {
+        const sig = turn1Thinking[0].signature || '';
+        turn1HasSignature = sig.length >= 50;
+        console.log(`  Signature length: ${sig.length} chars`);
+        console.log(`  Signature present: ${turn1HasSignature ? 'YES' : 'NO'}`);
+        if (turn1Thinking[0].thinking) {
+            console.log(`  Thinking preview: "${turn1Thinking[0].thinking.substring(0, 80)}..."`);
+        }
+    }
+
+    const test1Pass = turn1Thinking.length > 0 && turn1HasSignature && turn1ToolUse.length > 0;
+    results.push({ name: 'Turn 1: Thinking + Signature + Tool Use', passed: test1Pass });
+    console.log(`  Result: ${test1Pass ? 'PASS' : 'FAIL'}`);
+    if (!test1Pass) allPassed = false;
+
+    // ===== TEST 2: Second turn - send back thinking with signature =====
+    console.log('\nTEST 2: Multi-turn with thinking signature in assistant message');
+    console.log('-'.repeat(40));
+
+    if (!turn1ToolUse.length) {
+        console.log('  SKIPPED - No tool use in turn 1');
+        results.push({ name: 'Turn 2: Multi-turn with signature', passed: false, skipped: true });
+    } else {
+        // Build assistant message with thinking (including signature) - this is how Claude Code sends it
+        const assistantContent = turn1Result.content;
+
+        // Verify the thinking block has signature before sending
+        const thinkingInAssistant = assistantContent.find(b => b.type === 'thinking');
+        if (thinkingInAssistant) {
+            console.log(`  Sending thinking with signature: ${(thinkingInAssistant.signature || '').length} chars`);
+        }
+
+        const turn2Messages = [
+            ...turn1Messages,
+            { role: 'assistant', content: assistantContent },
+            {
+                role: 'user',
+                content: [{
+                    type: 'tool_result',
+                    tool_use_id: turn1ToolUse[0].id,
+                    content: 'The weather in Paris is 18°C and sunny.'
+                }]
+            }
+        ];
+
+        const turn2Result = await streamRequest({
+            model: 'claude-sonnet-4-5-thinking',
+            max_tokens: 4096,
+            stream: true,
+            tools,
+            thinking: { type: 'enabled', budget_tokens: 10000 },
+            messages: turn2Messages
+        });
+
+        const turn2Thinking = turn2Result.content.filter(b => b.type === 'thinking');
+        const turn2Text = turn2Result.content.filter(b => b.type === 'text');
+
+        console.log(`  Thinking blocks: ${turn2Thinking.length}`);
+        console.log(`  Text blocks: ${turn2Text.length}`);
+
+        // Check for errors
+        const hasError = turn2Result.events.some(e => e.type === 'error');
+        if (hasError) {
+            const errorEvent = turn2Result.events.find(e => e.type === 'error');
+            console.log(`  ERROR: ${errorEvent?.data?.error?.message || 'Unknown error'}`);
+        }
+
+        if (turn2Thinking.length > 0) {
+            const sig = turn2Thinking[0].signature || '';
+            console.log(`  New signature length: ${sig.length} chars`);
+            if (turn2Thinking[0].thinking) {
+                console.log(`  Thinking preview: "${turn2Thinking[0].thinking.substring(0, 80)}..."`);
+            }
+        }
+
+        if (turn2Text.length > 0 && turn2Text[0].text) {
+            console.log(`  Response: "${turn2Text[0].text.substring(0, 100)}..."`);
+        }
+
+        const test2Pass = !hasError && (turn2Thinking.length > 0 || turn2Text.length > 0);
+        results.push({ name: 'Turn 2: Multi-turn with signature', passed: test2Pass });
+        console.log(`  Result: ${test2Pass ? 'PASS' : 'FAIL'}`);
+        if (!test2Pass) allPassed = false;
+    }
+
+    // ===== TEST 3: Verify signature_delta events in stream =====
+    console.log('\nTEST 3: Verify signature_delta events in stream');
+    console.log('-'.repeat(40));
+
+    const signatureDeltas = turn1Result.events.filter(
+        e => e.type === 'content_block_delta' && e.data?.delta?.type === 'signature_delta'
+    );
+    console.log(`  signature_delta events: ${signatureDeltas.length}`);
+
+    if (signatureDeltas.length > 0) {
+        const totalSigLength = signatureDeltas.reduce((sum, e) => sum + (e.data.delta.signature?.length || 0), 0);
+        console.log(`  Total signature length from deltas: ${totalSigLength} chars`);
+    }
+
+    const test3Pass = signatureDeltas.length > 0;
+    results.push({ name: 'signature_delta events present', passed: test3Pass });
+    console.log(`  Result: ${test3Pass ? 'PASS' : 'FAIL'}`);
+    if (!test3Pass) allPassed = false;
+
+    // ===== Summary =====
+    console.log('\n' + '='.repeat(60));
+    console.log('SUMMARY');
+    console.log('='.repeat(60));
+
+    for (const result of results) {
+        const status = result.skipped ? 'SKIP' : (result.passed ? 'PASS' : 'FAIL');
+        console.log(`  [${status}] ${result.name}`);
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`OVERALL: ${allPassed ? 'ALL TESTS PASSED' : 'SOME TESTS FAILED'}`);
+    console.log('='.repeat(60));
+
+    process.exit(allPassed ? 0 : 1);
+}
+
+runTests().catch(err => {
+    console.error('Test failed with error:', err);
+    process.exit(1);
+});