fix(antigravity): retry transient upstream failures

[diegosouzapw]

What

Ports three improvements to the Antigravity executor from an upstream fix.

Slice 1 — Transient 5xx retry

Adds ANTIGRAVITY_TRANSIENT_ERROR_PATTERNS (regex array) and ANTIGRAVITY_TRANSIENT_STATUSES (500/502/503/504 set) plus two new public methods:

• extractErrorMessage(errorJson, bodyText) — flattens various JSON shapes into a single string for pattern matching
• isTransientAntigravityError(status, message) — returns true for 429, any transient 5xx status, or body matching a known infra-hiccup pattern ("Agent execution terminated due to error", "high traffic", "capacity", "temporarily unavailable", …)

The intra-request auto-retry block (previously 429-only) is extended to call isTransientAntigravityError for any response that hasn't already been handled. Transient 5xx uses a 15 s cap (ANTIGRAVITY_TRANSIENT_RETRY_MAX_MS) instead of the 60 s cap used for 429, keeping stall time bounded.

Slice 2 — Equivalent of upstream per-status "500": { attempts: 3 }

OmniRoute TS does not have a per-status registry config; retries are handled inline. The existing MAX_AUTO_RETRIES = 3 constant now applies to transient 5xx through Slice 1's extended condition — functionally equivalent to the upstream change.

Slice 3 — Tool-name deduplication in buildGeminiTools

Adds a seenToolNames: Set<string> inside buildGeminiTools (geminiToolsSanitizer.ts). After sanitization, any declaration whose sanitized name was already emitted is silently dropped. Prevents Gemini API rejections caused by duplicate functionDeclaration names (same raw name repeated across tool groups, or two names that collapse to the same sanitized form).

Tests

14 new unit tests in tests/unit/antigravity-retry-hook.test.ts (TDD — all confirmed failing before implementation, all green after):

• isTransientAntigravityError: 503 transient, 500 + body patterns (agent terminated, high traffic, capacity), 400 veto, 404 veto, 429/502/504 transient
• extractErrorMessage: standard error.message shape, top-level message, raw body text fallback
• buildGeminiTools dedup: identical raw name (→ same sanitized) deduplicated to one; distinct names both kept

Validation

npm run typecheck:core     → PASS (0 errors)
npx eslint <touched files> → PASS (0 warnings)
npm run check:cycles       → PASS
node --import tsx/esm --test tests/unit/antigravity-retry-hook.test.ts → 14/14 PASS
pre-commit hooks           → PASS
pre-push hooks             → PASS

Attribution

@Jordannst

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[gemini-code-assist]

Code Review

This pull request introduces transient retry logic for upstream 5xx errors in the Antigravity executor by checking error messages against known patterns, and adds tool-name deduplication to prevent Gemini rejection. The review feedback highlights a critical logic bug in isTransientAntigravityError where pattern matching is bypassed because all transient statuses immediately return true, and suggests optimizing the retry loop to avoid unnecessary response cloning for inherently transient statuses (502, 503, 504). Additionally, it recommends adding a unit test to verify that non-matching 500 errors are correctly classified as non-transient.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

The current implementation of isTransientAntigravityError contains a logic bug where any status in ANTIGRAVITY_TRANSIENT_STATUSES (which includes 500, 502, 503, and 504) immediately returns true on line 996. Because executeOnce only calls this method for statuses in ANTIGRAVITY_TRANSIENT_STATUSES (or 429), the pattern matching on line 997 is completely bypassed and acts as dead code. This causes all 500 errors (including non-transient ones like invalid model IDs or bad requests) to be unconditionally retried, leading to unnecessary delays and violating the goal of keeping stall times bounded.

To fix this, 502, 503, and 504 should return true immediately, while 500 (HTTP_STATUS.SERVER_ERROR) should be checked against ANTIGRAVITY_TRANSIENT_ERROR_PATTERNS.

  isTransientAntigravityError(status: number, message: string): boolean {
    if (status === HTTP_STATUS.RATE_LIMITED) return true;
    if (
      status === HTTP_STATUS.BAD_GATEWAY ||
      status === HTTP_STATUS.SERVICE_UNAVAILABLE ||
      status === HTTP_STATUS.GATEWAY_TIMEOUT
    ) {
      return true;
    }
    if (status === HTTP_STATUS.SERVER_ERROR) {
      return ANTIGRAVITY_TRANSIENT_ERROR_PATTERNS.some((p) => p.test(message || ""));
    }
    return false;
  }

[gemini-code-assist]

For inherently transient statuses like 502, 503, and 504, we can avoid the performance overhead of cloning the response and reading/parsing the body text asynchronously. We can initialize shouldAutoRetry to true for these statuses immediately, and only perform the asynchronous body read and pattern matching for 500 (HTTP_STATUS.SERVER_ERROR) responses.

            let shouldAutoRetry =
              response.status === HTTP_STATUS.RATE_LIMITED ||
              response.status === HTTP_STATUS.BAD_GATEWAY ||
              response.status === HTTP_STATUS.SERVICE_UNAVAILABLE ||
              response.status === HTTP_STATUS.GATEWAY_TIMEOUT;
            if (!shouldAutoRetry && response.status === HTTP_STATUS.SERVER_ERROR) {

[gemini-code-assist]

Add a test case to verify that a 500 status with a non-matching error message correctly returns false (is not treated as transient). This ensures that pattern matching is actually enforced and non-transient 500 errors are not incorrectly retried.

Suggested change

	test("isTransientAntigravityError: 500 + 'some non-matching error' body → false", () => {
	const ex = new AntigravityExecutor();
	assert.equal(ex.isTransientAntigravityError(500, "some non-matching error"), false);
	});