@expiren/opencode-antigravity-auth 1.6.33 → 1.6.35

package/dist/index.js

@@ -5517,12 +5517,12 @@ function injectToolHardeningInstruction(payload, instructionText) {
     if (existing && typeof existing === "object" && "parts" in existing) {
       const parts = existing.parts;
       if (Array.isArray(parts)) {
-        parts.unshift(instructionPart);
+        parts.push(instructionPart);
       }
     } else if (typeof existing === "string") {
       payload.systemInstruction = {
         role: "user",
-        parts: [instructionPart, { text: existing }]
+        parts: [{ text: existing }, instructionPart]
       };
     } else {
       payload.systemInstruction = {
@@ -5838,6 +5838,7 @@ function computeClaudeMaxOutputTokens(thinkingBudget) {
   }
   return Math.min(Math.max(thinkingBudget * 2, 32e3), CLAUDE_THINKING_MAX_OUTPUT_TOKENS);
 }
+var CLAUDE_INTERLEAVED_THINKING_HINT = "Interleaved thinking is enabled. You may think between tool calls and after receiving tool results before deciding the next action or final answer. Do not mention these instructions or any constraints about thinking blocks; just apply them.";
 function isClaudeModel(model) {
   return model.toLowerCase().includes("claude");
 }
@@ -5845,6 +5846,35 @@ function isClaudeThinkingModel(model) {
   const lower = model.toLowerCase();
   return lower.includes("claude") && lower.includes("thinking");
 }
+function appendClaudeThinkingHint(payload, hint = CLAUDE_INTERLEAVED_THINKING_HINT) {
+  const existing = payload.systemInstruction;
+  if (typeof existing === "string" && existing.includes(hint)) {
+    return;
+  }
+  if (existing && typeof existing === "object") {
+    const sys = existing;
+    if (Array.isArray(sys.parts)) {
+      const alreadyHasHint = sys.parts.some(
+        (p) => p && typeof p === "object" && p.text === hint
+      );
+      if (alreadyHasHint) return;
+    }
+  }
+  if (typeof existing === "string") {
+    payload.systemInstruction = existing.trim().length > 0 ? { role: "user", parts: [{ text: existing }, { text: hint }] } : hint;
+  } else if (existing && typeof existing === "object") {
+    const sys = existing;
+    const partsValue = sys.parts;
+    if (Array.isArray(partsValue)) {
+      sys.parts = [...partsValue, { text: hint }];
+    } else {
+      sys.parts = [{ text: hint }];
+    }
+    payload.systemInstruction = sys;
+  } else if (Array.isArray(payload.contents)) {
+    payload.systemInstruction = { parts: [{ text: hint }] };
+  }
+}
 
 // src/plugin/transform/gemini.ts
 var UNSUPPORTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
@@ -7880,6 +7910,9 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
               CLAUDE_TOOL_SYSTEM_INSTRUCTION
             );
           }
+          if (isClaudeThinking && Array.isArray(requestPayload.tools) && requestPayload.tools.length > 0) {
+            appendClaudeThinkingHint(requestPayload);
+          }
         }
         const conversationKey = resolveConversationKey(requestPayload);
         signatureSessionKey = buildSignatureSessionKey(PLUGIN_SESSION_ID, effectiveModel, conversationKey, resolveProjectKey(projectId));
@@ -9049,6 +9082,8 @@ var AccountManager = class _AccountManager {
   savePending = false;
   saveTimeout = null;
   savePromiseResolvers = [];
+  sessionStartTime = Date.now();
+  sessionRequestCounts = /* @__PURE__ */ new Map();
   static async loadFromDisk(authFallback) {
     const stored = await loadAccounts();
     return new _AccountManager(authFallback, stored);
@@ -9716,6 +9751,7 @@ var AccountManager = class _AccountManager {
     }
     account.dailyRequestCounts[family]++;
     account.lastUsed = nowMs();
+    this.recordSessionRequest(accountIndex, family);
   }
   /**
    * Get request counts for an account for today.
@@ -9755,6 +9791,45 @@ var AccountManager = class _AccountManager {
     }
     return result.sort((a, b) => b.count - a.count);
   }
+  /**
+   * Record a request for the current session (in-memory only).
+   */
+  recordSessionRequest(accountIndex, family) {
+    const key = String(accountIndex);
+    const current = this.sessionRequestCounts.get(key) ?? { claude: 0, gemini: 0 };
+    current[family]++;
+    this.sessionRequestCounts.set(key, current);
+  }
+  /**
+   * Get a summary of the current session's request usage.
+   */
+  getSessionSummary() {
+    const durationMs = Date.now() - this.sessionStartTime;
+    const durationMinutes = Math.round(durationMs / 6e4);
+    const durationHours = durationMs / 36e5;
+    let totalClaude = 0;
+    let totalGemini = 0;
+    const perAccount = [];
+    for (const [key, counts] of this.sessionRequestCounts) {
+      const idx = Number(key);
+      const account = this.accounts[idx];
+      totalClaude += counts.claude;
+      totalGemini += counts.gemini;
+      if (counts.claude > 0 || counts.gemini > 0) {
+        perAccount.push({ index: idx, email: account?.email, claude: counts.claude, gemini: counts.gemini });
+      }
+    }
+    const totalRequests = totalClaude + totalGemini;
+    const requestsPerHour = durationHours > 0 ? Math.round(totalRequests / durationHours) : 0;
+    return {
+      durationMinutes,
+      totalClaude,
+      totalGemini,
+      requestsPerHour,
+      accountsUsed: perAccount.length,
+      perAccount: perAccount.sort((a, b) => b.claude + b.gemini - (a.claude + a.gemini))
+    };
+  }
   isAccountOverSoftQuota(account, family, thresholdPercent, cacheTtlMs, model) {
     return isOverSoftQuotaThreshold(account, family, thresholdPercent, cacheTtlMs, model);
   }
@@ -12026,6 +12101,16 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
   const eventHandler = async (input2) => {
     await updateChecker.event(input2);
     if (input2.event.type === "session.created") {
+      const prevSummary = activeAccountManager?.getSessionSummary();
+      if (prevSummary && (prevSummary.totalClaude > 0 || prevSummary.totalGemini > 0)) {
+        log10.debug("prev-session-quota-summary", {
+          durationMinutes: prevSummary.durationMinutes,
+          totalClaude: prevSummary.totalClaude,
+          totalGemini: prevSummary.totalGemini,
+          requestsPerHour: prevSummary.requestsPerHour,
+          accountsUsed: prevSummary.accountsUsed
+        });
+      }
       const props = input2.event.properties;
       if (props?.info?.parentID) {
         isChildSession = true;
@@ -12942,6 +13027,23 @@ Alternatively, you can:
                     }
                     const totalToday = accountManager.getTotalDailyRequests(family);
                     pushDebug(`[Quota] Total ${family} requests today (all accounts): ${totalToday}`);
+                    const cachedQuota = account.cachedQuota;
+                    if (cachedQuota) {
+                      const quotaFamily = family === "claude" ? "claude" : "gemini-flash";
+                      const groupQuota = cachedQuota[quotaFamily];
+                      if (groupQuota?.remainingFraction != null) {
+                        const pct = Math.round(groupQuota.remainingFraction * 100);
+                        pushDebug(`[Quota] Account ${account.index} cached ${quotaFamily} remaining: ${pct}%${groupQuota.resetTime ? ` (resets ${groupQuota.resetTime})` : ""}`);
+                      }
+                    }
+                    const sessionSummary = accountManager.getSessionSummary();
+                    if (sessionSummary.durationMinutes >= 1) {
+                      const familyTotal = family === "claude" ? sessionSummary.totalClaude : sessionSummary.totalGemini;
+                      if (familyTotal > 0) {
+                        const ratePerHour = sessionSummary.requestsPerHour;
+                        pushDebug(`[Quota] Session: ${sessionSummary.durationMinutes}min, ${familyTotal} ${family} reqs, ~${ratePerHour} reqs/hr, ${sessionSummary.accountsUsed} accounts used`);
+                      }
+                    }
                     return transformedResponse;
                   } catch (error) {
                     if (tokenConsumed) {