mixdog 1.2.2 → 1.2.4

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

@@ -55,6 +55,7 @@ import { applyAnthropicEffortToBody, shouldIncludeEffortBeta } from './anthropic
 import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-rejection.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import {
+  anthropicThinkingActive,
   applyAnthropicCacheMarkers,
   clampAnthropicThinkingBudget as clampThinkingBudgetTokens,
   deferredAnthropicTools as sharedDeferredAnthropicTools,
@@ -62,6 +63,7 @@ import {
   resolveAnthropicCacheTtls as resolveCacheTtls,
   resolveAnthropicMessageCacheSlots,
   sanitizeAnthropicInputSchema,
+  sharedCachePrefixBoundary,
   toAnthropicMessages,
   toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
@@ -88,8 +90,7 @@ const _oauthRefreshes = new Map();
 // Anthropic OAuth contract for first-party OAuth clients: Claude requests
 // are gated on this exact system-prompt prefix (Haiku 5.5 included).
 const CLAUDE_CODE_SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
-const OAUTH_BETA_HEADERS =
-  'oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,extended-cache-ttl-2025-04-11';
+const OAUTH_BETA_HEADERS = 'oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27';
 
 function logQuiet(line) {
   if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] ${line}\n`);
@@ -168,8 +169,8 @@ function buildSystemBlocks(systemMsgs, systemTtl, tier3Ttl) {
 //      clamped to [MAX_TOKENS_FLOOR, safetyCap].
 //   3. Shared model catalog outputTokens, then the floor, when the live
 //      roster has no entry for this model.
-function resolveMaxTokens(model) {
-  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokens });
+function resolveMaxTokens(model, { modelMaxOutputTokens = null } = {}) {
+  return resolveAnthropicMaxTokens(model, { catalogLookup: _catalogOutputTokens, modelMaxOutputTokens });
 }
 
 // --- Message conversion ---
@@ -191,8 +192,8 @@ function requestAnthropicTools(tools, messages, opts) {
 function buildRequestBody(messages, model, tools, sendOpts) {
   const systemMsgs = messages.filter((m) => m.role === 'system');
   const chatMsgs = messages.filter((m) => m.role !== 'system');
-  const maxTokens = resolveMaxTokens(model);
   const opts = sendOpts || {};
+  const maxTokens = resolveMaxTokens(model, { modelMaxOutputTokens: opts.modelMaxOutputTokens });
   const effortProjection = projectEffortConfiguration(messages, 'anthropic-oauth', model, opts);
   const ttls = resolveCacheTtls(opts);
   // Each system message becomes its own Anthropic content block with its own
@@ -202,18 +203,27 @@ function buildRequestBody(messages, model, tools, sendOpts) {
 
   // Message-tail cache budget (4-BP layout + ANTHROPIC_MSG_SLOTS) is shared
   // with anthropic.mjs — see resolveAnthropicMessageCacheSlots.
-  const messageCacheSlots = resolveAnthropicMessageCacheSlots(systemBlocks, ttls);
   // Tools are resolved BEFORE the messages: the lowering needs the final
   // tool list to drop tool_reference blocks whose tool no longer ships in
   // this request (otherwise the API rejects the whole turn).
   const requestTools = requestAnthropicTools(tools, chatMsgs, opts);
+  const messageCacheSlots = resolveAnthropicMessageCacheSlots(systemBlocks, ttls, { tools: requestTools });
   // Build → sanitize (once, inside toAnthropicMessages) → mark. Markers 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 (see send path).
+  const lowerHistory = (history, projection) =>
+    lowerAnthropicEffortHistory(
+      history.filter((m) => m.role !== 'system'),
+      (segment) => toAnthropicMessages(segment, requestTools),
+      projection
+    );
   const anthropicMessages = applyAnthropicCacheMarkers(
-    lowerAnthropicEffortHistory(chatMsgs, (segment) => toAnthropicMessages(segment, requestTools), effortProjection),
-    messageCacheSlots
+    lowerHistory(chatMsgs, effortProjection),
+    messageCacheSlots,
+    sharedCachePrefixBoundary(messages, opts, (prefix) =>
+      lowerHistory(prefix, projectEffortConfiguration(prefix, 'anthropic-oauth', model, opts))
+    )
   );
 
   const body = {
@@ -238,10 +248,8 @@ function buildRequestBody(messages, model, tools, sendOpts) {
   // tool_choice only when tools are actually present (Anthropic rejects
   // tool_choice without tools). 'none' rides the hard-cap final turn to
   // forbid tool USE while keeping the tools prefix stable for cache reuse.
-  if (body.tools) {
-    const toolChoice = toAnthropicToolChoice(opts.toolChoice);
-    if (toolChoice) body.tool_choice = toolChoice;
-  }
+  // Key reserved for wire order; resolved after thinking is applied.
+  if (body.tools) body.tool_choice = undefined;
 
   applyAnthropicEffortToBody(body, {
     model,
@@ -252,6 +260,16 @@ function buildRequestBody(messages, model, tools, sendOpts) {
     progressUpdates: true,
   });
 
+  if (body.tools) {
+    const toolChoice = toAnthropicToolChoice(opts.toolChoice, {
+      thinking: anthropicThinkingActive(body),
+      disableParallelToolUse: opts.disableParallelToolUse === true,
+      onThinkingConflict: opts.toolChoiceThinkingConflict,
+    });
+    if (toolChoice) body.tool_choice = toolChoice;
+    else delete body.tool_choice;
+  }
+
   // Skipped while the fast capacity pool is in cooldown (or permanently
   // unavailable) so a drained pool is not re-probed every turn.
   if (opts.fast === true && supportsAnthropicFastMode(model) && fastModeAvailable()) {
@@ -657,9 +675,7 @@ export class AnthropicOAuthProvider {
       response.status === 400 &&
       opts.fast === true &&
       !opts._fastModeRetry &&
-      fastModeDowngraded(
-        noteFastModeCapacityError({ httpStatus: 400, message: scrubbedText }, { fast: true })
-      )
+      fastModeDowngraded(noteFastModeCapacityError({ httpStatus: 400, message: scrubbedText }, { fast: true }))
     ) {
       process.stderr.write(`[anthropic-oauth] fast mode is not enabled for this account; retrying at standard speed\n`);
       return this.send(messages, useModel, tools, { ...opts, _fastModeRetry: true });

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-blocks.mjs

@@ -36,6 +36,20 @@ export function createTurnBlocks() {
   const appendText = (index, chunk) => {
     text.set(index, (text.get(index) || '') + (chunk || ''));
   };
+  // Per-index citations of a text block (content_block_start `citations` plus
+  // streamed citations_delta), replayed verbatim on the text block they cite.
+  const citations = new Map();
+  const appendCitation = (index, citation) => {
+    if (!citation || typeof citation !== 'object') return;
+    if (!text.has(index)) text.set(index, '');
+    let copy;
+    try {
+      copy = structuredClone(citation);
+    } catch {
+      copy = { ...citation };
+    }
+    citations.set(index, [...(citations.get(index) || []), copy]);
+  };
   // Client tool_use blocks that were actually dispatched, kept for the same
   // ordered replay list (deduped/skipped calls are intentionally absent).
   const clientToolUse = new Map();
@@ -61,7 +75,11 @@ export function createTurnBlocks() {
     ...thinking.entries(),
     ...[...text.entries()].map(([index, value]) => [
       index,
-      { type: 'text', text: typeof value === 'string' ? value : '' },
+      {
+        type: 'text',
+        text: typeof value === 'string' ? value : '',
+        ...(citations.get(index)?.length ? { citations: citations.get(index) } : {}),
+      },
     ]),
     ...completedNativeBlocks(),
     ...clientToolUse.entries(),
@@ -105,6 +123,7 @@ export function createTurnBlocks() {
     pendingToolInputs,
     clientToolUse,
     appendText,
+    appendCitation,
     toolInputInFlight,
     orderedThinkingBlocks,
     orderedAssistantBlocks,

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/content-block-delta.mjs

@@ -88,14 +88,27 @@ export function createContentBlockDelta({ turn, blocks, state, leak, relayText,
     progress('tool');
   };
 
-  return (index, delta) => {
+  const stampTtft = () => {
+    if (state && !state.ttftAt) state.ttftAt = Date.now();
+  };
+
+  const onContentBlockDelta = (index, delta) => {
     if (delta?.type) turn.contentBlockTypes.add(delta.type);
     // Time-to-first-token: stamp the first content delta (text / thinking /
     // tool input_json) exactly once so the SSE trace can separate first-byte
     // latency from total stream/generation time.
-    if (state && !state.ttftAt) state.ttftAt = Date.now();
+    stampTtft();
     if (delta?.type === 'text_delta') onTextDelta(index, delta.text);
+    if (delta?.type === 'citations_delta') blocks.appendCitation(index, delta.citation);
     if (delta?.type === 'thinking_delta' || delta?.type === 'signature_delta') onThinkingDelta(index, delta);
     if (delta?.type === 'input_json_delta') onInputJsonDelta(index, delta.partial_json);
   };
+  // A text block may open with non-empty `text` on content_block_start: it is
+  // model output and takes the same path as a text_delta (live relay, leak
+  // guard, returned content, ordered replay copy).
+  onContentBlockDelta.seedText = (index, initialText) => {
+    stampTtft();
+    onTextDelta(index, initialText);
+  };
+  return onContentBlockDelta;
 }

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/content-block-start.mjs

@@ -19,7 +19,7 @@ function cloneNativeBlock(block) {
   }
 }
 
-export function createContentBlockStart({ turn, blocks, state, progress }) {
+export function createContentBlockStart({ turn, blocks, state, progress, seedText }) {
   const seedThinkingBlock = (index, block) => {
     if (block.type === 'redacted_thinking') {
       // Opaque redacted payload: real reasoning content, exposed as a block.
@@ -61,9 +61,16 @@ export function createContentBlockStart({ turn, blocks, state, progress }) {
       });
     }
     if (block?.type === 'text') {
-      // Seed the ordered text slot (a text block may open with a non-empty
-      // `text` before any delta).
-      blocks.appendText(index, typeof block.text === 'string' ? block.text : '');
+      // Seed the ordered text slot. An empty block still needs its slot (it
+      // separates thinking runs); a non-empty opening `text` is model output
+      // and is routed exactly like a text_delta so it reaches the returned and
+      // live content once.
+      const initialText = typeof block.text === 'string' ? block.text : '';
+      if (initialText) seedText(index, initialText);
+      else blocks.appendText(index, '');
+      if (Array.isArray(block.citations)) {
+        for (const citation of block.citations) blocks.appendCitation(index, citation);
+      }
     }
     if (NATIVE_SERVER_TOOL_CALL_BLOCK_TYPES.has(block?.type)) {
       // Verbatim seed; `input` is completed from the streamed

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/message-events.mjs

@@ -26,6 +26,9 @@ export function createMessageEvents({ turn, blocks, state }) {
     if (event.delta && (event.delta.stop_details != null || event.delta.category != null)) {
       turn.stopDetails = stopDetailsFrom(event.delta);
     }
+    if (event.delta?.stop_sequence != null) {
+      turn.stopSequence = event.delta.stop_sequence;
+    }
     if (event.usage) updateTurnUsage(turn.usage, event.usage);
     // A terminal stop_reason while ANY tool input is still streaming ends the
     // turn truncated, immediately: the model declared it stopped sampling, so

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events.mjs

@@ -21,18 +21,25 @@ export function createTurnEvents({
   labels,
 }) {
   const { onMessageStart, onMessageDelta, onMessageStop } = createMessageEvents({ turn, blocks, state });
+  const onContentBlockDelta = createContentBlockDelta({
+    turn,
+    blocks,
+    state,
+    leak,
+    relayText,
+    progress,
+    relayProgressUpdates,
+  });
   return {
     onMessageStart,
-    onContentBlockStart: createContentBlockStart({ turn, blocks, state, progress }),
-    onContentBlockDelta: createContentBlockDelta({
+    onContentBlockStart: createContentBlockStart({
       turn,
       blocks,
       state,
-      leak,
-      relayText,
       progress,
-      relayProgressUpdates,
+      seedText: onContentBlockDelta.seedText,
     }),
+    onContentBlockDelta,
     onContentBlockStop: createContentBlockStop({ turn, blocks, state, leak, progress, onToolCall, labels }),
     onMessageDelta,
     onMessageStop,

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-outcome.mjs

@@ -138,6 +138,7 @@ export function createTurnOutcome({ turn, blocks, state, labels = OAUTH_STREAM_L
       usage: turn.usage,
       stopReason: turn.stopReason,
       stopDetails: turn.stopDetails,
+      ...(turn.stopSequence != null ? { stopSequence: turn.stopSequence } : {}),
       hasThinkingContent: turn.hasThinkingContent,
       contentBlockTypes: Array.from(turn.contentBlockTypes),
       // Ordered extended-thinking blocks (verbatim thinking text + signature)

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-state.mjs

@@ -5,6 +5,8 @@
  * module of the turn reads and writes this one object; nothing about the
  * turn's progress is hidden in a closure.
  */
+import { reportedCostUsd } from '../lib/usage-primitives.mjs';
+import { normalizeServerToolUse } from '../lib/anthropic-server-tool-usage.mjs';
 
 export function createAnthropicTurnState() {
   return {
@@ -16,6 +18,9 @@ export function createAnthropicTurnState() {
     usage: { inputTokens: 0, outputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, raw: null },
     stopReason: null,
     stopDetails: undefined,
+    // The custom stop sequence that ended the turn (message_delta
+    // delta.stop_sequence); stays undefined unless the API reports one.
+    stopSequence: undefined,
     fallbackEvents: [],
     // Set when a terminal frame (message_delta stop_reason / message_stop)
     // arrived while tool input was still in flight — used only to word the
@@ -35,6 +40,15 @@ export function updateTurnUsage(usage, raw) {
   if (raw.cache_creation?.ephemeral_1h_input_tokens != null) {
     usage.cacheWrite1hTokens = raw.cache_creation.ephemeral_1h_input_tokens;
   }
+  // A gateway's reported cost (OpenRouter puts `cost` on the final usage). It
+  // rides the turn usage itself, so a success, an abandoned attempt and a
+  // failure's partial usage all carry it to the provider-boundary ledger.
+  const costUsd = reportedCostUsd(raw.cost);
+  if (costUsd !== undefined) usage.costUsd = costUsd;
+  // Server-tool counters are cumulative in message_delta; a later report
+  // replaces the earlier one, an absent one preserves it.
+  const serverToolUse = normalizeServerToolUse(raw);
+  if (serverToolUse) usage.serverToolUse = serverToolUse;
   usage.raw = { ...(usage.raw || {}), ...raw };
   // Input excludes cache; all three slots contribute to prompt volume.
   usage.promptTokens = usage.inputTokens + usage.cachedTokens + usage.cacheWriteTokens;

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

@@ -75,9 +75,11 @@ const ANTHROPIC_SSE_ERROR_TYPE_STATUS = new Map([
   ['authentication_error', 401],
   ['permission_error', 403],
   ['not_found_error', 404],
+  ['conflict_error', 409],
   ['request_too_large', 413],
   ['rate_limit_error', 429],
   ['api_error', 500],
+  ['timeout_error', 504],
   ['overloaded_error', 529],
 ]);
 

package/src/runtime/agent/orchestrator/providers/anthropic-turn-result.mjs

@@ -10,6 +10,7 @@
  * account for usage identically.
  */
 import { traceAgentUsage } from '../agent-trace.mjs';
+import { reportedCostUsd } from './lib/usage-primitives.mjs';
 
 /**
  * @param {object} parseResult  the assembled turn (streaming or normalized non-streaming)
@@ -26,6 +27,7 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
   const output = parseResult.usage?.outputTokens || 0;
   const promptTokens = parseResult.usage?.promptTokens ?? input + cacheRead + cacheWrite;
   const liveModel = parseResult.model || useModel;
+  const costUsd = parseResult.usage?.costUsd ?? reportedCostUsd(usageRaw?.cost);
 
   if (usageRaw || input || output || cacheRead || cacheWrite) {
     traceAgentUsage({
@@ -53,6 +55,8 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
     model: liveModel,
     toolCalls: parseResult.toolCalls,
     stopReason: parseResult.stopReason || null,
+    ...(parseResult.stopDetails != null ? { stopDetails: parseResult.stopDetails } : {}),
+    ...(parseResult.stopSequence != null ? { stopSequence: parseResult.stopSequence } : {}),
     hasThinkingContent: !!parseResult.hasThinkingContent,
     contentBlockTypes: Array.isArray(parseResult.contentBlockTypes) ? parseResult.contentBlockTypes : [],
     // Round-trip adaptive-thinking blocks (verbatim thinking +
@@ -84,6 +88,11 @@ export function buildAnthropicTurnResult(parseResult, { provider, useModel, opts
       cacheWriteTokens: cacheWrite,
       ...(parseResult.usage?.cacheWrite1hTokens ? { cacheWrite1hTokens: parseResult.usage.cacheWrite1hTokens } : {}),
       promptTokens,
+      // A gateway-reported cost (OpenRouter `usage.cost`), when the turn has one.
+      ...(costUsd !== undefined ? { costUsd } : {}),
+      ...(parseResult.usage?.serverToolUse ? { serverToolUse: parseResult.usage.serverToolUse } : {}),
+      // Raw provider usage (incl. server_tool_use counters), as on the OAuth path.
+      ...(usageRaw ? { raw: usageRaw } : {}),
     },
   };
 }

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

@@ -13,6 +13,7 @@ import { ANTHROPIC_MAX_MIDSTREAM_RETRIES, parseSSEStream } from './anthropic-sse
 import { buildAnthropicBetaHeaders } from './anthropic-betas.mjs';
 import { buildAnthropicApiRequest } from './anthropic-api-request.mjs';
 import { isCustomProviderName } from './custom-reasoning.mjs';
+import { createAnthropicApiKeyFetch } from './anthropic-api-key-fetch.mjs';
 import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-rejection.mjs';
 import { armFirstByteWatchdog, createAnthropicApiTransport } from './anthropic-api-transport.mjs';
 import { createAnthropicApiRecovery } from './anthropic-api-recovery.mjs';
@@ -75,6 +76,9 @@ export class AnthropicProvider {
     return new (loadAnthropic())({
       ...credentials,
       ...(this.config.baseURL ? { baseURL: this.config.baseURL } : {}),
+      // Gzip only toward the official origin (decided per request URL); a
+      // custom-* gateway keeps the SDK's plain fetch.
+      ...(custom ? {} : { fetch: createAnthropicApiKeyFetch() }),
       defaultHeaders: {
         ...(betaHeaders ? { 'anthropic-beta': betaHeaders } : {}),
         ...(keyless ? { 'x-api-key': null, authorization: null } : {}),
@@ -83,6 +87,11 @@ export class AnthropicProvider {
       maxRetries: 0,
     });
   }
+  // The model id capability lookups (output cap, thinking/effort shape) read;
+  // a gateway engine maps its routing slug to the Claude id it stands for.
+  _capabilityModel(model) {
+    return model;
+  }
   reloadApiKey() {
     try {
       const newKey = reloadProviderApiKey(this.name, this.config);
@@ -149,6 +158,7 @@ export class AnthropicProvider {
       fastModeLatched: this.fastModeBetaHeaderLatched,
       // Custom providers carry per-model reasoning settings on their own rows.
       modelInfo: isCustomProviderName(this.name) ? this.getCachedModelInfo?.(useModel) || null : null,
+      capabilityModel: this._capabilityModel(useModel),
     });
     this.fastModeBetaHeaderLatched = fastModeLatched;
 

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

@@ -193,6 +193,18 @@ function antigravityCatalogModels() {
   return _mirror || ANTIGRAVITY_MODELS;
 }
 
+/**
+ * The catalog `family` ('gemini-pro', 'gemini-flash', 'gpt-oss') of a picker
+ * id or one of its wire ids, or null when no record carries one (Claude, or
+ * an id the catalog does not list).
+ */
+export function antigravityModelFamily(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));
+  return typeof record?.family === 'string' && record.family ? record.family : 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
@@ -228,17 +240,34 @@ function quotaRow(label, bucket) {
   };
 }
 
-/** Shared Gemini 5H/7D rows from retrieveUserQuotaSummary. Missing fields stay omitted. */
+// The gateway's bucket ids; group names are display text and may change.
+const GEMINI_5H_BUCKET_ID = 'gemini-5h';
+const GEMINI_WEEKLY_BUCKET_ID = 'gemini-weekly';
+const ARGON_WEEKLY_BUCKET_ID = 'gemini-argon-wtu-weekly';
+// The "Claude and GPT models" group (Claude Opus, Claude Sonnet, GPT-OSS) has
+// its own pair of buckets, separate from the Gemini counters.
+const THIRD_PARTY_5H_BUCKET_ID = '3p-5h';
+const THIRD_PARTY_WEEKLY_BUCKET_ID = '3p-weekly';
+
+/**
+ * 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.
+ */
 export function antigravityQuotaWindows(summary) {
-  const groups = Array.isArray(summary?.groups) ? summary.groups : [];
-  const group = groups.find((entry) => entry && typeof entry === 'object' && entry.displayName === 'Gemini Models');
-  const buckets = Array.isArray(group?.buckets) ? group.buckets : [];
-  let fiveHour = null;
-  let weekly = null;
-  for (const bucket of buckets) {
-    if (!bucket || typeof bucket !== 'object') continue;
-    if (!fiveHour && bucket.window === '5h') fiveHour = bucket;
-    if (!weekly && bucket.window === 'weekly') weekly = bucket;
-  }
-  return [quotaRow('5H', fiveHour), quotaRow('7D', weekly)].filter(Boolean);
+  const groups = (Array.isArray(summary?.groups) ? summary.groups : []).filter(
+    (entry) => entry && typeof entry === 'object'
+  );
+  const buckets = groups.flatMap((entry) => (Array.isArray(entry.buckets) ? entry.buckets : []));
+  const bucket = (id, window) =>
+    buckets.find((entry) => entry && typeof entry === 'object' && entry.bucketId === id && entry.window === window) ??
+    null;
+  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')),
+  ].filter(Boolean);
 }

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

@@ -20,7 +20,11 @@ import { preconnect } from '../../../shared/llm/http-agent.mjs';
 import { createAntigravityStreamCollector } from './antigravity-stream.mjs';
 import { createAntigravityRequest } from './antigravity-transport.mjs';
 import { finalizeAntigravityTurn } from './antigravity-response.mjs';
-import { ANTIGRAVITY_ACCOUNT_COOLDOWN_POLICY } from './antigravity-retry-policy.mjs';
+import {
+  ANTIGRAVITY_ACCOUNT_COOLDOWN_POLICY,
+  antigravityFirstBytePolicy,
+  antigravityFirstResponseBudget,
+} from './antigravity-retry-policy.mjs';
 import {
   CONTENT_ENDPOINT,
   ANTIGRAVITY_MODELS,
@@ -97,6 +101,13 @@ export class AntigravityOAuthProvider {
     return configured || CONTENT_ENDPOINT;
   }
 
+  // Longest one send to `model` may wait for response headers / first output,
+  // the whole transport retry ladder included; the agent watchdog's
+  // first-response deadlines are floored above it.
+  firstResponseBudget(model) {
+    return antigravityFirstResponseBudget(antigravityFirstBytePolicy(model || DEFAULT_ANTIGRAVITY_MODEL));
+  }
+
   _buildBody(messages, model, tools, opts) {
     const body = buildAntigravityRequest(messages, model, tools, opts, this._projectId);
     dumpAntigravityRequest(body);
@@ -169,6 +180,7 @@ export class AntigravityOAuthProvider {
       signal: passthrough.signal,
       collector,
       sleepFn: this.config.sleepFn,
+      firstByte: antigravityFirstBytePolicy(useModel),
     });
     try {
       try {