@expiren/opencode-antigravity-auth 1.6.41 → 1.6.43

package/dist/index.js

@@ -3500,9 +3500,21 @@ var AntigravityConfigSchema = z2.object({
     z2.literal("auto"),
     z2.number().min(1).max(120)
   ]).default("auto"),
+  /**
+   * Proactive rotation threshold percentage (0-100).
+   * After a successful request, if the current account's remaining quota
+   * drops below this percentage, proactively switch to a warm-cache account
+   * before the next request — avoiding a forced 429 mid-conversation.
+   *
+   * Set to 0 to disable proactive rotation.
+   *
+   * @default 20
+   * @env OPENCODE_ANTIGRAVITY_PROACTIVE_ROTATION_THRESHOLD
+   */
+  proactive_rotation_threshold_percent: z2.number().min(0).max(100).default(20),
   // =========================================================================
   // Health Score (used by hybrid strategy)
-  // =========================================================================
+  // =========================================================================   
   health_score: z2.object({
     initial: z2.number().min(0).max(100).default(70),
     success_reward: z2.number().min(0).max(10).default(1),
@@ -3565,6 +3577,7 @@ var DEFAULT_CONFIG = {
   soft_quota_threshold_percent: 90,
   quota_refresh_interval_minutes: 30,
   soft_quota_cache_ttl_minutes: "auto",
+  proactive_rotation_threshold_percent: 20,
   auto_update: true,
   signature_cache: {
     enabled: true,
@@ -9127,6 +9140,7 @@ var AccountManager = class _AccountManager {
   savePromiseResolvers = [];
   sessionStartTime = Date.now();
   sessionRequestCounts = /* @__PURE__ */ new Map();
+  sessionUsedAccounts = /* @__PURE__ */ new Set();
   static async loadFromDisk(authFallback) {
     const stored = await loadAccounts();
     return new _AccountManager(authFallback, stored);
@@ -9352,7 +9366,9 @@ var AccountManager = class _AccountManager {
     if (available.length === 0) {
       return null;
     }
-    const account = available[this.cursor % available.length];
+    const sessionUsed = available.filter((a) => this.sessionUsedAccounts.has(a.index));
+    const candidates = sessionUsed.length > 0 ? sessionUsed : available;
+    const account = candidates[this.cursor % candidates.length];
     if (!account) {
       return null;
     }
@@ -9374,6 +9390,51 @@ var AccountManager = class _AccountManager {
       account.lastUsed = nowMs();
     }
   }
+  recordSessionUsage(accountIndex) {
+    this.sessionUsedAccounts.add(accountIndex);
+  }
+  wasUsedInSession(accountIndex) {
+    return this.sessionUsedAccounts.has(accountIndex);
+  }
+  shouldProactivelyRotate(family, model, thresholdPercent, cacheTtlMs) {
+    if (thresholdPercent <= 0) return false;
+    const current = this.getCurrentAccountForFamily(family);
+    if (!current || !current.cachedQuota || current.cachedQuotaUpdatedAt == null) return false;
+    const age = nowMs() - current.cachedQuotaUpdatedAt;
+    if (age > cacheTtlMs) return false;
+    const quotaGroup = resolveQuotaGroup(family, model);
+    const groupData = current.cachedQuota[quotaGroup];
+    if (groupData?.remainingFraction == null) return false;
+    const remainingPercent = Math.max(0, Math.min(100, groupData.remainingFraction * 100));
+    return remainingPercent < thresholdPercent;
+  }
+  proactivelyRotateForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs) {
+    const currentIndex = this.currentAccountIndexByFamily[family];
+    const candidates = this.accounts.filter((acc) => {
+      if (acc.enabled === false) return false;
+      if (acc.index === currentIndex) return false;
+      clearExpiredRateLimits(acc);
+      if (isRateLimitedForHeaderStyle(acc, family, headerStyle, model)) return false;
+      if (isOverSoftQuotaThreshold(acc, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model)) return false;
+      if (this.isAccountCoolingDown(acc)) return false;
+      return true;
+    });
+    if (candidates.length === 0) return null;
+    const warmCandidates = candidates.filter((a) => this.sessionUsedAccounts.has(a.index));
+    const pool = warmCandidates.length > 0 ? warmCandidates : candidates;
+    const quotaGroup = resolveQuotaGroup(family, model);
+    pool.sort((a, b) => {
+      const aRemaining = a.cachedQuota?.[quotaGroup]?.remainingFraction ?? 0;
+      const bRemaining = b.cachedQuota?.[quotaGroup]?.remainingFraction ?? 0;
+      return bRemaining - aRemaining;
+    });
+    const selected = pool[0];
+    if (!selected) return null;
+    const quotaKey = getQuotaKey(family, headerStyle, model);
+    this.markTouchedForQuota(selected, quotaKey);
+    this.currentAccountIndexByFamily[family] = selected.index;
+    return selected;
+  }
   markRateLimitedWithReason(account, family, headerStyle, model, reason, retryAfterMs, failureTtlMs = 36e5) {
     const now = nowMs();
     if (account.lastFailureTime !== void 0 && now - account.lastFailureTime > failureTtlMs) {
@@ -12494,6 +12555,7 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                 pushDebug(`account-switch: ${previousAccountIndex} \u2192 ${account.index}, warmup=${needsCacheWarmup}`);
               }
               previousAccountIndex = account.index;
+              accountManager.recordSessionUsage(account.index);
               if (isDebugEnabled()) {
                 logAccountContext("Selected", {
                   index: account.index,
@@ -13028,6 +13090,27 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                         providerId,
                         config.quota_refresh_interval_minutes
                       );
+                      const proactiveThreshold = config.proactive_rotation_threshold_percent ?? 20;
+                      if (proactiveThreshold > 0 && accountManager.shouldProactivelyRotate(
+                        family,
+                        model,
+                        proactiveThreshold,
+                        softQuotaCacheTtlMs
+                      )) {
+                        const rotated = accountManager.proactivelyRotateForFamily(
+                          family,
+                          model,
+                          headerStyle,
+                          config.soft_quota_threshold_percent,
+                          softQuotaCacheTtlMs
+                        );
+                        if (rotated) {
+                          const remaining = account.cachedQuota?.[resolveQuotaGroup(family, model)]?.remainingFraction;
+                          const remainingPct = remaining != null ? `${(remaining * 100).toFixed(1)}%` : "?";
+                          pushDebug(`[ProactiveRotation] account ${account.index} quota ${remainingPct} < ${proactiveThreshold}%, pre-switched to account ${rotated.index} for next request`);
+                          pushDebug(`[ProactiveRotation] ${account.index} \u2192 ${rotated.index} (warm=${accountManager.wasUsedInSession(rotated.index)})`);
+                        }
+                      }
                     }
                     logAntigravityDebugResponse(debugContext, response, {
                       note: response.ok ? "Success" : `Error ${response.status}`