mixdog 1.3.4 → 1.4.0

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

@@ -2,10 +2,11 @@ import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/pro
 import { sanitizeToolPairs } from '../session/context-utils.mjs';
 import { AnthropicFallbackTriggeredError } from './retry-classifier.mjs';
 import {
-  announceAnthropicModelFallback,
   createAnthropicOverloadTracker,
   isTerminalOverloadModel,
+  takeAnthropicModelFallback,
 } from './anthropic-overload-fallback.mjs';
+import { removeAbortListener } from './anthropic-oauth-request/abort-wiring.mjs';
 import { readStreamOutcome } from './lib/stream-outcome.mjs';
 import { createPassthroughSignal } from '../stall-policy.mjs';
 import { createAbortController } from '../../../shared/abort-controller.mjs';
@@ -18,6 +19,7 @@ import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-r
 import { armFirstByteWatchdog, createAnthropicApiTransport } from './anthropic-api-transport.mjs';
 import { createAnthropicApiRecovery } from './anthropic-api-recovery.mjs';
 import { buildAnthropicTurnResult } from './anthropic-turn-result.mjs';
+import { sendAnthropicCacheWarm } from './anthropic-cache-warm.mjs';
 import {
   assertAnthropicStreamNotEmpty,
   createAnthropicMidState,
@@ -38,6 +40,29 @@ import { streamCallbacks } from './lib/send-callbacks.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
 export { _test, _toAnthropicMessagesForTest } from './anthropic-messages.mjs';
 
+// One stream attempt's controller, aborted with the caller's reason when the
+// send's signal aborts. An already-aborted send fails before the attempt.
+function linkAttemptAbort(totalSignal) {
+  const streamController = createAbortController();
+  let cancelHandler = null;
+
+  if (totalSignal) {
+    if (totalSignal.aborted) {
+      const reason = totalSignal.reason;
+      throw reason instanceof Error ? reason : new Error('Anthropic request aborted');
+    }
+    cancelHandler = () => {
+      try {
+        streamController.abort(totalSignal.reason);
+      } catch {
+        // best-effort propagation of caller cancellation
+      }
+    };
+    totalSignal.addEventListener('abort', cancelHandler, { once: true });
+  }
+  return { streamController, cancelHandler };
+}
+
 export class AnthropicProvider {
   // Takes a PDF as a native document block (decided by this adapter's wire protocol).
   nativePdf = true;
@@ -143,6 +168,38 @@ export class AnthropicProvider {
       throw err;
     }
   }
+  /**
+   * Cache-warm mode (anthropic-cache-warm.mjs): the request `send` would
+   * build for these arguments, sent once on the retry-free client — no
+   * key reload, fallback model or re-send — and cut at the first content
+   * block. `onUsage` receives the reported usage as it arrives.
+   */
+  async sendCacheWarm(messages, model, tools, opts = {}, { onUsage, accountId = '' } = {}) {
+    const prepared = await preparePdfTextForProvider(sanitizeToolPairs(messages), this);
+    const { params, requestHeaders } = await buildAnthropicApiRequest({
+      name: this.name,
+      config: this.config,
+      messages: prepared,
+      useModel: model,
+      tools,
+      opts,
+      fastModeLatched: this.fastModeBetaHeaderLatched,
+      modelInfo: isCustomProviderName(this.name) ? this.getCachedModelInfo?.(model) || null : null,
+      capabilityModel: this._capabilityModel(model),
+    });
+    return sendAnthropicCacheWarm({
+      providerName: this.name,
+      instance: this,
+      accountId,
+      model,
+      opts,
+      onUsage,
+      post: (signal) =>
+        this._currentClient()
+          .messages.create(params, { signal, ...(requestHeaders ? { headers: requestHeaders } : {}) })
+          .asResponse(),
+    });
+  }
   // The `anthropic` API-key provider and every custom `anthropic`-protocol
   // provider (a subclass of this one) share this send path.
   async _doSend(messages, model, tools, sendOpts) {
@@ -188,89 +245,20 @@ export class AnthropicProvider {
     const totalTimeout = createPassthroughSignal(externalSignal);
     const totalSignal = totalTimeout.signal;
 
-    const cleanupCancelHandler = (handler) => {
-      if (!handler) return;
-      try {
-        totalSignal.removeEventListener('abort', handler);
-      } catch {}
-    };
-
-    // Request-loop 529s and SSE overload events share one counter; at the
-    // limit the configured fallback model takes over the whole send.
-    const overload = createAnthropicOverloadTracker({
-      model: useModel,
-      fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
-      terminalAtLimit: !isCustomProviderName(this.name) && isTerminalOverloadModel(useModel),
-    });
-    // The SDK calls and their initial-response retry policy
-    // (anthropic-api-transport.mjs).
-    const transport = createAnthropicApiTransport({
-      client: this._currentClient(),
-      label: this.name,
+    const { transport, buildTurnResult, recovery, midstream } = this._createSendRecovery({
       opts,
       useModel,
       params,
       requestHeaders,
       totalSignal,
-      overload,
-    });
-    // Usage accounting + caller-visible projection, shared by the streaming
-    // success path and the non-streaming fallback (anthropic-turn-result.mjs).
-    const buildTurnResult = (parseResult) =>
-      buildAnthropicTurnResult(parseResult, { provider: this.name, useModel, opts });
-    // Non-streaming re-issue of a dead stream, behind the transport-recovery
-    // budget and the exposed-output retraction handshake
-    // (anthropic-api-recovery.mjs).
-    const recovery = createAnthropicApiRecovery({
-      label: this.name,
-      opts,
-      useModel,
-      params,
-      totalSignal,
-      transport,
-      buildTurnResult,
       onStageChange,
       onTextReset,
     });
-    // Bounded mid-stream retries for transient stream loss; jittered backoff
-    // between attempts (anthropic-midstream-recovery.mjs, shared with
-    // anthropic-oauth).
-    const midstream = createAnthropicMidstreamRecovery({
-      label: this.name,
-      displayName: 'Anthropic',
-      outcomeProvider: 'anthropic',
-      midstreamOwner: `${this.name}-midstream`,
-      unreachableMessage: 'Anthropic mid-stream retry: unreachable',
-      // The transport's withRetry already exhausted the full request-level
-      // budget for a non-OK initial response, so it must not earn an
-      // additional SSE retry budget here.
-      initialResponseErrorTerminal: true,
-      maxRetries: ANTHROPIC_MAX_MIDSTREAM_RETRIES,
-      totalSignal,
-      recovery,
-      onStageChange,
-      retry529: opts.retry529 !== false,
-      overload,
-    });
 
     let streamingFallbackTried = false;
     try {
       for (let attemptIndex = 0; attemptIndex <= ANTHROPIC_MAX_MIDSTREAM_RETRIES; attemptIndex++) {
-        const streamController = createAbortController();
-        let cancelHandler = null;
-
-        if (totalSignal) {
-          if (totalSignal.aborted) {
-            const reason = totalSignal.reason;
-            throw reason instanceof Error ? reason : new Error('Anthropic request aborted');
-          }
-          cancelHandler = () => {
-            try {
-              streamController.abort(totalSignal.reason);
-            } catch {}
-          };
-          totalSignal.addEventListener('abort', cancelHandler, { once: true });
-        }
+        const { streamController, cancelHandler } = linkAttemptAbort(totalSignal);
 
         const midState = createAnthropicMidState(attemptIndex);
 
@@ -280,13 +268,17 @@ export class AnthropicProvider {
         try {
           try {
             onStageChange?.('requesting');
-          } catch {}
+          } catch {
+            // the stage observer is advisory
+          }
 
           response = await transport.requestStreamingResponse();
 
           try {
             onStageChange?.('streaming');
-          } catch {}
+          } catch {
+            // the stage observer is advisory
+          }
 
           firstByte = armFirstByteWatchdog(streamController, midState);
 
@@ -307,7 +299,9 @@ export class AnthropicProvider {
           );
           try {
             streamController.abort?.('Anthropic SSE complete');
-          } catch {}
+          } catch {
+            // the stream is complete; the controller may already be aborted
+          }
 
           firstByte.cleanup();
           assertAnthropicStreamNotEmpty(midState, parseResult, 'Anthropic');
@@ -336,26 +330,80 @@ export class AnthropicProvider {
           return decision.value;
         } finally {
           firstByte?.cleanup();
-          cleanupCancelHandler(cancelHandler);
+          removeAbortListener(totalSignal, cancelHandler);
         }
       }
       throw midstream.exhaustedError();
     } catch (err) {
-      // The fallback trigger can surface from the request loop, a mid-stream
-      // overload, or the non-streaming recovery: handle it around the whole
-      // operation, not just the first request.
-      if (!(err instanceof AnthropicFallbackTriggeredError)) throw err;
-      process.stderr.write(`[${this.name}] ${err.message}\n`);
-      announceAnthropicModelFallback(onStageChange, useModel, err.fallbackModel);
-      return await this._doSend(messages, err.fallbackModel, tools, {
-        ...opts,
-        fallbackModel: undefined,
-        _fallbackTriggered: true,
-      });
+      const fallbackOpts = takeAnthropicModelFallback(err, { tag: this.name, model: useModel, opts, onStageChange });
+      return await this._doSend(messages, err.fallbackModel, tools, fallbackOpts);
     } finally {
       totalTimeout.cleanup();
     }
   }
+  // The recovery pipeline of one send over its fixed request: the shared
+  // overload counter, the transport, the turn-result projection, the
+  // non-streaming recovery and the bounded mid-stream retries.
+  _createSendRecovery({ opts, useModel, params, requestHeaders, totalSignal, onStageChange, onTextReset }) {
+    // Request-loop 529s and SSE overload events share one counter; at the
+    // limit the configured fallback model takes over the whole send.
+    const overload = createAnthropicOverloadTracker({
+      model: useModel,
+      fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
+      terminalAtLimit: !isCustomProviderName(this.name) && isTerminalOverloadModel(useModel),
+    });
+    // The SDK calls and their initial-response retry policy
+    // (anthropic-api-transport.mjs).
+    const transport = createAnthropicApiTransport({
+      client: this._currentClient(),
+      label: this.name,
+      opts,
+      useModel,
+      params,
+      requestHeaders,
+      totalSignal,
+      overload,
+    });
+    // Usage accounting + caller-visible projection, shared by the streaming
+    // success path and the non-streaming fallback (anthropic-turn-result.mjs).
+    const buildTurnResult = (parseResult) =>
+      buildAnthropicTurnResult(parseResult, { provider: this.name, useModel, opts });
+    // Non-streaming re-issue of a dead stream, behind the transport-recovery
+    // budget and the exposed-output retraction handshake
+    // (anthropic-api-recovery.mjs).
+    const recovery = createAnthropicApiRecovery({
+      label: this.name,
+      opts,
+      useModel,
+      params,
+      totalSignal,
+      transport,
+      buildTurnResult,
+      onStageChange,
+      onTextReset,
+    });
+    // Bounded mid-stream retries for transient stream loss; jittered backoff
+    // between attempts (anthropic-midstream-recovery.mjs, shared with
+    // anthropic-oauth).
+    const midstream = createAnthropicMidstreamRecovery({
+      label: this.name,
+      displayName: 'Anthropic',
+      outcomeProvider: 'anthropic',
+      midstreamOwner: `${this.name}-midstream`,
+      unreachableMessage: 'Anthropic mid-stream retry: unreachable',
+      // The transport's withRetry already exhausted the full request-level
+      // budget for a non-OK initial response, so it must not earn an
+      // additional SSE retry budget here.
+      initialResponseErrorTerminal: true,
+      maxRetries: ANTHROPIC_MAX_MIDSTREAM_RETRIES,
+      totalSignal,
+      recovery,
+      onStageChange,
+      retry529: opts.retry529 !== false,
+      overload,
+    });
+    return { transport, buildTurnResult, recovery, midstream };
+  }
   async listModels() {
     const apiKey = resolveProviderApiKey(this.name, this.config);
     if (!apiKey) return MODELS;

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,
+  };
 }
 
 /**

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

@@ -36,8 +36,18 @@ function retiredModelError(err, streamedText, model) {
  * @param {Function|null} deps.onToolCall
  * @param {Function|null} deps.onTextDelta
  * @param {Function|null} deps.onStreamDelta
+ * @param {Function|null} [deps.onReasoningDelta]  receives thought-summary text
+ * @param {Function|null} [deps.retractReasoning]  drops thinking a dead attempt already showed
  */
-export function createAntigravityStreamCollector({ tools, useModel, onToolCall, onTextDelta, onStreamDelta }) {
+export function createAntigravityStreamCollector({
+  tools,
+  useModel,
+  onToolCall,
+  onTextDelta,
+  onStreamDelta,
+  onReasoningDelta = null,
+  retractReasoning = null,
+}) {
   let textLeakGuard = null;
   let terminalFailure = null;
   // Streamed text is kept so a retirement notice can be told apart from
@@ -66,6 +76,7 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
   // Each attempt starts from an empty record: a replayed request must not
   // inherit the dead attempt's text or failure.
   const beginAttempt = () => {
+    retractReasoning?.();
     textLeakGuard = createGeminiTextLeakGuard({
       knownToolNames: tools?.map((t) => t.name).filter(Boolean) ?? [],
       onTextDelta: relayText,
@@ -80,6 +91,8 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
     textLeakGuard = null;
   };
 
+  const failureUsage = { model: useModel, normalize: normalizeAntigravityUsage };
+
   const consume = async (res, attemptSignal, { firstByteTimeoutMs } = {}) => {
     try {
       return await consumeGeminiRestStreamResponse(res, {
@@ -87,10 +100,11 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
         firstByteTimeoutMs,
         onStreamDelta,
         onTextDelta: relayText,
+        onReasoningDelta,
         onChunk,
         textLeakGuard,
         label: 'Antigravity streamGenerateContent',
-        failureUsage: { model: useModel, normalize: normalizeAntigravityUsage },
+        failureUsage,
         // Cloud Code Assist nests the Gemini payload under
         // `response`; in-band error events stay top level.
         unwrapChunk: (chunk) => (chunk && typeof chunk === 'object' && chunk.response ? chunk.response : chunk),
@@ -105,6 +119,7 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
     beginAttempt,
     releaseGuard,
     consume,
+    failureUsage,
     get leakGuard() {
       return textLeakGuard;
     },