antigravity-claude-proxy 1.2.2 → 1.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-claude-proxy",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Proxy server to use Antigravity's Claude models with Claude Code CLI",
   "main": "src/index.js",
   "type": "module",

package/src/account-manager/credentials.js

@@ -14,6 +14,7 @@ import {
 import { refreshAccessToken } from '../auth/oauth.js';
 import { getAuthStatus } from '../auth/database.js';
 import { logger } from '../utils/logger.js';
+import { isNetworkError } from '../utils/helpers.js';
 
 /**
  * Get OAuth token for an account
@@ -48,6 +49,13 @@ export async function getTokenForAccount(account, tokenCache, onInvalid, onSave)
             }
             logger.success(`[AccountManager] Refreshed OAuth token for: ${account.email}`);
         } catch (error) {
+            // Check if it's a transient network error
+            if (isNetworkError(error)) {
+                logger.warn(`[AccountManager] Failed to refresh token for ${account.email} due to network error: ${error.message}`);
+                // Do NOT mark as invalid, just throw so caller knows it failed
+                throw new Error(`AUTH_NETWORK_ERROR: ${error.message}`);
+            }
+
             logger.error(`[AccountManager] Failed to refresh token for ${account.email}:`, error.message);
             // Mark account as invalid (credentials need re-auth)
             if (onInvalid) onInvalid(account.email, error.message);
@@ -123,14 +131,20 @@ export async function discoverProject(token) {
                 })
             });
 
-            if (!response.ok) continue;
+            if (!response.ok) {
+                const errorText = await response.text();
+                logger.warn(`[AccountManager] Project discovery failed at ${endpoint}: ${response.status} - ${errorText}`);
+                continue;
+            }
 
             const data = await response.json();
 
             if (typeof data.cloudaicompanionProject === 'string') {
+                logger.success(`[AccountManager] Discovered project: ${data.cloudaicompanionProject}`);
                 return data.cloudaicompanionProject;
             }
             if (data.cloudaicompanionProject?.id) {
+                logger.success(`[AccountManager] Discovered project: ${data.cloudaicompanionProject.id}`);
                 return data.cloudaicompanionProject.id;
             }
         } catch (error) {
@@ -138,7 +152,8 @@ export async function discoverProject(token) {
         }
     }
 
-    logger.info(`[AccountManager] Using default project: ${DEFAULT_PROJECT_ID}`);
+    logger.warn(`[AccountManager] Project discovery failed for all endpoints. Using default project: ${DEFAULT_PROJECT_ID}`);
+    logger.warn(`[AccountManager] If you see 404 errors, your account may not have Gemini Code Assist enabled.`);
     return DEFAULT_PROJECT_ID;
 }
 

package/src/account-manager/index.js

@@ -81,18 +81,20 @@ export class AccountManager {
 
     /**
      * Check if all accounts are rate-limited
+     * @param {string} [modelId] - Optional model ID
      * @returns {boolean} True if all accounts are rate-limited
      */
-    isAllRateLimited() {
-        return checkAllRateLimited(this.#accounts);
+    isAllRateLimited(modelId = null) {
+        return checkAllRateLimited(this.#accounts, modelId);
     }
 
     /**
      * Get list of available (non-rate-limited, non-invalid) accounts
+     * @param {string} [modelId] - Optional model ID
      * @returns {Array<Object>} Array of available account objects
      */
-    getAvailableAccounts() {
-        return getAvailable(this.#accounts);
+    getAvailableAccounts(modelId = null) {
+        return getAvailable(this.#accounts, modelId);
     }
 
     /**
@@ -127,10 +129,11 @@ export class AccountManager {
     /**
      * Pick the next available account (fallback when current is unavailable).
      * Sets activeIndex to the selected account's index.
+     * @param {string} [modelId] - Optional model ID
      * @returns {Object|null} The next available account or null if none available
      */
-    pickNext() {
-        const { account, newIndex } = selectNext(this.#accounts, this.#currentIndex, () => this.saveToDisk());
+    pickNext(modelId = null) {
+        const { account, newIndex } = selectNext(this.#accounts, this.#currentIndex, () => this.saveToDisk(), modelId);
         this.#currentIndex = newIndex;
         return account;
     }
@@ -138,10 +141,11 @@ export class AccountManager {
     /**
      * Get the current account without advancing the index (sticky selection).
      * Used for cache continuity - sticks to the same account until rate-limited.
+     * @param {string} [modelId] - Optional model ID
      * @returns {Object|null} The current account or null if unavailable/rate-limited
      */
-    getCurrentStickyAccount() {
-        const { account, newIndex } = getSticky(this.#accounts, this.#currentIndex, () => this.saveToDisk());
+    getCurrentStickyAccount(modelId = null) {
+        const { account, newIndex } = getSticky(this.#accounts, this.#currentIndex, () => this.saveToDisk(), modelId);
         this.#currentIndex = newIndex;
         return account;
     }
@@ -149,10 +153,11 @@ export class AccountManager {
     /**
      * Check if we should wait for the current account's rate limit to reset.
      * Used for sticky account selection - wait if rate limit is short (≤ threshold).
+     * @param {string} [modelId] - Optional model ID
      * @returns {{shouldWait: boolean, waitMs: number, account: Object|null}}
      */
-    shouldWaitForCurrentAccount() {
-        return shouldWait(this.#accounts, this.#currentIndex);
+    shouldWaitForCurrentAccount(modelId = null) {
+        return shouldWait(this.#accounts, this.#currentIndex, modelId);
     }
 
     /**
@@ -160,10 +165,11 @@ export class AccountManager {
      * Prefers the current account for cache continuity, only switches when:
      * - Current account is rate-limited for > 2 minutes
      * - Current account is invalid
+     * @param {string} [modelId] - Optional model ID
      * @returns {{account: Object|null, waitMs: number}} Account to use and optional wait time
      */
-    pickStickyAccount() {
-        const { account, waitMs, newIndex } = selectSticky(this.#accounts, this.#currentIndex, () => this.saveToDisk());
+    pickStickyAccount(modelId = null) {
+        const { account, waitMs, newIndex } = selectSticky(this.#accounts, this.#currentIndex, () => this.saveToDisk(), modelId);
         this.#currentIndex = newIndex;
         return { account, waitMs };
     }
@@ -172,9 +178,10 @@ export class AccountManager {
      * Mark an account as rate-limited
      * @param {string} email - Email of the account to mark
      * @param {number|null} resetMs - Time in ms until rate limit resets (optional)
+     * @param {string} [modelId] - Optional model ID to mark specific limit
      */
-    markRateLimited(email, resetMs = null) {
-        markLimited(this.#accounts, email, resetMs, this.#settings);
+    markRateLimited(email, resetMs = null, modelId = null) {
+        markLimited(this.#accounts, email, resetMs, this.#settings, modelId);
         this.saveToDisk();
     }
 
@@ -190,10 +197,11 @@ export class AccountManager {
 
     /**
      * Get the minimum wait time until any account becomes available
+     * @param {string} [modelId] - Optional model ID
      * @returns {number} Wait time in milliseconds
      */
-    getMinWaitTimeMs() {
-        return getMinWait(this.#accounts);
+    getMinWaitTimeMs(modelId = null) {
+        return getMinWait(this.#accounts, modelId);
     }
 
     /**
@@ -251,9 +259,16 @@ export class AccountManager {
      */
     getStatus() {
         const available = this.getAvailableAccounts();
-        const rateLimited = this.#accounts.filter(a => a.isRateLimited);
         const invalid = this.getInvalidAccounts();
 
+        // Count accounts that have any active model-specific rate limits
+        const rateLimited = this.#accounts.filter(a => {
+            if (!a.modelRateLimits) return false;
+            return Object.values(a.modelRateLimits).some(
+                limit => limit.isRateLimited && limit.resetTime > Date.now()
+            );
+        });
+
         return {
             total: this.#accounts.length,
             available: available.length,
@@ -263,8 +278,7 @@ export class AccountManager {
             accounts: this.#accounts.map(a => ({
                 email: a.email,
                 source: a.source,
-                isRateLimited: a.isRateLimited,
-                rateLimitResetTime: a.rateLimitResetTime,
+                modelRateLimits: a.modelRateLimits || {},
                 isInvalid: a.isInvalid || false,
                 invalidReason: a.invalidReason || null,
                 lastUsed: a.lastUsed

package/src/account-manager/rate-limits.js

@@ -2,6 +2,7 @@
  * Rate Limit Management
  *
  * Handles rate limit tracking and state management for accounts.
+ * All rate limits are model-specific.
  */
 
 import { DEFAULT_COOLDOWN_MS } from '../constants.js';
@@ -9,24 +10,44 @@ import { formatDuration } from '../utils/helpers.js';
 import { logger } from '../utils/logger.js';
 
 /**
- * Check if all accounts are rate-limited
+ * Check if all accounts are rate-limited for a specific model
  *
  * @param {Array} accounts - Array of account objects
+ * @param {string} modelId - Model ID to check rate limits for
  * @returns {boolean} True if all accounts are rate-limited
  */
-export function isAllRateLimited(accounts) {
+export function isAllRateLimited(accounts, modelId) {
     if (accounts.length === 0) return true;
-    return accounts.every(acc => acc.isRateLimited);
+    if (!modelId) return false; // No model specified = not rate limited
+
+    return accounts.every(acc => {
+        if (acc.isInvalid) return true; // Invalid accounts count as unavailable
+        const modelLimits = acc.modelRateLimits || {};
+        const limit = modelLimits[modelId];
+        return limit && limit.isRateLimited && limit.resetTime > Date.now();
+    });
 }
 
 /**
- * Get list of available (non-rate-limited, non-invalid) accounts
+ * Get list of available (non-rate-limited, non-invalid) accounts for a model
  *
  * @param {Array} accounts - Array of account objects
+ * @param {string} [modelId] - Model ID to filter by
  * @returns {Array} Array of available account objects
  */
-export function getAvailableAccounts(accounts) {
-    return accounts.filter(acc => !acc.isRateLimited && !acc.isInvalid);
+export function getAvailableAccounts(accounts, modelId = null) {
+    return accounts.filter(acc => {
+        if (acc.isInvalid) return false;
+
+        if (modelId && acc.modelRateLimits && acc.modelRateLimits[modelId]) {
+            const limit = acc.modelRateLimits[modelId];
+            if (limit.isRateLimited && limit.resetTime > Date.now()) {
+                return false;
+            }
+        }
+
+        return true;
+    });
 }
 
 /**
@@ -50,11 +71,15 @@ export function clearExpiredLimits(accounts) {
     let cleared = 0;
 
     for (const account of accounts) {
-        if (account.isRateLimited && account.rateLimitResetTime && account.rateLimitResetTime <= now) {
-            account.isRateLimited = false;
-            account.rateLimitResetTime = null;
-            cleared++;
-            logger.success(`[AccountManager] Rate limit expired for: ${account.email}`);
+        if (account.modelRateLimits) {
+            for (const [modelId, limit] of Object.entries(account.modelRateLimits)) {
+                if (limit.isRateLimited && limit.resetTime <= now) {
+                    limit.isRateLimited = false;
+                    limit.resetTime = null;
+                    cleared++;
+                    logger.success(`[AccountManager] Rate limit expired for: ${account.email} (model: ${modelId})`);
+                }
+            }
         }
     }
 
@@ -68,31 +93,43 @@ export function clearExpiredLimits(accounts) {
  */
 export function resetAllRateLimits(accounts) {
     for (const account of accounts) {
-        account.isRateLimited = false;
-        account.rateLimitResetTime = null;
+        if (account.modelRateLimits) {
+            for (const key of Object.keys(account.modelRateLimits)) {
+                account.modelRateLimits[key] = { isRateLimited: false, resetTime: null };
+            }
+        }
     }
     logger.warn('[AccountManager] Reset all rate limits for optimistic retry');
 }
 
 /**
- * Mark an account as rate-limited
+ * Mark an account as rate-limited for a specific model
  *
  * @param {Array} accounts - Array of account objects
  * @param {string} email - Email of the account to mark
- * @param {number|null} resetMs - Time in ms until rate limit resets (optional)
+ * @param {number|null} resetMs - Time in ms until rate limit resets
  * @param {Object} settings - Settings object with cooldownDurationMs
+ * @param {string} modelId - Model ID to mark rate limit for
  * @returns {boolean} True if account was found and marked
  */
-export function markRateLimited(accounts, email, resetMs = null, settings = {}) {
+export function markRateLimited(accounts, email, resetMs = null, settings = {}, modelId) {
     const account = accounts.find(a => a.email === email);
     if (!account) return false;
 
-    account.isRateLimited = true;
     const cooldownMs = resetMs || settings.cooldownDurationMs || DEFAULT_COOLDOWN_MS;
-    account.rateLimitResetTime = Date.now() + cooldownMs;
+    const resetTime = Date.now() + cooldownMs;
+
+    if (!account.modelRateLimits) {
+        account.modelRateLimits = {};
+    }
+
+    account.modelRateLimits[modelId] = {
+        isRateLimited: true,
+        resetTime: resetTime
+    };
 
     logger.warn(
-        `[AccountManager] Rate limited: ${email}. Available in ${formatDuration(cooldownMs)}`
+        `[AccountManager] Rate limited: ${email} (model: ${modelId}). Available in ${formatDuration(cooldownMs)}`
     );
 
     return true;
@@ -128,24 +165,28 @@ export function markInvalid(accounts, email, reason = 'Unknown error') {
 }
 
 /**
- * Get the minimum wait time until any account becomes available
+ * Get the minimum wait time until any account becomes available for a model
  *
  * @param {Array} accounts - Array of account objects
+ * @param {string} modelId - Model ID to check
  * @returns {number} Wait time in milliseconds
  */
-export function getMinWaitTimeMs(accounts) {
-    if (!isAllRateLimited(accounts)) return 0;
+export function getMinWaitTimeMs(accounts, modelId) {
+    if (!isAllRateLimited(accounts, modelId)) return 0;
 
     const now = Date.now();
     let minWait = Infinity;
     let soonestAccount = null;
 
     for (const account of accounts) {
-        if (account.rateLimitResetTime) {
-            const wait = account.rateLimitResetTime - now;
-            if (wait > 0 && wait < minWait) {
-                minWait = wait;
-                soonestAccount = account;
+        if (modelId && account.modelRateLimits && account.modelRateLimits[modelId]) {
+            const limit = account.modelRateLimits[modelId];
+            if (limit.isRateLimited && limit.resetTime) {
+                const wait = limit.resetTime - now;
+                if (wait > 0 && wait < minWait) {
+                    minWait = wait;
+                    soonestAccount = account;
+                }
             }
         }
     }

package/src/account-manager/selection.js

@@ -2,6 +2,7 @@
  * Account Selection
  *
  * Handles account picking logic (round-robin, sticky) for cache continuity.
+ * All rate limit checks are model-specific.
  */
 
 import { MAX_WAIT_BEFORE_ERROR_MS } from '../constants.js';
@@ -9,18 +10,38 @@ import { formatDuration } from '../utils/helpers.js';
 import { logger } from '../utils/logger.js';
 import { clearExpiredLimits, getAvailableAccounts } from './rate-limits.js';
 
+/**
+ * Check if an account is usable for a specific model
+ * @param {Object} account - Account object
+ * @param {string} modelId - Model ID to check
+ * @returns {boolean} True if account is usable
+ */
+function isAccountUsable(account, modelId) {
+    if (!account || account.isInvalid) return false;
+
+    if (modelId && account.modelRateLimits && account.modelRateLimits[modelId]) {
+        const limit = account.modelRateLimits[modelId];
+        if (limit.isRateLimited && limit.resetTime > Date.now()) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 /**
  * Pick the next available account (fallback when current is unavailable).
  *
  * @param {Array} accounts - Array of account objects
  * @param {number} currentIndex - Current account index
  * @param {Function} onSave - Callback to save changes
+ * @param {string} [modelId] - Model ID to check rate limits for
  * @returns {{account: Object|null, newIndex: number}} The next available account and new index
  */
-export function pickNext(accounts, currentIndex, onSave) {
+export function pickNext(accounts, currentIndex, onSave, modelId = null) {
     clearExpiredLimits(accounts);
 
-    const available = getAvailableAccounts(accounts);
+    const available = getAvailableAccounts(accounts, modelId);
     if (available.length === 0) {
         return { account: null, newIndex: currentIndex };
     }
@@ -36,7 +57,7 @@ export function pickNext(accounts, currentIndex, onSave) {
         const idx = (index + i) % accounts.length;
         const account = accounts[idx];
 
-        if (!account.isRateLimited && !account.isInvalid) {
+        if (isAccountUsable(account, modelId)) {
             account.lastUsed = Date.now();
 
             const position = idx + 1;
@@ -59,9 +80,10 @@ export function pickNext(accounts, currentIndex, onSave) {
  * @param {Array} accounts - Array of account objects
  * @param {number} currentIndex - Current account index
  * @param {Function} onSave - Callback to save changes
+ * @param {string} [modelId] - Model ID to check rate limits for
  * @returns {{account: Object|null, newIndex: number}} The current account and index
  */
-export function getCurrentStickyAccount(accounts, currentIndex, onSave) {
+export function getCurrentStickyAccount(accounts, currentIndex, onSave, modelId = null) {
     clearExpiredLimits(accounts);
 
     if (accounts.length === 0) {
@@ -77,8 +99,7 @@ export function getCurrentStickyAccount(accounts, currentIndex, onSave) {
     // Get current account directly (activeIndex = current account)
     const account = accounts[index];
 
-    // Return if available
-    if (account && !account.isRateLimited && !account.isInvalid) {
+    if (isAccountUsable(account, modelId)) {
         account.lastUsed = Date.now();
         // Trigger save (don't await to avoid blocking)
         if (onSave) onSave();
@@ -93,9 +114,10 @@ export function getCurrentStickyAccount(accounts, currentIndex, onSave) {
  *
  * @param {Array} accounts - Array of account objects
  * @param {number} currentIndex - Current account index
+ * @param {string} [modelId] - Model ID to check rate limits for
  * @returns {{shouldWait: boolean, waitMs: number, account: Object|null}}
  */
-export function shouldWaitForCurrentAccount(accounts, currentIndex) {
+export function shouldWaitForCurrentAccount(accounts, currentIndex, modelId = null) {
     if (accounts.length === 0) {
         return { shouldWait: false, waitMs: 0, account: null };
     }
@@ -113,15 +135,21 @@ export function shouldWaitForCurrentAccount(accounts, currentIndex) {
         return { shouldWait: false, waitMs: 0, account: null };
     }
 
-    if (account.isRateLimited && account.rateLimitResetTime) {
-        const waitMs = account.rateLimitResetTime - Date.now();
+    let waitMs = 0;
 
-        // If wait time is within threshold, recommend waiting
-        if (waitMs > 0 && waitMs <= MAX_WAIT_BEFORE_ERROR_MS) {
-            return { shouldWait: true, waitMs, account };
+    // Check model-specific limit
+    if (modelId && account.modelRateLimits && account.modelRateLimits[modelId]) {
+        const limit = account.modelRateLimits[modelId];
+        if (limit.isRateLimited && limit.resetTime) {
+            waitMs = limit.resetTime - Date.now();
         }
     }
 
+    // If wait time is within threshold, recommend waiting
+    if (waitMs > 0 && waitMs <= MAX_WAIT_BEFORE_ERROR_MS) {
+        return { shouldWait: true, waitMs, account };
+    }
+
     return { shouldWait: false, waitMs: 0, account };
 }
 
@@ -132,21 +160,22 @@ export function shouldWaitForCurrentAccount(accounts, currentIndex) {
  * @param {Array} accounts - Array of account objects
  * @param {number} currentIndex - Current account index
  * @param {Function} onSave - Callback to save changes
+ * @param {string} [modelId] - Model ID to check rate limits for
  * @returns {{account: Object|null, waitMs: number, newIndex: number}}
  */
-export function pickStickyAccount(accounts, currentIndex, onSave) {
+export function pickStickyAccount(accounts, currentIndex, onSave, modelId = null) {
     // First try to get the current sticky account
-    const { account: stickyAccount, newIndex: stickyIndex } = getCurrentStickyAccount(accounts, currentIndex, onSave);
+    const { account: stickyAccount, newIndex: stickyIndex } = getCurrentStickyAccount(accounts, currentIndex, onSave, modelId);
     if (stickyAccount) {
         return { account: stickyAccount, waitMs: 0, newIndex: stickyIndex };
     }
 
     // Current account is rate-limited or invalid.
     // CHECK IF OTHERS ARE AVAILABLE before deciding to wait.
-    const available = getAvailableAccounts(accounts);
+    const available = getAvailableAccounts(accounts, modelId);
     if (available.length > 0) {
         // Found a free account! Switch immediately.
-        const { account: nextAccount, newIndex } = pickNext(accounts, currentIndex, onSave);
+        const { account: nextAccount, newIndex } = pickNext(accounts, currentIndex, onSave, modelId);
         if (nextAccount) {
             logger.info(`[AccountManager] Switched to new account (failover): ${nextAccount.email}`);
             return { account: nextAccount, waitMs: 0, newIndex };
@@ -154,14 +183,14 @@ export function pickStickyAccount(accounts, currentIndex, onSave) {
     }
 
     // No other accounts available. Now checking if we should wait for current account.
-    const waitInfo = shouldWaitForCurrentAccount(accounts, currentIndex);
+    const waitInfo = shouldWaitForCurrentAccount(accounts, currentIndex, modelId);
     if (waitInfo.shouldWait) {
         logger.info(`[AccountManager] Waiting ${formatDuration(waitInfo.waitMs)} for sticky account: ${waitInfo.account.email}`);
         return { account: null, waitMs: waitInfo.waitMs, newIndex: currentIndex };
     }
 
     // Current account unavailable for too long/invalid, and no others available?
-    const { account: nextAccount, newIndex } = pickNext(accounts, currentIndex, onSave);
+    const { account: nextAccount, newIndex } = pickNext(accounts, currentIndex, onSave, modelId);
     if (nextAccount) {
         logger.info(`[AccountManager] Switched to new account for cache: ${nextAccount.email}`);
     }

package/src/account-manager/storage.js

@@ -26,9 +26,11 @@ export async function loadAccounts(configPath = ACCOUNT_CONFIG_PATH) {
 
         const accounts = (config.accounts || []).map(acc => ({
             ...acc,
-            isRateLimited: acc.isRateLimited || false,
-            rateLimitResetTime: acc.rateLimitResetTime || null,
-            lastUsed: acc.lastUsed || null
+            lastUsed: acc.lastUsed || null,
+            // Reset invalid flag on startup - give accounts a fresh chance to refresh
+            isInvalid: false,
+            invalidReason: null,
+            modelRateLimits: acc.modelRateLimits || {}
         }));
 
         const settings = config.settings || {};
@@ -66,9 +68,8 @@ export function loadDefaultAccount(dbPath) {
             const account = {
                 email: authData.email || 'default@antigravity',
                 source: 'database',
-                isRateLimited: false,
-                rateLimitResetTime: null,
-                lastUsed: null
+                lastUsed: null,
+                modelRateLimits: {}
             };
 
             const tokenCache = new Map();
@@ -111,10 +112,9 @@ export async function saveAccounts(configPath, accounts, settings, activeIndex)
                 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,
+                modelRateLimits: acc.modelRateLimits || {},
                 lastUsed: acc.lastUsed
             })),
             settings: settings,

package/src/cli/accounts.js

@@ -138,8 +138,7 @@ function saveAccounts(accounts, settings = {}) {
                 projectId: acc.projectId,
                 addedAt: acc.addedAt || new Date().toISOString(),
                 lastUsed: acc.lastUsed || null,
-                isRateLimited: acc.isRateLimited || false,
-                rateLimitResetTime: acc.rateLimitResetTime || null
+                modelRateLimits: acc.modelRateLimits || {}
             })),
             settings: {
                 cooldownDurationMs: 60000,
@@ -168,7 +167,11 @@ function displayAccounts(accounts) {
 
     console.log(`\n${accounts.length} account(s) saved:`);
     accounts.forEach((acc, i) => {
-        const status = acc.isRateLimited ? ' (rate-limited)' : '';
+        // Check for any active model-specific rate limits
+        const hasActiveLimit = Object.values(acc.modelRateLimits || {}).some(
+            limit => limit.isRateLimited && limit.resetTime > Date.now()
+        );
+        const status = hasActiveLimit ? ' (rate-limited)' : '';
         console.log(`  ${i + 1}. ${acc.email}${status}`);
     });
 }
@@ -218,8 +221,7 @@ async function addAccount(existingAccounts) {
             refreshToken: result.refreshToken,
             projectId: result.projectId,
             addedAt: new Date().toISOString(),
-            isRateLimited: false,
-            rateLimitResetTime: null
+            modelRateLimits: {}
         };
     } catch (error) {
         console.error(`\n✗ Authentication failed: ${error.message}`);
@@ -280,7 +282,7 @@ async function interactiveAdd(rl) {
     if (accounts.length > 0) {
         displayAccounts(accounts);
 
-        const choice = await rl.question('\n(a)dd new, (r)emove existing, or (f)resh start? [a/r/f]: ');
+        const choice = await rl.question('\n(a)dd new, (r)emove existing, (f)resh start, or (e)xit? [a/r/f/e]: ');
         const c = choice.toLowerCase();
 
         if (c === 'r') {
@@ -291,36 +293,32 @@ async function interactiveAdd(rl) {
             accounts.length = 0;
         } else if (c === 'a') {
             console.log('\nAdding to existing accounts.');
+        } else if (c === 'e') {
+            console.log('\nExiting...');
+            return; // Exit cleanly
         } else {
             console.log('\nInvalid choice, defaulting to add.');
         }
     }
 
-    // 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;
-        }
+    // Add single account
+    if (accounts.length >= MAX_ACCOUNTS) {
+        console.log(`\nMaximum of ${MAX_ACCOUNTS} accounts reached.`);
+        return;
+    }
 
-        const addMore = await rl.question('\nAdd another account? [y/N]: ');
-        if (addMore.toLowerCase() !== 'y') {
-            break;
-        }
+    const newAccount = await addAccount(accounts);
+    if (newAccount) {
+        accounts.push(newAccount);
+        saveAccounts(accounts);
+    } else if (accounts.length > 0) {
+        // Even if newAccount is null (duplicate update), save the updated accounts
+        saveAccounts(accounts);
     }
 
     if (accounts.length > 0) {
         displayAccounts(accounts);
+        console.log('\nTo add more accounts, run this command again.');
     } else {
         console.log('\nNo accounts to save.');
     }
@@ -431,6 +429,8 @@ async function main() {
         }
     } finally {
         rl.close();
+        // Force exit to prevent hanging
+        process.exit(0);
     }
 }