mixdog 1.2.3 → 1.2.5

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

@@ -2,55 +2,37 @@
 // /v1/messages returns 200 for Content-Encoding: gzip, 400 for zstd). Large turn
 // bodies (system prompt + history, typically 50-100KB+) compress ~5-10x,
 // trimming upload time off every call's header wait. Env kill-switch
-// (MIXDOG_ANTHROPIC_REQ_GZIP=0) plus a process-wide latch flipped on the first
-// 400 seen on a compressed request; small bodies skip compression since below
-// ~8KB the CPU + header cost outweighs the upload saving.
-import { promisify } from 'node:util';
-import { gzip } from 'node:zlib';
+// (MIXDOG_ANTHROPIC_REQ_GZIP=0); the gzip policy (8KB floor, fail-open,
+// 400/415 plain resend + latch-on-success) lives in lib/request-compression.mjs.
 import { getLlmDispatcher } from '../../../../shared/llm/http-agent.mjs';
 import { claudeCliUserAgent } from '../anthropic-oauth-client-version.mjs';
 import { ANTHROPIC_VERSION } from '../lib/anthropic-models.mjs';
+import { sendGzipCompressed } from '../lib/request-compression.mjs';
 
 const API_URL = 'https://api.anthropic.com/v1/messages';
 export { ANTHROPIC_VERSION };
 
-const ANTHROPIC_REQ_GZIP_MIN_BYTES = 8 * 1024;
-let gzipLatchedOff = false;
-const gzipDisabled = () => gzipLatchedOff || process.env.MIXDOG_ANTHROPIC_REQ_GZIP === '0';
-// Compress on the libuv threadpool so large turn bodies never block the main thread.
-const gzipAsync = promisify(gzip);
-
-export async function postMessages({ accessToken, requestBody, betaHeaders, signal }) {
-  const rawBody = Buffer.from(JSON.stringify(requestBody));
-  const useGzip = !gzipDisabled() && rawBody.length >= ANTHROPIC_REQ_GZIP_MIN_BYTES;
-  const sendAttempt = async (gz) =>
-    fetch(API_URL, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        'anthropic-version': ANTHROPIC_VERSION,
-        'anthropic-beta': betaHeaders,
-        'anthropic-dangerous-direct-browser-access': 'true',
-        'user-agent': claudeCliUserAgent(),
-        'x-app': 'cli',
-        'Content-Type': 'application/json',
-        ...(gz ? { 'Content-Encoding': 'gzip' } : {}),
-      },
-      body: gz ? await gzipAsync(rawBody) : rawBody,
-      signal,
-      dispatcher: getLlmDispatcher(),
-    });
-  let response = await sendAttempt(useGzip);
-  if (useGzip && response.status === 400) {
-    // Latch OFF process-wide and retry this attempt uncompressed, so a
-    // server-side behavior change can never wedge the session.
-    gzipLatchedOff = true;
-    try {
-      await response.arrayBuffer();
-    } catch {
-      /* drain best-effort */
-    }
-    response = await sendAttempt(false);
-  }
-  return response;
+export async function postMessages({ accessToken, requestBody, betaHeaders, signal, compress }) {
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    'anthropic-version': ANTHROPIC_VERSION,
+    'anthropic-beta': betaHeaders,
+    'anthropic-dangerous-direct-browser-access': 'true',
+    'user-agent': claudeCliUserAgent(),
+    'x-app': 'cli',
+    'Content-Type': 'application/json',
+  };
+  return sendGzipCompressed({
+    raw: Buffer.from(JSON.stringify(requestBody)),
+    headers,
+    compress,
+    send: (body, sendHeaders) =>
+      fetch(API_URL, {
+        method: 'POST',
+        headers: sendHeaders,
+        body,
+        signal,
+        dispatcher: getLlmDispatcher(),
+      }),
+  });
 }

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

@@ -90,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`);
@@ -676,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.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 } : {}),

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 {

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

@@ -60,9 +60,8 @@ function coalesceClaudeThoughts(parts) {
       out.push(part);
       continue;
     }
-    open = open
-      ? { ...open, ...part, text: `${open.text}${typeof part.text === 'string' ? part.text : ''}` }
-      : { ...part, text: typeof part.text === 'string' ? part.text : '' };
+    const partText = typeof part.text === 'string' ? part.text : '';
+    open = open ? { ...open, ...part, text: `${open.text}${partText}` } : { ...part, text: partText };
     if (typeof part.thoughtSignature === 'string') {
       out.push(open);
       open = null;
@@ -72,6 +71,30 @@ function coalesceClaudeThoughts(parts) {
   return out;
 }
 
+// The validator-bypass sentinel is a Gemini wire token: the Claude bridge
+// sends a thinking block carrying it (or no signature at all) without a
+// signature and Anthropic rejects the request ("thinking.signature: Field
+// required"). Only a signature this route recorded is replayed to Claude;
+// any other signature is removed, and a thinking block left without one (an
+// interrupted run, another model's or provider's turn, legacy metadata) is
+// dropped rather than turned into visible text.
+const hasOwnClaudeSignature = (part) =>
+  typeof part.thoughtSignature === 'string' &&
+  part.thoughtSignature !== '' &&
+  part.thoughtSignature !== THOUGHT_SIGNATURE_SENTINEL;
+
+function claudeReplayParts(parts, own) {
+  const signed = parts.map((part) => {
+    if (!part || typeof part !== 'object' || !('thoughtSignature' in part)) return part;
+    if (own && hasOwnClaudeSignature(part)) return part;
+    const { thoughtSignature: _foreign, ...unsigned } = part;
+    return unsigned;
+  });
+  return coalesceClaudeThoughts(signed.filter((part) => !isEmptyPlainTextPart(part))).filter(
+    (part) => part?.thought !== true || hasOwnClaudeSignature(part)
+  );
+}
+
 function signatureSafeMessages(messages, model) {
   const claude = isAntigravityClaude(model);
   return messages.flatMap((message) => {
@@ -80,11 +103,8 @@ function signatureSafeMessages(messages, model) {
     // Repair tool signatures only after the complete history establishes
     // the active turn, not while normalizing an isolated older message.
     const sourceParts = ownParts || toGeminiContents([message], model, { repairToolSignatures: false })[0]?.parts;
-    const parts =
-      claude && sourceParts
-        ? coalesceClaudeThoughts(sourceParts.filter((part) => !isEmptyPlainTextPart(part)))
-        : sourceParts;
-    // A turn that held only empty parts is omitted, not sent as parts:[].
+    const parts = claude && sourceParts ? claudeReplayParts(sourceParts, !!ownParts) : sourceParts;
+    // A turn that held only empty or dropped parts is omitted, not sent as parts:[].
     if (sourceParts?.length && !parts.length) return [];
     if (!parts?.length) return [message];
     for (const part of parts) {
@@ -100,6 +120,56 @@ function signatureSafeMessages(messages, model) {
   });
 }
 
+const isToolResultTurn = (content) =>
+  content?.role === 'user' && !!content.parts?.some((part) => part?.functionResponse);
+const isPromptTurn = (content) => content?.role === 'user' && !isToolResultTurn(content);
+const hasSignedThinking = (content) =>
+  !!content?.parts?.some((part) => part?.thought === true && hasOwnClaudeSignature(part));
+
+// With thinking on, Claude rejects a tool loop whose turn did not open with a
+// signed thinking block, and a block that was dropped (unsigned, foreign or
+// compacted away) cannot be restored. The outgoing request closes that loop
+// instead: the closed part loses its thinking, a short model reply
+// acknowledges the tool results, and a user nudge opens a fresh turn that
+// Claude starts with new thinking. The closure sits after the results of the
+// turn's last unthought model message, so later steps keep the signed
+// thinking that the fresh turn produced. Wire-only: the caller's messages and
+// recorded replays are never touched.
+function closeUnthoughtToolLoop(contents) {
+  if (!isToolResultTurn(contents.at(-1))) return contents;
+  const promptIndex = contents.findLastIndex(isPromptTurn);
+  const modelIndexes = [];
+  for (let index = promptIndex + 1; index < contents.length; index += 1) {
+    if (contents[index]?.role === 'model') modelIndexes.push(index);
+  }
+  if (!modelIndexes.length || hasSignedThinking(contents[modelIndexes[0]])) return contents;
+  const unthought = modelIndexes.findLast((index) => !hasSignedThinking(contents[index]));
+  let cut = unthought + 1;
+  let results = 0;
+  while (isToolResultTurn(contents[cut])) {
+    results += contents[cut].parts.filter((part) => part?.functionResponse).length;
+    cut += 1;
+  }
+  if (!results) return contents;
+  const closed = contents.slice(0, cut).flatMap((content) => {
+    if (content?.role !== 'model') return [content];
+    const parts = content.parts.filter((part) => part?.thought !== true);
+    return parts.length ? [{ ...content, parts }] : [];
+  });
+  const ack = results === 1 ? '[Tool result received.]' : `[${results} tool results received.]`;
+  return [
+    ...closed,
+    { role: 'model', parts: [{ text: ack }] },
+    { role: 'user', parts: [{ text: '[Continue.]' }] },
+    ...contents.slice(cut),
+  ];
+}
+
+// The request turns Claude thinking on through an effort level or token
+// budget; a `-thinking` wire id thinks without either.
+const claudeThinkingEnabled = (model, thinkingConfig) =>
+  !!(thinkingConfig.thinkingLevel || thinkingConfig.thinkingBudget) || /-thinking$/i.test(String(model));
+
 function sessionId(contents) {
   const first = contents.find((content) => content?.role === 'user');
   const text = first?.parts?.map((part) => (typeof part?.text === 'string' ? part.text : '')).join('') || '';
@@ -155,10 +225,11 @@ export function buildAntigravityRequest(messages, model, tools, opts = {}, proje
     .map((message) => message.content)
     .join('\n\n');
   const chatMessages = messages.filter((message) => message.role !== 'system');
-  const contents = toGeminiContents(signatureSafeMessages(chatMessages, model), model);
-  if (!contents.length) throw new Error('No messages to send');
+  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 contents = claude && claudeThinkingEnabled(model, thinkingConfig) ? closeUnthoughtToolLoop(history) : history;
   const generationConfig = {
     ...(claude ? { maxOutputTokens: CLAUDE_MAX_OUTPUT_TOKENS } : {}),
     ...(thinkingConfig ? { thinkingConfig } : {}),

package/src/runtime/agent/orchestrator/providers/antigravity-retry-policy.mjs

@@ -14,11 +14,28 @@
  *     rotate; advice beyond 60s surfaces at once.
  *   QUOTA_EXHAUSTED (and any day/plan window): never retried here.
  *
+ *   First byte: the gateway queues or thinks server-side and sends the
+ *     response headers together with the first chunk, so the window is chosen
+ *     per model class from the catalog `family`: Pro-class Gemini (Pro tiers,
+ *     Argon) waits MIXDOG_ANTIGRAVITY_FIRST_BYTE_TIMEOUT_MS (300s, clamped to
+ *     the provider ceiling PROVIDER_MAX_BEFORE_WARN_MS, 285s by default),
+ *     Flash-class Gemini the shared Gemini window (60s); both apply to the
+ *     headers and again to the first chunk. A header or first-chunk timeout is
+ *     retried at most MIXDOG_ANTIGRAVITY_FIRST_BYTE_RETRIES times (1), each
+ *     retry doubling the window up to that ceiling; connect, 5xx and drop
+ *     failures keep the full ladder (MIXDOG_ANTIGRAVITY_RETRY_MAX_ATTEMPTS, 4
+ *     attempts, at MIXDOG_ANTIGRAVITY_RETRY_BACKOFF_MS 1s / 2s / 4s). Models
+ *     without a Gemini family (Claude, GPT-OSS, unlisted ids) keep the shared
+ *     Gemini window on that ladder.
+ *
  * Replay stays gated by the stream-outcome contract: an attempt that exposed
  * text or dispatched a tool is never re-issued.
  */
 import { readStreamOutcome } from './lib/stream-outcome.mjs';
 import { DETERMINISTIC_KINDS, providerErrorKind } from './provider-error-kind.mjs';
+import { PROVIDER_MAX_BEFORE_WARN_MS, firstBytePolicyBudget, resolveTimeoutMs } from '../stall-policy.mjs';
+import { GEMINI_FIRST_BYTE_TIMEOUT_MS } from './gemini-stream.mjs';
+import { antigravityModelFamily } from './antigravity-oauth-catalog.mjs';
 
 export const ANTIGRAVITY_CAPACITY_RETRIES = 3;
 export const ANTIGRAVITY_CAPACITY_BASE_MS = 1000;
@@ -29,21 +46,103 @@ export const ANTIGRAVITY_CAPACITY_BUDGET_MS = 60_000;
 export const ANTIGRAVITY_QUICK_RETRY_MS = 1000;
 export const ANTIGRAVITY_QUICK_RETRY_MAX_ADVICE_MS = 60_000;
 
+const DEFAULT_RETRY_BACKOFF_MS = Object.freeze([1000, 1000, 2000, 4000]);
+
+function envInt(env, name, fallback, min, max) {
+  const raw = env?.[name];
+  if (raw == null || String(raw).trim() === '') return fallback;
+  const n = Number(raw);
+  if (!Number.isInteger(n)) return fallback;
+  return Math.min(Math.max(n, min), max);
+}
+
+function envBackoffMs(env, name) {
+  const raw = String(env?.[name] ?? '').trim();
+  if (!raw) return DEFAULT_RETRY_BACKOFF_MS;
+  const steps = raw.split(',').map((step) => Number(step.trim()));
+  if (!steps.every((step) => Number.isInteger(step) && step >= 0)) return DEFAULT_RETRY_BACKOFF_MS;
+  return Object.freeze(steps);
+}
+
+/**
+ * The same-host ladder for everything that is not a 429, read from the
+ * environment: attempts (1–6), the backoff list (index n is the wait before
+ * attempt n) and how many first-byte timeouts a thinking model may retry.
+ */
+export function resolveAntigravityRetryConfig(env = process.env) {
+  return {
+    maxAttempts: envInt(env, 'MIXDOG_ANTIGRAVITY_RETRY_MAX_ATTEMPTS', ANTIGRAVITY_CAPACITY_RETRIES + 1, 1, 6),
+    backoffMs: envBackoffMs(env, 'MIXDOG_ANTIGRAVITY_RETRY_BACKOFF_MS'),
+    firstByteRetries: envInt(env, 'MIXDOG_ANTIGRAVITY_FIRST_BYTE_RETRIES', 1, 0, 5),
+  };
+}
+
+const RETRY_CONFIG = resolveAntigravityRetryConfig();
+
 // withRetry options for everything that is not a 429: transient transport and
 // 5xx failures use the capacity schedule (the reference has no other same-host
 // retry; the leading duplicate is the sleep-before-attempt index).
 export const ANTIGRAVITY_RETRY = Object.freeze({
-  maxAttempts: ANTIGRAVITY_CAPACITY_RETRIES + 1,
-  backoffMs: Object.freeze([1000, 1000, 2000, 4000]),
+  maxAttempts: RETRY_CONFIG.maxAttempts,
+  backoffMs: RETRY_CONFIG.backoffMs,
   retryJitterRatio: ANTIGRAVITY_CAPACITY_JITTER_RATIO,
   // 429s are handled by antigravity429WaitMs, not the generic loop.
   retry429: false,
 });
 
+export const ANTIGRAVITY_FIRST_BYTE_RETRIES = RETRY_CONFIG.firstByteRetries;
+
+// Pro-class window: 300s requested, clamped to the provider ceiling.
+export const ANTIGRAVITY_FIRST_BYTE_TIMEOUT_MS = resolveTimeoutMs('MIXDOG_ANTIGRAVITY_FIRST_BYTE_TIMEOUT_MS', 300_000, {
+  minMs: 30_000,
+  maxMs: PROVIDER_MAX_BEFORE_WARN_MS,
+});
+
+// First-attempt window per catalog family.
+const FAMILY_FIRST_BYTE_MS = Object.freeze({
+  'gemini-pro': ANTIGRAVITY_FIRST_BYTE_TIMEOUT_MS,
+  'gemini-flash': GEMINI_FIRST_BYTE_TIMEOUT_MS,
+});
+
+// Models without a Gemini family: the shared Gemini window on the ordinary ladder.
+export const ANTIGRAVITY_UNCLASSED_FIRST_BYTE = Object.freeze({
+  timeoutMs: GEMINI_FIRST_BYTE_TIMEOUT_MS,
+  maxMs: GEMINI_FIRST_BYTE_TIMEOUT_MS,
+  retries: null,
+});
+
+/**
+ * First-byte policy (see firstByteWindowMs) for one model, picker or wire id.
+ * The class comes from the catalog record's `family`.
+ */
+export function antigravityFirstBytePolicy(model, models) {
+  const timeoutMs = FAMILY_FIRST_BYTE_MS[antigravityModelFamily(model, models)];
+  if (!timeoutMs) return ANTIGRAVITY_UNCLASSED_FIRST_BYTE;
+  return {
+    timeoutMs,
+    maxMs: PROVIDER_MAX_BEFORE_WARN_MS,
+    retries: Math.min(ANTIGRAVITY_FIRST_BYTE_RETRIES, ANTIGRAVITY_RETRY.maxAttempts - 1),
+  };
+}
+
+/**
+ * Longest a send may wait before its first output across the whole transport
+ * ladder ({ transportMs, semanticMs }, see firstBytePolicyBudget): the agent
+ * watchdog must not fire inside it. Drops and 5xx share the ladder with
+ * first-byte timeouts, so the budget is every backoff step of the ladder plus
+ * the windows of the first-byte timeouts the policy permits (all attempts for
+ * a policy without its own retry cap).
+ */
+export function antigravityFirstResponseBudget(policy, backoffMs = ANTIGRAVITY_RETRY.backoffMs) {
+  return firstBytePolicyBudget(policy, { attempts: ANTIGRAVITY_RETRY.maxAttempts, backoffMs });
+}
+
 /** Capacity wait for retry number `retryIndex` (0-based): 1s, 2s, 4s, 8s cap, ±10%. */
-export function antigravityCapacityDelayMs(retryIndex) {
+function antigravityCapacityDelayMs(retryIndex) {
   const base = Math.min(ANTIGRAVITY_CAPACITY_BASE_MS * 2 ** retryIndex, ANTIGRAVITY_CAPACITY_MAX_MS);
-  return Math.round(base * (1 - ANTIGRAVITY_CAPACITY_JITTER_RATIO + Math.random() * 2 * ANTIGRAVITY_CAPACITY_JITTER_RATIO));
+  return Math.round(
+    base * (1 - ANTIGRAVITY_CAPACITY_JITTER_RATIO + Math.random() * 2 * ANTIGRAVITY_CAPACITY_JITTER_RATIO)
+  );
 }
 
 export function isAntigravityCapacityError(err) {
@@ -60,7 +159,12 @@ export function antigravity429WaitMs(err, state) {
   if (status !== 429 && !(capacity && (status === 503 || status === 529))) return null;
   if (readStreamOutcome(err).replaySafe !== true) return null;
   const { kind, retryAfterMs } = providerErrorKind(err);
-  if (DETERMINISTIC_KINDS.has(kind) || err.code === 'quota_exhausted' || err.quotaScope === 'day' || err.quotaScope === 'plan') {
+  if (
+    DETERMINISTIC_KINDS.has(kind) ||
+    err.code === 'quota_exhausted' ||
+    err.quotaScope === 'day' ||
+    err.quotaScope === 'plan'
+  ) {
     return null;
   }
   // Capacity waits at least the advised RetryInfo delay (the local schedule

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

@@ -80,10 +80,11 @@ export function createAntigravityStreamCollector({ tools, useModel, onToolCall,
     textLeakGuard = null;
   };
 
-  const consume = async (res, attemptSignal) => {
+  const consume = async (res, attemptSignal, { firstByteTimeoutMs } = {}) => {
     try {
       return await consumeGeminiRestStreamResponse(res, {
         signal: attemptSignal,
+        firstByteTimeoutMs,
         onStreamDelta,
         onTextDelta: relayText,
         onChunk,