Cherry‑pick PRs NoeFabris#476, NoeFabris#465, NoeFabris#460 and address review issues

- PR NoeFabris#476: guard isOAuthAuth against undefined/null (auth.ts)
- PR NoeFabris#465: use ensureProjectContext for google_search project‑ID resolution
- PR NoeFabris#460: throttle excessive file writes from account state updates
- Fix abort‑during‑cooldown error‑escape (wrap all  calls)
- Remove stale THINKING_RECOVERY_NEEDED sentinel branch
- Change abort status from HTTP 499 to standard 408 (Request Timeout)
- All tests pass, type‑check clean

Author: Lonny Jepson

src/plugin.ts

@@ -1185,10 +1185,19 @@ describe("AccountManager", () => {
 
       it("parses RATE_LIMIT_EXCEEDED from reason field", () => {
         expect(parseRateLimitReason("RATE_LIMIT_EXCEEDED", undefined)).toBe("RATE_LIMIT_EXCEEDED");
+        expect(parseRateLimitReason("TOO_MANY_REQUESTS", undefined)).toBe("RATE_LIMIT_EXCEEDED");
+        expect(parseRateLimitReason("RATE_LIMITED", undefined)).toBe("RATE_LIMIT_EXCEEDED");
       });
 
       it("parses MODEL_CAPACITY_EXHAUSTED from reason field", () => {
         expect(parseRateLimitReason("MODEL_CAPACITY_EXHAUSTED", undefined)).toBe("MODEL_CAPACITY_EXHAUSTED");
+        expect(parseRateLimitReason("RESOURCE_EXHAUSTED", undefined)).toBe("MODEL_CAPACITY_EXHAUSTED");
+      });
+
+      it("parses server errors from reason/status field", () => {
+        expect(parseRateLimitReason("UNAVAILABLE", undefined)).toBe("SERVER_ERROR");
+        expect(parseRateLimitReason("SERVICE_UNAVAILABLE", undefined)).toBe("SERVER_ERROR");
+        expect(parseRateLimitReason("INTERNAL", undefined)).toBe("SERVER_ERROR");
       });
 
       it("falls back to message parsing when reason is absent", () => {

src/plugin/accounts.test.ts

@@ -58,7 +58,14 @@ export function parseRateLimitReason(
     switch (reason.toUpperCase()) {
       case "QUOTA_EXHAUSTED": return "QUOTA_EXHAUSTED";
       case "RATE_LIMIT_EXCEEDED": return "RATE_LIMIT_EXCEEDED";
+      case "TOO_MANY_REQUESTS": return "RATE_LIMIT_EXCEEDED";
+      case "RATE_LIMITED": return "RATE_LIMIT_EXCEEDED";
       case "MODEL_CAPACITY_EXHAUSTED": return "MODEL_CAPACITY_EXHAUSTED";
+      case "RESOURCE_EXHAUSTED": return "MODEL_CAPACITY_EXHAUSTED";
+      case "UNAVAILABLE": return "SERVER_ERROR";
+      case "SERVICE_UNAVAILABLE": return "SERVER_ERROR";
+      case "INTERNAL": return "SERVER_ERROR";
+      case "INTERNAL_ERROR": return "SERVER_ERROR";
     }
   }
 
@@ -67,17 +74,36 @@ export function parseRateLimitReason(
     const lower = message.toLowerCase();
 
     // Capacity / Overloaded (Transient) - Check FIRST before "exhausted"
-    if (lower.includes("capacity") || lower.includes("overloaded") || lower.includes("resource exhausted")) {
+    if (
+      lower.includes("capacity") ||
+      lower.includes("overloaded") ||
+      lower.includes("resource exhausted") ||
+      lower.includes("resource_exhausted")
+    ) {
       return "MODEL_CAPACITY_EXHAUSTED";
     }
 
     // RPM / TPM (Short Wait)
     // "per minute", "rate limit", "too many requests"
     // "presque" (French: almost) - retained for i18n parity with Rust reference
-    if (lower.includes("per minute") || lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("presque")) {
+    if (
+      lower.includes("per minute") ||
+      lower.includes("rate limit") ||
+      lower.includes("too many requests") ||
+      lower.includes("rate_limited") ||
+      lower.includes("presque")
+    ) {
       return "RATE_LIMIT_EXCEEDED";
     }
 
+    if (
+      lower.includes("service unavailable") ||
+      lower.includes("temporarily unavailable") ||
+      lower.includes("internal error")
+    ) {
+      return "SERVER_ERROR";
+    }
+
     // Quota (Long Wait)
     if (lower.includes("exhausted") || lower.includes("quota")) {
       return "QUOTA_EXHAUSTED";

src/plugin/accounts.ts

@@ -21,6 +21,14 @@ describe("isOAuthAuth", () => {
     };
     expect(isOAuthAuth(auth)).toBe(false);
   });
+
+  it("returns false for undefined auth", () => {
+    expect(isOAuthAuth(undefined as any)).toBe(false);
+  });
+
+  it("returns false for null auth", () => {
+    expect(isOAuthAuth(null as any)).toBe(false);
+  });
 });
 
 describe("parseRefreshParts", () => {

src/plugin/auth.test.ts

@@ -2,8 +2,8 @@ import type { AuthDetails, OAuthAuthDetails, RefreshParts } from "./types";
 
 const ACCESS_TOKEN_EXPIRY_BUFFER_MS = 60 * 1000;
 
-export function isOAuthAuth(auth: AuthDetails): auth is OAuthAuthDetails {
-  return auth.type === "oauth";
+export function isOAuthAuth(auth: AuthDetails | null | undefined): auth is OAuthAuthDetails {
+  return !!auth && auth.type === "oauth";
 }
 
 /**

src/plugin/auth.ts

@@ -940,35 +940,66 @@ it("removes x-api-key header", () => {
       );
 
       await expect(transformed.text()).resolves.toContain("Request contains an invalid argument.");
+      expect(transformed.headers.get("x-antigravity-recovery-needed")).toBeNull();
     });
 
-    it("rethrows THINKING_RECOVERY_NEEDED for outer retry handling", async () => {
+    it("extracts fallback message from error.status when error.message is missing", async () => {
       const response = new Response(
         JSON.stringify({
           error: {
-            code: 400,
-            message: "Thinking must start with a thinking block before tool use.",
             status: "INVALID_ARGUMENT",
+            details: [{ "@type": "type.googleapis.com/google.rpc.BadRequest" }],
           },
         }),
         {
           status: 400,
-          headers: { "content-type": "application/json" },
+          headers: { "Content-Type": "application/json" },
         },
       );
 
-      await expect(
-        transformAntigravityResponse(
-          response,
-          true,
-          undefined,
-          "antigravity-claude-opus-4-6-thinking",
-          "test-project",
-          "https://daily-cloudcode-pa.sandbox.googleapis.com/v1internal:streamGenerateContent?alt=sse",
-          "claude-opus-4-6-thinking",
-          "session-1",
-        ),
-      ).rejects.toMatchObject({ message: "THINKING_RECOVERY_NEEDED" });
+      const transformed = await transformAntigravityResponse(response, false);
+      const body = await transformed.json() as any;
+
+      expect(transformed.status).toBe(400);
+      expect(body.error.message).toContain("INVALID_ARGUMENT");
+    });
+
+    it("handles batch-style error.errors[] fallback when message is missing", async () => {
+      const response = new Response(
+        JSON.stringify({
+          error: {
+            errors: [{ status: "RESOURCE_EXHAUSTED" }],
+          },
+        }),
+        {
+          status: 429,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+
+      const transformed = await transformAntigravityResponse(response, false);
+      const body = await transformed.json() as any;
+
+      expect(transformed.status).toBe(429);
+      expect(body.error.message).toContain("RESOURCE_EXHAUSTED");
+    });
+
+    it("signals thinking recovery with a response header instead of throwing", async () => {
+      const response = new Response(
+        JSON.stringify({
+          error: {
+            status: "INVALID_ARGUMENT",
+            details: [{ reason: "thinking must start with first block" }],
+          },
+        }),
+        {
+          status: 400,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+
+      const transformed = await transformAntigravityResponse(response, false);
+      expect(transformed.headers.get("x-antigravity-recovery-needed")).toBe("thinking_block_order");
     });
   });
 });

src/plugin/request.test.ts

@@ -827,11 +827,9 @@ export function prepareAntigravityRequest(
           // Use stable session ID for signature caching across multi-turn conversations
           (req as any).sessionId = signatureSessionKey;
           stripInjectedDebugFromRequestPayload(req as Record<string, unknown>);
+          sanitizeCrossModelPayloadInPlace(req, { targetModel: effectiveModel });
 
           if (isClaude) {
-            // Step 0: Sanitize cross-model metadata (strips Gemini signatures when sending to Claude)
-            sanitizeCrossModelPayloadInPlace(req, { targetModel: effectiveModel });
-
             // Step 1: Strip corrupted/unsigned thinking blocks FIRST
             deepFilterThinkingBlocks(req, signatureSessionKey, getCachedSignature, true);
 
@@ -1270,10 +1268,8 @@ export function prepareAntigravityRequest(
         // For Claude models, filter out unsigned thinking blocks (required by Claude API)
         // Attempts to restore signatures from cache for multi-turn conversations
         // Handle both Gemini-style contents[] and Anthropic-style messages[] payloads.
+        sanitizeCrossModelPayloadInPlace(requestPayload, { targetModel: effectiveModel });
         if (isClaude) {
-          // Step 0: Sanitize cross-model metadata (strips Gemini signatures when sending to Claude)
-          sanitizeCrossModelPayloadInPlace(requestPayload, { targetModel: effectiveModel });
-
           // Step 1: Strip corrupted/unsigned thinking blocks FIRST
           deepFilterThinkingBlocks(requestPayload, signatureSessionKey, getCachedSignature, true);
 
@@ -1588,6 +1584,49 @@ export async function transformAntigravityResponse(
   toolDebugPayload?: string,
   debugLines?: string[],
 ): Promise<Response> {
+  const extractBestErrorMessage = (errorValue: unknown): string => {
+    if (!errorValue || typeof errorValue !== "object") {
+      return "";
+    }
+
+    const errorObj = errorValue as Record<string, unknown>;
+    if (typeof errorObj.message === "string" && errorObj.message.trim()) {
+      return errorObj.message;
+    }
+    if (typeof errorObj.status === "string" && errorObj.status.trim()) {
+      return errorObj.status;
+    }
+
+    if (Array.isArray(errorObj.details) && errorObj.details.length > 0) {
+      const firstDetail = errorObj.details[0];
+      if (firstDetail && typeof firstDetail === "object") {
+        const detailRecord = firstDetail as Record<string, unknown>;
+        if (typeof detailRecord.reason === "string" && detailRecord.reason.trim()) {
+          return detailRecord.reason;
+        }
+      }
+    }
+
+    if (Array.isArray(errorObj.errors) && errorObj.errors.length > 0) {
+      const firstBatchError = errorObj.errors[0];
+      if (firstBatchError && typeof firstBatchError === "object") {
+        const batchRecord = firstBatchError as Record<string, unknown>;
+        if (typeof batchRecord.message === "string" && batchRecord.message.trim()) {
+          return batchRecord.message;
+        }
+        if (typeof batchRecord.status === "string" && batchRecord.status.trim()) {
+          return batchRecord.status;
+        }
+      }
+    }
+
+    try {
+      return JSON.stringify(errorObj);
+    } catch {
+      return "";
+    }
+  };
+
   const contentType = response.headers.get("content-type") ?? "";
   const isJsonResponse = contentType.includes("application/json");
   const isEventStreamResponse = contentType.includes("text/event-stream");
@@ -1651,31 +1690,67 @@ export async function transformAntigravityResponse(
     const text = await response.text();
 
     if (!response.ok) {
-      let errorBody;
+      let errorBody: any;
       try {
         errorBody = JSON.parse(text);
       } catch {
         errorBody = { error: { message: text } };
       }
 
+      if (!errorBody || typeof errorBody !== "object") {
+        errorBody = { error: { message: String(errorBody ?? text) } };
+      }
+
+      if (!errorBody.error || typeof errorBody.error !== "object") {
+        errorBody.error = {
+          message: typeof errorBody.message === "string" ? errorBody.message : undefined,
+          status: typeof errorBody.status === "string" ? errorBody.status : undefined,
+          details: Array.isArray(errorBody.details) ? errorBody.details : undefined,
+          errors: Array.isArray(errorBody.errors) ? errorBody.errors : undefined,
+        };
+      }
+
+      // Extract retry headers from google.rpc.RetryInfo when present.
+      if (Array.isArray(errorBody?.error?.details)) {
+        const retryInfo = errorBody.error.details.find(
+          (detail: any) => detail?.["@type"] === "type.googleapis.com/google.rpc.RetryInfo",
+        );
+
+        if (retryInfo?.retryDelay) {
+          const match = retryInfo.retryDelay.match(/^([\d.]+)s$/);
+          if (match && match[1]) {
+            const retrySeconds = parseFloat(match[1]);
+            if (!isNaN(retrySeconds) && retrySeconds > 0) {
+              const retryAfterSec = Math.ceil(retrySeconds).toString();
+              const retryAfterMs = Math.ceil(retrySeconds * 1000).toString();
+              headers.set("Retry-After", retryAfterSec);
+              headers.set("retry-after-ms", retryAfterMs);
+            }
+          }
+        }
+      }
+
       // Inject Debug Info
       if (errorBody?.error) {
-        const rawErrorMessage =
-          typeof errorBody.error.message === "string" && errorBody.error.message.length > 0
-            ? errorBody.error.message
-            : "Unknown error";
-        const errorType = detectErrorType(rawErrorMessage);
+        const extractedMessage = extractBestErrorMessage(errorBody.error) || "Unknown error";
         const debugInfo = `\n\n[Debug Info]\nRequested Model: ${requestedModel || "Unknown"}\nEffective Model: ${effectiveModel || "Unknown"}\nProject: ${projectId || "Unknown"}\nEndpoint: ${endpoint || "Unknown"}\nStatus: ${response.status}\nRequest ID: ${headers.get("x-request-id") || "N/A"}${toolDebugMissing !== undefined ? `\nTool Debug Missing: ${toolDebugMissing}` : ""}${toolDebugSummary ? `\nTool Debug Summary: ${toolDebugSummary}` : ""}${toolDebugPayload ? `\nTool Debug Payload: ${toolDebugPayload}` : ""}`;
         const injectedDebug = debugText ? `\n\n${debugText}` : "";
-        errorBody.error.message = rawErrorMessage + debugInfo + injectedDebug;
-
-        // Check if this is a recoverable thinking error - throw to trigger retry
+        errorBody.error.message = extractedMessage + debugInfo + injectedDebug;
+
+        // Signal recoverable thinking errors via headers so caller can retry without throwing.
+        const firstDetailReason =
+          Array.isArray(errorBody?.error?.details) &&
+          errorBody.error.details[0] &&
+          typeof errorBody.error.details[0] === "object"
+            ? ((errorBody.error.details[0] as Record<string, unknown>).reason as string | undefined)
+            : undefined;
+        const errorType = detectErrorType(
+          [extractedMessage, typeof firstDetailReason === "string" ? firstDetailReason : ""]
+            .filter(Boolean)
+            .join(" "),
+        );
         if (errorType === "thinking_block_order") {
-          const recoveryError = new Error("THINKING_RECOVERY_NEEDED");
-          (recoveryError as any).recoveryType = errorType;
-          (recoveryError as any).originalError = errorBody;
-          (recoveryError as any).debugInfo = debugInfo;
-          throw recoveryError;
+          headers.set("x-antigravity-recovery-needed", errorType);
         }
 
         // Detect context length / prompt too long errors - signal to caller for toast
@@ -1704,25 +1779,6 @@ export async function transformAntigravityResponse(
           headers
         });
       }
-
-      if (errorBody?.error?.details && Array.isArray(errorBody.error.details)) {
-        const retryInfo = errorBody.error.details.find(
-          (detail: any) => detail['@type'] === 'type.googleapis.com/google.rpc.RetryInfo'
-        );
-
-        if (retryInfo?.retryDelay) {
-          const match = retryInfo.retryDelay.match(/^([\d.]+)s$/);
-          if (match && match[1]) {
-            const retrySeconds = parseFloat(match[1]);
-            if (!isNaN(retrySeconds) && retrySeconds > 0) {
-              const retryAfterSec = Math.ceil(retrySeconds).toString();
-              const retryAfterMs = Math.ceil(retrySeconds * 1000).toString();
-              headers.set('Retry-After', retryAfterSec);
-              headers.set('retry-after-ms', retryAfterMs);
-            }
-          }
-        }
-      }
     }
 
     const init = {