@expiren/opencode-antigravity-auth 1.6.42 → 1.6.44

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,
@@ -9383,6 +9396,45 @@ var AccountManager = class _AccountManager {
   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) {
@@ -12684,12 +12736,12 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                   const parsed = JSON.parse(bodyStr);
                   parsed.generationConfig = {
                     ...parsed.generationConfig ?? {},
-                    maxOutputTokens: 1,
-                    candidateCount: 1
+                    maxOutputTokens: 1
                   };
+                  delete parsed.generationConfig.candidateCount;
                   if (parsed.generationConfig.thinkingConfig) {
                     parsed.generationConfig.thinkingConfig = {
-                      thinkingBudget: 0
+                      thinkingBudget: 128
                     };
                   }
                   const probeHeaders = new Headers(prepared.init.headers ?? {});
@@ -13038,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}`