[dhaern]

Summary

• Align Antigravity and Agy public model tiers to the clean Low / Medium / High names.
• Normalize Provider Limits to prefer live quota buckets, reconcile legacy IDs, and refresh after real Antigravity/Agy usage.
• Fix reasoning text leakage by extracting malformed/open reasoning wrappers into reasoning_content instead of visible assistant text.
• Preserve tool calls and textual tool-call translation behavior.

Scope

• Antigravity/Agy model aliases and visible labels
• Provider quota parsing, normalization and refresh
• Reasoning text sanitization and Gemini->OpenAI translation

Validation

• bun test tests/unit/response-sanitizer.test.ts
• bun test tests/unit/translator-resp-gemini-to-openai.test.ts
• bun test tests/unit/usage-service-hardening.test.ts

Notes

• The reasoning-text fix is generic for think/thinking/thought/internal_thought wrappers, not a hardcoded one-off.
• This PR does not touch OpenCode.

[gemini-code-assist]

Code Review

This pull request updates the Antigravity and agy model catalogs to expose clean Gemini 3.5 Flash tiers (Low, Medium, High) and maps them to legacy upstream IDs. It also improves quota tracking by integrating the retrieveUserQuota endpoint with a local usage fallback, and enhances streaming response sanitization to extract unclosed reasoning tags. The code review provides valuable feedback, pointing out that reasoning tags spanning multiple chunks can leak into user-visible content, SQL token summation can fail due to NULL values, sequential quota fetches should be parallelized to reduce latency, and the agy provider is missing from the cache refresh check.

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]

During streaming, reasoning tags almost always span multiple chunks. Since splitReasoningTagText treats any tag without a closing tag in the same chunk as an unclosed tag, it will immediately emit the partial text as reasoning_content and clear state.textualToolCallBuffer. In the next chunk, the rest of the reasoning text (and the closing tag) will arrive without an opening tag, causing it to bypass the reasoning filter and leak directly into the user-visible content as regular text.

To fix this, we should track whether we are currently inside a reasoning block using a state variable (e.g., state.inReasoning) so that reasoning content can be streamed across multiple chunks until the closing tag is encountered.

        while (accumulated) {
          if (state.inReasoning) {
            const closeMatch = /<\/(?:think|thinking|thought|internal_thought)>/i.exec(accumulated);
            if (closeMatch) {
              const reasoningText = accumulated.slice(0, closeMatch.index);
              if (reasoningText) {
                emitTextDelta(reasoningText, state, results, "reasoning_content");
              }
              state.inReasoning = false;
              accumulated = accumulated.slice(closeMatch.index + closeMatch[0].length);
            } else {
              emitTextDelta(accumulated, state, results, "reasoning_content");
              accumulated = "";
            }
          } else {
            const openMatch = REASONING_TAG_OPEN_REGEX.exec(accumulated);
            if (openMatch) {
              const beforeText = accumulated.slice(0, openMatch.index);
              if (beforeText && !isIgnorableReasoningTagPrefix(beforeText)) {
                emitTextDelta(beforeText, state, results, "content");
              }
              state.inReasoning = true;
              accumulated = accumulated.slice(openMatch.index + openMatch[0].length);
            } else {
              break;
            }
          }
        }
        if (!accumulated) {
          continue;
        }

[gemini-code-assist]

In SQL, adding a NULL value to any other value results in NULL (e.g., 100 + NULL is NULL). If tokens_reasoning (or any other token column) is NULL for a row in usage_history, the entire addition tokens_input + tokens_output + tokens_reasoning will evaluate to NULL. This causes those rows to be completely excluded from the sum, leading to incorrect local usage tracking.

To prevent this, use COALESCE on each individual column before performing the addition.

Suggested change

	`SELECT COALESCE(SUM(tokens_input + tokens_output + tokens_reasoning), 0) AS tokens
	`SELECT COALESCE(SUM(COALESCE(tokens_input, 0) + COALESCE(tokens_output, 0) + COALESCE(tokens_reasoning, 0)), 0) AS tokens

[gemini-code-assist]

The network requests to fetch available models and user quotas are independent of each other. Awaiting them sequentially introduces unnecessary latency (head-of-line blocking). They should be fetched in parallel using Promise.all to improve performance.

    const [data, userQuotaData] = await Promise.all([
      fetchAntigravityAvailableModelsCached(accessToken, projectId, options),
      fetchAntigravityUserQuotaCached(accessToken, projectId, options),
    ]);

[gemini-code-assist]

The "agy" provider is the CLI companion to Antigravity and shares the same backend, executor, and quota logic. However, it is missing from the provider check in shouldRefreshProviderLimitsCache, which means "agy" connections will not trigger automatic cache refreshes when user-quota sources are missing or legacy keys are present.

Add "agy" to the provider check to ensure consistent behavior.

Suggested change

	if (connection.provider !== "antigravity") return false;
	if (connection.provider !== "antigravity" && connection.provider !== "agy") return false;

[dhaern]

@gemini-code-assist[bot] Gracias por la revisión. He corregido los 4 puntos:

1. El cálculo SQL de uso local ahora usa COALESCE por columna para no perder filas con valores NULL.
2. La obtención de fetchAvailableModels y retrieveUserQuota ahora va en paralelo con Promise.all.
3. agy entra en la lógica de refresh de Provider Limits cuando faltan fuentes live o hay claves legacy.
4. El traductor Gemini/OpenAI ahora mantiene reasoning textual abierto entre chunks sin filtrarlo a content, y lo cierra correctamente al llegar el tag final.

Validado con tests focalizados verdes.

[gemini-code-assist]

¡Excelente trabajo con estas correcciones, @dhaern! La implementación de COALESCE para la robustez de los datos, el uso de Promise.all para la concurrencia en la obtención de cuotas, la lógica de refresco para Provider Limits y la mejora en el manejo de los tags de razonamiento en el traductor son cambios muy sólidos y bien estructurados.

He verificado los cambios y la lógica parece correcta y alineada con las mejores prácticas. ¡Buen trabajo manteniendo los tests focalizados y pasando!

[diegosouzapw]

Thanks for this, @dhaern — the Antigravity/Agy tier alignment (Low/Medium/High), the live-quota Provider Limits normalization, and especially the generic reasoning-wrapper extraction into reasoning_content are all valuable, and the test coverage (13 test files) is appreciated. 🙏

Before we can merge it, two things need addressing:

1. Conflicts in the Gemini translator hot-path (blocking). This PR conflicts with release/v3.8.21 in open-sse/translator/request/openai-to-gemini.ts and open-sse/translator/response/gemini-to-openai.ts. Those two files were just rewritten in v3.8.20 by #3569: standard Gemini now sends native function calls without a thoughtSignature (validated against the live Gemini API — gemini-2.5-flash:generateContent returns 200 for signatureless historical functionCall, even with tools + thinkingConfig). The previous assumption that standard Gemini rejects signatureless native parts is no longer true. Resolving the conflict incorrectly would silently regress #3569, so could you rebase onto release/v3.8.21 and reconcile against the new behavior? The intended end state is: standard Gemini = native (no sentinel), CLI/Antigravity = skip_thought_signature_validator sentinel bypass.

2. Please split the 4 concerns. This bundles (a) tier renaming, (b) Provider Limits quota normalization, (c) reasoning-text leak fix, and (d) tool-call translation. Splitting them into focused PRs lets us review and validate each independently (the reasoning-leak fix in particular touches the same translator the rebase above affects).

Once rebased (and ideally split), we'll get it in. Leaving this open — not closing. Thanks again!

[dhaern]

Thanks for the review. I split the original #3584 work and rebased the pieces onto release/v3.8.21 as requested.

New focused PRs:

1. fix(antigravity): normalize Gemini 3.5 Flash tier IDs #3603 — Antigravity/agy Gemini 3.5 Flash tier IDs and executor-side alias normalization.

   • Keeps only catalog/model-id/routing changes.
   • Validation: 26 focused tests passing locally.

2. fix(usage): normalize Antigravity and agy provider quotas #3604 — Antigravity/agy Provider Quota normalization and refresh behavior.

   • Depends on fix(antigravity): normalize Gemini 3.5 Flash tier IDs #3603 because it normalizes quota buckets to the same clean public IDs.
   • Validation: 36 focused tests passing locally.
   • Note: GitHub does not allow using a fork-only branch as the upstream PR base, so this is opened against release/v3.8.21; after fix(antigravity): normalize Gemini 3.5 Flash tier IDs #3603 lands, it can be rebased so the diff is quota-only.

3. fix(gemini): isolate textual reasoning wrappers #3605 — Gemini textual reasoning wrapper isolation.

   • Keeps only the sanitizer/streaming translator work for <think>/<thinking>/<thought>/<internal_thought> wrappers.
   • Preserves the current v3.8.21 Gemini tool-call hot path and does not revert the scoped signature-bypass behavior.
   • Validation: 55 focused tests passing locally.

I also tested the combined stack locally on v3.8.21 with omniroute-install-local-build --restart before opening the split PRs.

[diegosouzapw]

Superseded by the clean split you opened — #3603 (tier IDs), #3604 (provider quotas), and #3605 (reasoning wrappers) — all three merged into release/v3.8.21. Thanks for rebasing and splitting per the earlier review feedback! Leaving this open for you to close at your convenience (so you keep ownership), since the work landed via the split PRs.