mixdog 1.3.3 → 1.3.5

package/src/runtime/agent/orchestrator/providers/account-pool.mjs

@@ -9,11 +9,14 @@ import {
   providerAccountExhaustedForModelOnly,
   providerAccountPolicy,
   providerAccountsResetAt,
+  providerAccountWithBlocks,
+  providerAccountBlockedUntil,
+  staleQuotaWindows,
 } from '../../../shared/provider-accounts.mjs';
 import { withProviderAccount, hasExplicitProviderAuthBinding } from '../../../shared/provider-auth-binding.mjs';
 import { isExplicitUserAbortError, markProviderRecoveryExhausted } from './retry-classifier.mjs';
 import { sleepWithAbort } from './retry-backoff.mjs';
-import { QUOTA_KINDS, providerErrorKind } from './provider-error-kind.mjs';
+import { QUOTA_KINDS, boundedCauseChain, providerErrorKind } from './provider-error-kind.mjs';
 import { fetchOAuthUsageSnapshot, readCachedOAuthUsageSnapshot } from './oauth-usage.mjs';
 
 // Only an explicit quota / plan / billing refusal advances the roster as
@@ -124,15 +127,18 @@ function accountsExhaustedError(useCredits) {
 // evidence): a rate limit, advising the earliest cooldown end as the wait.
 // The pool already spent its cooldown wait, so this is a terminal verdict for
 // the loop, not an unclassified failure.
-function earliestCooldownMs(rows, now) {
-  const ends = rows.map((row) => Number(row.blockedUntil)).filter((until) => Number.isFinite(until) && until > now);
+// A row's cooldown for `model` ends when every block holding that model lifts.
+const coolingUntil = (row, model) => providerAccountBlockedUntil(row, model) ?? 0;
+
+function earliestCooldownMs(rows, now, model) {
+  const ends = rows.map((row) => coolingUntil(row, model)).filter((until) => until > now);
   return ends.length ? Math.min(...ends) - now : null;
 }
 
-function accountsCoolingDownError(rows, now) {
+function accountsCoolingDownError(rows, now, model) {
   const error = new Error('Every connected account is cooling down after a rate limit. Try again shortly.');
   error.code = 'rate_limited';
-  const wait = earliestCooldownMs(rows, now);
+  const wait = earliestCooldownMs(rows, now, model);
   if (wait != null) error.retryAfterMs = wait;
   return markProviderRecoveryExhausted(error, { owner: 'account-pool', terminal: true });
 }
@@ -258,6 +264,36 @@ function recordServingAccount(providerName, result, id, bindingId) {
   };
 }
 
+// A block covers the quota bucket of the model that failed, which only a usage
+// reading names. An account without a recorded reading is measured once before
+// it is blocked — once per account for this process, whatever the outcome,
+// through the ordinary cache (a fresh failed reading is not repeated) — and
+// again only after a reading has recorded windows and they were dropped.
+// Without a reading the block stays account-wide.
+const measureAttempted = new Set();
+
+async function measureOnce(providerName, row, account) {
+  const key = `${providerName}:${row.id}`;
+  if (row.usage?.windows?.length) {
+    measureAttempted.delete(key);
+    return;
+  }
+  if (measureAttempted.has(key)) return;
+  measureAttempted.add(key);
+  await fetchOAuthUsageSnapshot({ provider: providerName, accountId: row.id }, account(row.id), () => {}).catch(
+    () => null
+  );
+}
+
+// The server's id of the limit a refusal names (a Codex model-specific limit),
+// stamped on the error by the provider boundary.
+function quotaLimitOf(error) {
+  for (const item of boundedCauseChain(error)) {
+    if (typeof item?.quotaLimit === 'string' && item.quotaLimit) return item.quotaLimit;
+  }
+  return '';
+}
+
 // Whether the failed account's quota window is exhausted, plus the server's
 // retry delay. Anthropic and other subscriptions may use the same 429 code
 // for burst throttling and exhausted subscription windows, so the native
@@ -272,7 +308,7 @@ async function accountQuotaExhausted(providerName, row, model, error, account) {
   const policy = cooldownPolicyOf(account(row.id));
   const floorMs = policy ? finiteMs(policy.floorMs, 0) : 0;
   const blockUntil = (withReset, reason = 'unknown') => {
-    if (withReset && resetAt > now) return { until: resetAt, source: 'retry-after' };
+    if (withReset && resetAt > now) return { until: resetAt, source: 'retry-after', reset: true };
     if (delay > 0) return { until: now + Math.max(delay, floorMs), source: 'retry-after' };
     if (policy) {
       const ms = policyCooldownMs(policy, `${providerName}:${row.id}`, reason);
@@ -298,10 +334,14 @@ async function accountQuotaExhausted(providerName, row, model, error, account) {
     };
   }
   const typed = isAccountQuotaError(error);
-  if (typed) return { exhausted: true, delay, evidence: true, ...blockUntil(true, 'quota') };
+  if (typed) {
+    await measureOnce(providerName, row, account);
+    return { exhausted: true, delay, evidence: true, ...blockUntil(true, 'quota') };
+  }
   // A policy with rotateOnRateLimit rotates on a plain rate limit too (the
   // advice as its cooldown, else rateLimitedMs); never quota evidence.
   if (policy?.rotateOnRateLimit === true && kind === 'rate_limited' && status === 429) {
+    await measureOnce(providerName, row, account);
     return { exhausted: true, delay, evidence: false, ...blockUntil(false, 'rate_limited') };
   }
   let exhausted = status === 429 && delay > QUOTA_WINDOW_RETRY_AFTER_MS;
@@ -315,7 +355,7 @@ async function accountQuotaExhausted(providerName, row, model, error, account) {
     const pool = readProviderAccountPool(providerName);
     const entry = pool.accounts.find((item) => item.id === row.id);
     const options = { useCredits: pool.useCredits === true };
-    evidence = providerAccountExhausted({ ...entry, blockedUntil: 0 }, Date.now(), model, options);
+    evidence = providerAccountExhausted(providerAccountWithBlocks(entry), Date.now(), model, options);
     exhausted = exhausted || evidence || providerAccountExhausted(entry, Date.now(), model, options);
   }
   return { exhausted, delay, evidence, ...(exhausted ? blockUntil(evidence, evidence ? 'quota' : 'unknown') : {}) };
@@ -350,7 +390,7 @@ function poolSend(providerName, account) {
         rows.length > 0 &&
         rows.every((entry) =>
           providerAccountExhausted(
-            evidenced.has(entry.id) || entry.blockedQuota === true ? entry : { ...entry, blockedUntil: 0 },
+            evidenced.has(entry.id) ? entry : providerAccountWithBlocks(entry, (block) => block.blockedQuota === true),
             now,
             model,
             opts
@@ -363,7 +403,7 @@ function poolSend(providerName, account) {
       if (all) {
         return quotaExhausted(error || accountsExhaustedError(opts.useCredits), providerName, model, rows, opts);
       }
-      return error || accountsCoolingDownError(rows, now);
+      return error || accountsCoolingDownError(rows, now, model);
     };
     // Accounts this send blocked on a rate-limit cooldown, the time it spent
     // waiting for cooldowns, and the provider's wait bound.
@@ -381,8 +421,9 @@ function poolSend(providerName, account) {
       const bound = waitBoundMs(ids);
       // Persisting a short cooldown can outlast its deadline. Release only
       // attempts cooled by this send, and only under an enabled wait policy.
-      const expired = bound > 0 && rows.some((row) => cooled.has(row.id) && !(Number(row.blockedUntil) > now));
-      const wait = all ? null : expired ? 0 : earliestCooldownMs(rows, now);
+      const expired = bound > 0 && rows.some((row) => cooled.has(row.id) && !(coolingUntil(row, model) > now));
+      let wait = null;
+      if (!all) wait = expired ? 0 : earliestCooldownMs(rows, now, model);
       if (wait == null || waitedMs + wait > bound) throw markExhausted(error, ids);
       options.onStageChange?.('reconnecting', {
         message: `Rate limited — every account is cooling down; retrying in ${Math.ceil(wait / 1000)}s`,
@@ -397,7 +438,7 @@ function poolSend(providerName, account) {
       waitedMs += wait;
       const lifted = Date.now();
       for (const row of readProviderAccountPool(providerName).accounts) {
-        if (cooled.has(row.id) && !(Number(row.blockedUntil) > lifted)) {
+        if (cooled.has(row.id) && !(coolingUntil(row, model) > lifted)) {
           cooled.delete(row.id);
           attempted.delete(row.id);
         }
@@ -409,7 +450,8 @@ function poolSend(providerName, account) {
       if (!pool.accounts.length) {
         if (pool.useCredits !== true) {
           const stored = readCachedOAuthUsageSnapshot({ provider: providerName, model: '' });
-          if (stored?.quotaWindows?.length) {
+          // A snapshot cached before per-model gating is stale evidence.
+          if (stored?.quotaWindows?.length && !staleQuotaWindows(providerName, stored.quotaWindows)) {
             const row = { usage: { windows: stored.quotaWindows, checkedAt: stored.cachedAt } };
             if (providerAccountExhausted(row, Date.now(), model)) {
               throw quotaExhausted(accountsExhaustedError(false), providerName, model, [row]);
@@ -480,7 +522,7 @@ function poolSend(providerName, account) {
           options.onStageChange?.('reconnecting', { message: 'Sign-in expired — switching to the next account' });
           continue;
         }
-        const { exhausted, evidence, until, source, accountBlocked } = await accountQuotaExhausted(
+        const { exhausted, evidence, until, source, reset, accountBlocked } = await accountQuotaExhausted(
           providerName,
           row,
           model,
@@ -490,7 +532,13 @@ function poolSend(providerName, account) {
         if (options.signal?.aborted || !exhausted) throw error;
         if (evidence) evidenced.add(row.id);
         else cooled.add(row.id);
-        await blockProviderAccount(providerName, row.id, until, model, source, { quota: evidence === true });
+        // An account-level block holds every model, so it carries no model or
+        // limit scope.
+        await blockProviderAccount(providerName, row.id, until, accountBlocked ? '' : model, source, {
+          quota: evidence === true,
+          reset: reset === true,
+          limit: accountBlocked ? '' : quotaLimitOf(error),
+        });
         // An account block is unsafe to re-issue on THAT account only; with no
         // output emitted, the next account may serve the same request.
         if (
@@ -509,13 +557,10 @@ function poolSend(providerName, account) {
         lastError = error;
         switched = true;
         refusalScoped = accountExhaustedForModelOnly(providerName, row.id, model);
-        options.onStageChange?.('reconnecting', {
-          message: evidence
-            ? 'Quota exhausted — switching to the next account'
-            : accountBlocked
-              ? 'Account blocked — switching to the next account'
-              : 'Rate limited (cooldown) — switching to the next account',
-        });
+        let reason = 'Rate limited (cooldown)';
+        if (evidence) reason = 'Quota exhausted';
+        else if (accountBlocked) reason = 'Account blocked';
+        options.onStageChange?.('reconnecting', { message: `${reason} — switching to the next account` });
       }
     }
     throw markExhausted(lastError || new Error('Provider account attempts exhausted.'));

package/src/runtime/agent/orchestrator/providers/admission-scheduler.mjs

@@ -2,6 +2,13 @@ import { createHash } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { PRIORITY_RANK, normalizePriority, resourceAdmission } from '../../../shared/resource-admission.mjs';
 import { accountProviderSend } from '../../../shared/llm/usage-accounting.mjs';
+import { sanitizeSurrogates } from '../../../shared/llm/well-formed.mjs';
+import { providerAvailable, providerUnavailableError } from './provider-availability.mjs';
+import {
+  finalizeProviderRequestTools,
+  isFinalizedProviderRequestTools,
+  providerNativeToolPrefixCount,
+} from '../runtime-core/provider-request-tools.mjs';
 
 // Normal provider traffic is not concurrency-gated. Independent sessions and
 // accounts start immediately; a finite limit exists only when an operator
@@ -518,7 +525,18 @@ export function wrapProviderAdmission(provider, providerName, scheduler = provid
   if (!provider || typeof provider.send !== 'function' || provider[WRAPPED]) return provider;
   const originalSend = provider.send;
   Object.defineProperty(provider, WRAPPED, { value: true });
-  provider.send = function admittedProviderSend(messages, model, tools, sendOpts) {
+  provider.send = function admittedProviderSend(rawMessages, model, rawTools, sendOpts) {
+    // Every registered provider (and its account-pool / proxy / custom variants)
+    // is wrapped here, so this is the one point all model requests pass before
+    // serialization. A lone surrogate would make the API reject the body on
+    // every send; only the outgoing request is rewritten, never the transcript.
+    const messages = sanitizeSurrogates(rawMessages);
+    let tools = sanitizeSurrogates(rawTools);
+    // A finalized tool list is recognised by identity; its sanitized copy must
+    // stay finalized with the same native prefix (the model proxy reads both).
+    if (tools !== rawTools && isFinalizedProviderRequestTools(rawTools)) {
+      tools = finalizeProviderRequestTools(tools, providerNativeToolPrefixCount(rawTools));
+    }
     const opts = sendOpts || {};
     const signal = opts.signal || null;
     const key = providerAdmissionKey(providerName, this);
@@ -530,6 +548,9 @@ export function wrapProviderAdmission(provider, providerName, scheduler = provid
         scheduler.run(
           key,
           (admissionSignal, admissionMetrics) => {
+            // The Developer option may have been switched off after lookup or
+            // while this request waited: the gate is rechecked right before send.
+            if (!providerAvailable(providerName)) throw providerUnavailableError(providerName);
             // Admission is the common request-clock boundary for WS/SSE/HTTP.
             // Queue wait therefore cannot consume first-byte or agent-watchdog
             // time. Provider-local retry remains the sole retry owner.

package/src/runtime/agent/orchestrator/providers/anthropic-api-request.mjs

@@ -18,13 +18,17 @@ import { applyAnthropicEffortToBody, shouldIncludeEffortBeta } from './anthropic
 import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
 import {
   anthropicThinkingActive,
+  anthropicTurnScopedReminders,
   appendAnthropicTailReminder,
+  appendAnthropicTurnReminder,
   applyAnthropicCacheMarkers,
   clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
+  hasAnthropicTurnScopedMessages,
   resolveAnthropicCacheTtls as resolveCacheTtls,
   resolveAnthropicMessageCacheSlots,
   sharedCachePrefixBoundary,
   toAnthropicToolChoice,
+  withAnthropicTurnReminders,
 } from './lib/anthropic-request-utils.mjs';
 import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 import {
@@ -97,12 +101,17 @@ export async function buildAnthropicApiRequest({
   // are applied to the FINAL sanitized array by invariant, so block
   // drops / inserts / reorders performed by the sanitizer can never move
   // or delete a marked block. NEVER sanitize again after this.
-  const lowerHistory = (history, projection) =>
-    lowerAnthropicEffortHistory(
+  // Turn-scoped tail reminders (tail-reminder-split.mjs): stored reminders are
+  // re-sent before their assistant turns, the current one ends the request.
+  const turnScoped = anthropicTurnScopedReminders(name, useModel, config);
+  const lowerHistory = (history, projection) => {
+    const lowered = lowerAnthropicEffortHistory(
       history.filter((m) => m.role !== 'system'),
       (segment) => toAnthropicMessages(segment, requestTools, name),
       projection
     );
+    return turnScoped ? withAnthropicTurnReminders(lowered) : lowered;
+  };
   const anthropicMessages = applyAnthropicCacheMarkers(
     lowerHistory(chatMsgs, effortProjection),
     messageCacheSlots,
@@ -115,9 +124,12 @@ export async function buildAnthropicApiRequest({
     model: useModel,
     max_tokens: maxTokens,
     system: systemBlocks.length ? systemBlocks : undefined,
-    messages: await prepareAnthropicImages(appendAnthropicTailReminder(anthropicMessages, reminder), {
-      signal: opts.signal,
-    }),
+    messages: await prepareAnthropicImages(
+      turnScoped
+        ? appendAnthropicTurnReminder(anthropicMessages, reminder)
+        : appendAnthropicTailReminder(anthropicMessages, reminder),
+      { signal: opts.signal }
+    ),
   };
   // Server-side fallback and fast mode are decided from Claude model ids:
   // first-party knowledge, never applied to a custom endpoint.
@@ -255,6 +267,7 @@ function requestHeadersFor(
         effort: isCustom ? Boolean(params.output_config?.effort) : shouldIncludeEffortBeta(capabilityModel, opts),
         serverFallback: params.fallbacks === 'default',
         thinkingDisplayUpdates: params.thinking?.display === 'updates',
+        turnScopedSystem: hasAnthropicTurnScopedMessages(params.messages),
       }),
       ...(effortProjection ? [EFFORT_CONFIGURATION_BETA] : []),
     ].filter(Boolean);

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-client-version.mjs

@@ -10,7 +10,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // source release just to advance the user-agent version.
 // Claude Opus 5.5 requires 2.1.280 or newer. The release workflow raises this
 // to the published CLI version (scripts/sync-client-version-floors.mjs).
-export const DEFAULT_CLI_VERSION = '2.1.308';
+export const DEFAULT_CLI_VERSION = '2.1.310';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

package/src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs

@@ -61,10 +61,13 @@ import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-r
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import {
   anthropicThinkingActive,
+  anthropicTurnScopedReminders,
   appendAnthropicTailReminder,
+  appendAnthropicTurnReminder,
   applyAnthropicCacheMarkers,
   clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
   deferredAnthropicTools as sharedDeferredAnthropicTools,
+  hasAnthropicTurnScopedMessages,
   requestAnthropicTools as sharedRequestAnthropicTools,
   resolveAnthropicCacheTtls as resolveCacheTtls,
   resolveAnthropicMessageCacheSlots,
@@ -72,6 +75,7 @@ import {
   sharedCachePrefixBoundary,
   toAnthropicMessages,
   toAnthropicToolChoice,
+  withAnthropicTurnReminders,
 } from './lib/anthropic-request-utils.mjs';
 import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 import {
@@ -111,6 +115,7 @@ function buildOAuthBetaHeaders(body, { fastMode = false, toolSearch = false, mod
     effort: shouldIncludeEffortBeta(model, opts),
     serverFallback: body?.fallbacks === 'default',
     thinkingDisplayUpdates: body?.thinking?.display === 'updates',
+    turnScopedSystem: hasAnthropicTurnScopedMessages(body?.messages),
   });
 }
 
@@ -223,12 +228,17 @@ function buildRequestBody(requestMessages, model, tools, sendOpts) {
   // applied to the FINAL sanitized array by invariant, so block drops /
   // inserts / reorders performed by the sanitizer can never move or delete a
   // marked block. NEVER sanitize again after this (see send path).
-  const lowerHistory = (history, projection) =>
-    lowerAnthropicEffortHistory(
+  // Turn-scoped tail reminders (tail-reminder-split.mjs): stored reminders are
+  // re-sent before their assistant turns, the current one ends the request.
+  const turnScoped = anthropicTurnScopedReminders('anthropic-oauth', model);
+  const lowerHistory = (history, projection) => {
+    const lowered = lowerAnthropicEffortHistory(
       history.filter((m) => m.role !== 'system'),
       (segment) => toAnthropicMessages(segment, requestTools),
       projection
     );
+    return turnScoped ? withAnthropicTurnReminders(lowered) : lowered;
+  };
   const anthropicMessages = applyAnthropicCacheMarkers(
     lowerHistory(chatMsgs, effortProjection),
     messageCacheSlots,
@@ -240,7 +250,9 @@ function buildRequestBody(requestMessages, model, tools, sendOpts) {
   const body = {
     model,
     max_tokens: maxTokens,
-    messages: appendAnthropicTailReminder(anthropicMessages, reminder),
+    messages: turnScoped
+      ? appendAnthropicTurnReminder(anthropicMessages, reminder)
+      : appendAnthropicTailReminder(anthropicMessages, reminder),
     stream: true,
   };
   applyAnthropicServerFallback(body, model, {

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-catalog.mjs

@@ -23,7 +23,8 @@ import {
 } from './antigravity-oauth-tokens.mjs';
 
 const ANTIGRAVITY_MODEL_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
-const ANTIGRAVITY_MODEL_CACHE_VERSION = 1;
+// v2: rows keep the gateway-declared per-model `maxOutputTokens`.
+const ANTIGRAVITY_MODEL_CACHE_VERSION = 2;
 const FETCH_MODELS_TIMEOUT_MS = 15_000;
 // Tier labels the gateway puts in parentheses, in effort order.
 const TIER_EFFORTS = { 'extra low': 'minimal', minimal: 'minimal', low: 'low', medium: 'medium', high: 'high' };
@@ -145,10 +146,21 @@ export function normalizeAntigravityCatalog(rawModels) {
     const key = familyId(base);
     let family = families.get(key);
     if (!family) {
-      family = { base, contextWindow: 0, supportsVision: false, supportsReasoning: false, wires: new Map() };
+      family = {
+        base,
+        contextWindow: 0,
+        maxOutputTokens: 0,
+        supportsVision: false,
+        supportsReasoning: false,
+        wires: new Map(),
+      };
       families.set(key, family);
     }
     family.contextWindow = Math.max(family.contextWindow, contextWindow);
+    // Wire ids sharing one record keep the smallest declared output limit, so
+    // the ceiling holds for every id the record can resolve to.
+    const declaredOutput = Math.floor(Number(entry.maxOutputTokens));
+    if (declaredOutput > 0) family.maxOutputTokens = Math.min(family.maxOutputTokens || declaredOutput, declaredOutput);
     family.supportsVision ||= entry.supportsImages === true;
     family.supportsReasoning ||= entry.supportsThinking === true;
     const slot = effort || '';
@@ -177,6 +189,7 @@ export function normalizeAntigravityCatalog(rawModels) {
       provider: 'antigravity-oauth',
       ...(kind ? { family: kind } : {}),
       contextWindow: family.contextWindow,
+      ...(family.maxOutputTokens ? { maxOutputTokens: family.maxOutputTokens } : {}),
       supportsVision: family.supportsVision,
       supportsReasoning: family.supportsReasoning,
       supportsFunctionCalling: true,
@@ -210,6 +223,19 @@ export function antigravityModelFamily(model, models = antigravityCatalogModels(
   return typeof record?.family === 'string' && record.family ? record.family : null;
 }
 
+/**
+ * The output-token limit the gateway declared for a picker id or one of its
+ * wire ids, or null when the catalog row carries none (the curated fallback
+ * list and caches written before the field existed declare none).
+ */
+export function antigravityOutputLimit(model, models = antigravityCatalogModels()) {
+  const id = String(model || '');
+  const wires = (entry) => (entry?.wire && typeof entry.wire === 'object' ? Object.values(entry.wire) : [entry?.wire]);
+  const record = models.find((entry) => entry?.id === id) || models.find((entry) => wires(entry).includes(id));
+  const limit = Math.floor(Number(record?.maxOutputTokens));
+  return limit > 0 ? limit : null;
+}
+
 /**
  * Turn a picker model + effort into the wire id the gateway accepts. Tiered
  * families consume the effort (the id encodes it); a bare id whose record
@@ -232,7 +258,7 @@ export function resolveAntigravityWireModel(model, effort, models = antigravityC
   return { model: wire, effort: record.reasoningLevels?.length ? effort : null };
 }
 
-function quotaRow(label, bucket) {
+function quotaRow(label, bucket, scope) {
   if (!bucket || typeof bucket !== 'object') return null;
   if (typeof bucket.remainingFraction !== 'number' || !Number.isFinite(bucket.remainingFraction)) return null;
   const usedPct = Math.round(Math.max(0, Math.min(100, (1 - bucket.remainingFraction) * 100)) * 100) / 100;
@@ -242,6 +268,7 @@ function quotaRow(label, bucket) {
     usedPct,
     ...(Number.isFinite(resetAt) && resetAt > 0 ? { resetAt } : {}),
     source: 'antigravity-quota-summary',
+    ...scope,
   };
 }
 
@@ -254,11 +281,21 @@ const ARGON_WEEKLY_BUCKET_ID = 'gemini-argon-wtu-weekly';
 const THIRD_PARTY_5H_BUCKET_ID = '3p-5h';
 const THIRD_PARTY_WEEKLY_BUCKET_ID = '3p-weekly';
 
+// The model ids each separate bucket meters: the "Claude and GPT models"
+// group (Claude Opus, Claude Sonnet, GPT-OSS) and the Gemini 4 Argon group.
+const THIRD_PARTY_MODELS = Object.freeze(['claude', 'gpt']);
+const ARGON_MODELS = Object.freeze(['argon']);
+
 /**
  * Gemini 5H/7D rows from retrieveUserQuotaSummary, the separate weekly limit
  * of the Gemini 4 Argon group (its own group with only a weekly bucket), and
  * the Claude/GPT-OSS 5H/7D pair. Rows are selected by bucket id and window.
  * Missing fields stay omitted.
+ *
+ * Each group's buckets gate its own models only: the 3p pair gates Claude and
+ * GPT-OSS, the Argon bucket gates Argon, and the shared Gemini pair gates every
+ * model no other bucket in this summary claims, so a full Claude/GPT window
+ * leaves Gemini serving and the reverse.
  */
 export function antigravityQuotaWindows(summary) {
   const groups = (Array.isArray(summary?.groups) ? summary.groups : []).filter(
@@ -268,11 +305,18 @@ export function antigravityQuotaWindows(summary) {
   const bucket = (id, window) =>
     buckets.find((entry) => entry && typeof entry === 'object' && entry.bucketId === id && entry.window === window) ??
     null;
+  const reported = (...ids) => buckets.some((entry) => ids.includes(entry?.bucketId));
+  const claimed = [
+    ...(reported(THIRD_PARTY_5H_BUCKET_ID, THIRD_PARTY_WEEKLY_BUCKET_ID) ? THIRD_PARTY_MODELS : []),
+    ...(reported(ARGON_WEEKLY_BUCKET_ID) ? ARGON_MODELS : []),
+  ];
+  const gemini = claimed.length ? { except: claimed } : {};
+  const thirdParty = { models: [...THIRD_PARTY_MODELS] };
   return [
-    quotaRow('5H', bucket(GEMINI_5H_BUCKET_ID, '5h')),
-    quotaRow('7D', bucket(GEMINI_WEEKLY_BUCKET_ID, 'weekly')),
-    quotaRow('7D Argon', bucket(ARGON_WEEKLY_BUCKET_ID, 'weekly')),
-    quotaRow('5H Claude/GPT', bucket(THIRD_PARTY_5H_BUCKET_ID, '5h')),
-    quotaRow('7D Claude/GPT', bucket(THIRD_PARTY_WEEKLY_BUCKET_ID, 'weekly')),
+    quotaRow('5H', bucket(GEMINI_5H_BUCKET_ID, '5h'), gemini),
+    quotaRow('7D', bucket(GEMINI_WEEKLY_BUCKET_ID, 'weekly'), gemini),
+    quotaRow('7D Argon', bucket(ARGON_WEEKLY_BUCKET_ID, 'weekly'), { models: [...ARGON_MODELS] }),
+    quotaRow('5H Claude/GPT', bucket(THIRD_PARTY_5H_BUCKET_ID, '5h'), thirdParty),
+    quotaRow('7D Claude/GPT', bucket(THIRD_PARTY_WEEKLY_BUCKET_ID, 'weekly'), thirdParty),
   ].filter(Boolean);
 }

package/src/runtime/agent/orchestrator/providers/antigravity-oauth.mjs

@@ -18,6 +18,8 @@ import { buildAntigravityRequest, isAntigravityClaude as isClaudeModel } from '.
 import { createPassthroughSignal } from '../stall-policy.mjs';
 import { preconnect } from '../../../shared/llm/http-agent.mjs';
 import { createAntigravityStreamCollector } from './antigravity-stream.mjs';
+import { createGeminiReasoningRelay } from './gemini-reasoning-relay.mjs';
+import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 import { createAntigravityRequest } from './antigravity-transport.mjs';
 import { finalizeAntigravityTurn } from './antigravity-response.mjs';
 import {
@@ -41,6 +43,7 @@ import {
   fetchAvailableModels,
   fetchUserQuotaSummary,
   normalizeAntigravityCatalog,
+  antigravityOutputLimit,
   resolveAntigravityWireModel,
 } from './antigravity-oauth-catalog.mjs';
 
@@ -109,7 +112,7 @@ export class AntigravityOAuthProvider {
   }
 
   _buildBody(messages, model, tools, opts) {
-    const body = buildAntigravityRequest(messages, model, tools, opts, this._projectId);
+    const body = buildAntigravityRequest(messages, model, tools, opts, this._projectId, antigravityOutputLimit(model));
     dumpAntigravityRequest(body);
     return body;
   }
@@ -131,6 +134,7 @@ export class AntigravityOAuthProvider {
     // Relayed through opts so the callback keeps its original receiver.
     const onTextDelta = typeof opts.onTextDelta === 'function' ? (text) => opts.onTextDelta(text) : null;
     const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
+    const reasoning = createGeminiReasoningRelay(opts);
     // Per-turn stream record: live text mirror, ordered parts, native/leaked
     // tool calls and the exposure marks a failed attempt carries
     // (antigravity-stream.mjs).
@@ -140,6 +144,8 @@ export class AntigravityOAuthProvider {
       onToolCall,
       onTextDelta,
       onStreamDelta,
+      onReasoningDelta: reasoning.onReasoningDelta,
+      retractReasoning: reasoning.retract,
     });
     if (signal?.aborted) {
       const reason = signal.reason;
@@ -181,6 +187,9 @@ export class AntigravityOAuthProvider {
       collector,
       sleepFn: this.config.sleepFn,
       firstByte: antigravityFirstBytePolicy(useModel),
+      // The tail reminder is not history: an empty answer right after a tool
+      // result is the model's answer, whatever reminder rides behind it.
+      afterToolResult: splitTailReminder(messages).messages.at(-1)?.role === 'tool',
     });
     try {
       try {

package/src/runtime/agent/orchestrator/providers/antigravity-request.mjs

@@ -3,10 +3,17 @@ import { createProviderReplay, providerReplayItems } from './lib/provider-replay
 import { toGeminiContents, toGeminiRequestTools, toGeminiToolConfig } from './gemini-schema.mjs';
 import { geminiThinkingConfig } from './gemini-thinking.mjs';
 import { isGeminiFamilyModel } from './gemini-family.mjs';
+import { geminiMaxOutputTokens } from './gemini-output-limit.mjs';
 import { splitTailReminder } from './lib/tail-reminder-split.mjs';
 
 const THOUGHT_SIGNATURE_SENTINEL = 'skip_thought_signature_validator';
+// Used only when the gateway declared no output limit for a Claude id (the
+// gateway enforces Claude's limit per model: one token over it is a 400).
 const CLAUDE_MAX_OUTPUT_TOKENS = 64000;
+const claudeMaxOutputTokens = (declared) => {
+  const limit = Math.floor(Number(declared));
+  return limit > 0 ? limit : CLAUDE_MAX_OUTPUT_TOKENS;
+};
 
 // Claude models behind the gateway speak a different thinking/replay dialect
 // (token budgets, anthropic-beta header, their own signatures). The roster
@@ -190,7 +197,7 @@ function claudeGatewayLevel(value) {
 
 // An explicit token budget is sent as-is; otherwise the chosen effort rides
 // on thinkingLevel with the wire id unchanged.
-function claudeThinkingConfig(opts) {
+function claudeThinkingConfig(opts, cap) {
   const budget = opts.thinkingBudget ?? opts.thinkingBudgetTokens;
   const thinkingConfig = { includeThoughts: true };
   if (budget == null) {
@@ -199,8 +206,8 @@ function claudeThinkingConfig(opts) {
     return thinkingConfig;
   }
   const value = Number(budget);
-  if (!Number.isInteger(value) || value < 1024 || value >= CLAUDE_MAX_OUTPUT_TOKENS) {
-    throw new TypeError('Antigravity Claude thinkingBudget must be an integer from 1024 to 63999.');
+  if (!Number.isInteger(value) || value < 1024 || value >= cap) {
+    throw new TypeError(`Antigravity Claude thinkingBudget must be an integer from 1024 to ${cap - 1}.`);
   }
   thinkingConfig.thinkingBudget = value;
   return thinkingConfig;
@@ -220,7 +227,9 @@ function antigravityGeminiThinkingConfig(model, opts) {
   });
 }
 
-export function buildAntigravityRequest(requestMessages, model, tools, opts = {}, projectId) {
+// `outputLimit` is the output-token limit the gateway declared for this wire id
+// (the catalog row's `maxOutputTokens`), or null when it declared none.
+export function buildAntigravityRequest(requestMessages, model, tools, opts = {}, projectId, outputLimit = null) {
   // The tail reminder is not history: the tool-loop closure below must see the
   // real tail, so the reminder is appended to the wire contents last.
   const { messages, reminder } = splitTailReminder(requestMessages);
@@ -232,10 +241,17 @@ export function buildAntigravityRequest(requestMessages, model, tools, opts = {}
   const history = toGeminiContents(signatureSafeMessages(chatMessages, model), model);
   if (!history.length) throw new Error('No messages to send');
   const claude = isAntigravityClaude(model);
-  const thinkingConfig = claude ? claudeThinkingConfig(opts) : antigravityGeminiThinkingConfig(model, opts);
+  const claudeCap = claudeMaxOutputTokens(outputLimit);
+  const thinkingConfig = claude ? claudeThinkingConfig(opts, claudeCap) : antigravityGeminiThinkingConfig(model, opts);
   const contents = claude && claudeThinkingEnabled(model, thinkingConfig) ? closeUnthoughtToolLoop(history) : history;
+  // Gemini wire ids carry the model's output ceiling (thoughts count against
+  // it); Claude is always sent a cap (the declared limit, else a fixed one);
+  // GPT-OSS keeps the plain config its gateway accepts.
+  let maxOutputTokens;
+  if (claude) maxOutputTokens = claudeCap;
+  else if (isGeminiFamilyModel(model)) maxOutputTokens = geminiMaxOutputTokens(model, opts, null, outputLimit);
   const generationConfig = {
-    ...(claude ? { maxOutputTokens: CLAUDE_MAX_OUTPUT_TOKENS } : {}),
+    ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
     ...(thinkingConfig ? { thinkingConfig } : {}),
   };
   const request = { contents: reminder ? [...contents, { role: 'user', parts: [{ text: reminder }] }] : contents };

package/src/runtime/agent/orchestrator/providers/antigravity-response.mjs

@@ -23,10 +23,21 @@ export function normalizeAntigravityUsage(um) {
     (um.promptTokenCount || um.prompt_token_count || 0) +
     (um.toolUsePromptTokenCount || um.tool_use_prompt_token_count || 0);
   const cachedTokens = um.cachedContentTokenCount || um.cached_content_token_count || 0;
-  const outputTokens =
-    (um.candidatesTokenCount || um.candidates_token_count || 0) +
-    (um.thoughtsTokenCount || um.thoughts_token_count || 0);
-  return { inputTokens, outputTokens, cachedTokens, promptTokens: inputTokens, raw: um };
+  const thoughtTokens = um.thoughtsTokenCount ?? um.thoughts_token_count;
+  // Thought tokens are billed and capped as output.
+  const outputTokens = (um.candidatesTokenCount || um.candidates_token_count || 0) + (Number(thoughtTokens) || 0);
+  const reportedTotal = Number(um.totalTokenCount ?? um.total_token_count);
+  return {
+    inputTokens,
+    outputTokens,
+    cachedTokens,
+    promptTokens: inputTokens,
+    // Reasoning is reported only when the gateway reported thoughts (a missing
+    // count is not zero).
+    ...(typeof thoughtTokens === 'number' ? { reasoningTokens: thoughtTokens } : {}),
+    totalTokens: reportedTotal > 0 ? reportedTotal : inputTokens + outputTokens,
+    raw: um,
+  };
 }
 
 /**