@expiren/opencode-antigravity-auth 1.6.40 → 1.6.42

package/dist/index.js

@@ -3226,6 +3226,17 @@ var AntigravityConfigSchema = z2.object({
    * @default false
    */
   thinking_warmup: z2.boolean().default(false),
+  /**
+   * Send a lightweight cache-seeding probe when switching to a different account.
+   * The probe reuses the same request prefix with maxOutputTokens=1 so the
+   * server-side implicit cache warms up before the real request fires.
+   * Costs ~1 quota unit per account switch but eliminates the 0% cold-cache
+   * MISS that otherwise occurs on every rotation.
+   *
+   * Env override: OPENCODE_ANTIGRAVITY_CACHE_WARMUP_ON_SWITCH=1
+   * @default true
+   */
+  cache_warmup_on_switch: z2.boolean().default(true),
   // =========================================================================
   // Session Recovery
   // =========================================================================  
@@ -3525,6 +3536,7 @@ var DEFAULT_CONFIG = {
   debug_tui: false,
   keep_thinking: false,
   thinking_warmup: false,
+  cache_warmup_on_switch: true,
   session_recovery: true,
   auto_resume: true,
   resume_text: "continue",
@@ -9115,6 +9127,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);
@@ -9340,7 +9353,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;
     }
@@ -9362,6 +9377,12 @@ var AccountManager = class _AccountManager {
       account.lastUsed = nowMs();
     }
   }
+  recordSessionUsage(accountIndex) {
+    this.sessionUsedAccounts.add(accountIndex);
+  }
+  wasUsedInSession(accountIndex) {
+    return this.sessionUsedAccounts.has(accountIndex);
+  }
   markRateLimitedWithReason(account, family, headerStyle, model, reason, retryAfterMs, failureTtlMs = 36e5) {
     const now = nowMs();
     if (account.lastFailureTime !== void 0 && now - account.lastFailureTime > failureTtlMs) {
@@ -12369,6 +12390,8 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
             };
             let accountSwitchCount = 0;
             const maxAccountSwitches = config.max_account_switches ?? 2;
+            let previousAccountIndex = -1;
+            let needsCacheWarmup = false;
             while (true) {
               checkAborted();
               const accountCount = accountManager.getAccountCount();
@@ -12475,6 +12498,12 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
               pushDebug(
                 `selected idx=${account.index} email=${account.email ?? ""} family=${family} accounts=${accountCount} strategy=${config.account_selection_strategy}`
               );
+              if (previousAccountIndex >= 0 && previousAccountIndex !== account.index) {
+                needsCacheWarmup = config.cache_warmup_on_switch;
+                pushDebug(`account-switch: ${previousAccountIndex} \u2192 ${account.index}, warmup=${needsCacheWarmup}`);
+              }
+              previousAccountIndex = account.index;
+              accountManager.recordSessionUsage(account.index);
               if (isDebugEnabled()) {
                 logAccountContext("Selected", {
                   index: account.index,
@@ -12646,6 +12675,45 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                   );
                 }
               };
+              const runCacheWarmupProbe = async (prepared) => {
+                if (!needsCacheWarmup) return;
+                needsCacheWarmup = false;
+                const bodyStr = typeof prepared.init.body === "string" ? prepared.init.body : void 0;
+                if (!bodyStr) return;
+                try {
+                  const parsed = JSON.parse(bodyStr);
+                  parsed.generationConfig = {
+                    ...parsed.generationConfig ?? {},
+                    maxOutputTokens: 1,
+                    candidateCount: 1
+                  };
+                  if (parsed.generationConfig.thinkingConfig) {
+                    parsed.generationConfig.thinkingConfig = {
+                      thinkingBudget: 0
+                    };
+                  }
+                  const probeHeaders = new Headers(prepared.init.headers ?? {});
+                  probeHeaders.set("accept", "application/json");
+                  const probeUrl = toUrlString(prepared.request).replace(
+                    ":streamGenerateContent?alt=sse",
+                    ":generateContent"
+                  );
+                  pushDebug("cache-warmup-probe: start");
+                  const probeResponse = await fetch(probeUrl, {
+                    ...prepared.init,
+                    method: "POST",
+                    headers: probeHeaders,
+                    body: JSON.stringify(parsed)
+                  });
+                  await probeResponse.text();
+                  const status = probeResponse.status;
+                  pushDebug(`cache-warmup-probe: done status=${status}`);
+                } catch (error) {
+                  pushDebug(
+                    `cache-warmup-probe: failed ${error instanceof Error ? error.message : String(error)}`
+                  );
+                }
+              };
               let apiRequestCount = 0;
               let shouldSwitchAccount = false;
               let headerStyle = preferredHeaderStyle;
@@ -12756,6 +12824,7 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                       toolDebugPayload: prepared.toolDebugPayload
                     });
                     await runThinkingWarmup(prepared, projectContext.effectiveProjectId);
+                    await runCacheWarmupProbe(prepared);
                     if (config.request_jitter_max_ms > 0) {
                       const jitterMs = Math.floor(Math.random() * config.request_jitter_max_ms);
                       if (jitterMs > 0) {