mixdog 1.2.3 → 1.2.4

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,

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

@@ -6,15 +6,22 @@
  * account-verification URL Google hides in the error details), and the
  * per-attempt hand-off of the live stream to the turn collector.
  */
-import { emitProviderRetryStage, markProviderRecoveryExhausted, sleepWithAbort, withRetry } from './retry-classifier.mjs';
+import {
+  emitProviderRetryStage,
+  markProviderRecoveryExhausted,
+  sleepWithAbort,
+  withRetry,
+} from './retry-classifier.mjs';
 import {
   ANTIGRAVITY_RETRY,
+  ANTIGRAVITY_UNCLASSED_FIRST_BYTE,
   antigravity429WaitMs,
   isAntigravityCapacityError,
 } from './antigravity-retry-policy.mjs';
-import { createTimeoutSignal } from '../stall-policy.mjs';
+import { createTimeoutSignal, firstByteWindowMs } from '../stall-policy.mjs';
+import { MODEL_THINKING_STAGE } from '../../../shared/quiet-progress.mjs';
+import { TIMEOUT_PHASE, isFirstByteTimeout } from '../../../shared/provider-timeout-phase.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
-import { GEMINI_FIRST_BYTE_TIMEOUT_MS } from './gemini-stream.mjs';
 import { _scrubTokens } from './antigravity-oauth-tokens.mjs';
 import { applyGeminiErrorContract } from './gemini-error-contract.mjs';
 import { DETERMINISTIC_KINDS, providerErrorKind } from './provider-error-kind.mjs';
@@ -77,8 +84,10 @@ export function antigravityError(res, text, endpoint) {
     .map((link) => link?.url)
     .find((url) => typeof url === 'string' && url.length > 0);
   const metadataUrl = (key) =>
-    detailEntries.find((entry) => entry?.reason === 'VALIDATION_REQUIRED' && typeof entry.metadata?.[key] === 'string' && entry.metadata[key])
-      ?.metadata[key];
+    detailEntries.find(
+      (entry) =>
+        entry?.reason === 'VALIDATION_REQUIRED' && typeof entry.metadata?.[key] === 'string' && entry.metadata[key]
+    )?.metadata[key];
   const validationUrl =
     helpUrl ||
     metadataUrl('validation_url') ||
@@ -105,19 +114,53 @@ export function antigravityError(res, text, endpoint) {
  * @param {object} deps.opts  send options (stage heartbeat)
  * @param {AbortSignal|null} deps.signal  retry-loop signal (session pass-through)
  * @param {{ beginAttempt: Function, consume: Function }} deps.collector
+ * @param {{ timeoutMs: number, maxMs: number, retries: number|null }} [deps.firstByte]
+ *   first-byte window per attempt (antigravityFirstBytePolicy)
  * @returns {() => Promise<object>} one retried request that resolves the final payload
  */
-export function createAntigravityRequest({ fetchFn, endpoint, headers, body, opts, signal, collector, sleepFn }) {
+export function createAntigravityRequest({
+  fetchFn,
+  endpoint,
+  headers,
+  body,
+  opts,
+  signal,
+  collector,
+  sleepFn,
+  firstByte = ANTIGRAVITY_UNCLASSED_FIRST_BYTE,
+}) {
   const log = (attempt, lastErr, delayMs) => {
+    // A first-byte timeout runs on its own, shorter retry budget.
+    const firstByteLimited = isFirstByteTimeout(lastErr) && firstByte.retries != null;
     emitProviderRetryStage(opts.onStageChange, {
       attempt: attempt + 1,
-      maxAttempts: ANTIGRAVITY_RETRY.maxAttempts,
+      maxAttempts: firstByteLimited
+        ? Math.min(ANTIGRAVITY_RETRY.maxAttempts, firstByte.retries + 1)
+        : ANTIGRAVITY_RETRY.maxAttempts,
       lastErr,
       delayMs,
     });
     process.stderr.write(`[antigravity] retry ${attempt + 1} after ${lastErr?.message || 'transient error'}\n`);
   };
-  const attemptOnce = () =>
+  // Stamps what the attempt tells the user: how many attempts ran and, for a
+  // first-byte timeout, how long the model was given in total. A timeout past
+  // the first-byte retry budget ends the ladder here. A caller's cancellation
+  // reason may be shared by other requests and is never stamped.
+  const noteFailure = (err, { attemptSignal, windowMs, send }) => {
+    if (!err || typeof err !== 'object' || attemptSignal?.aborted) return err;
+    send.attempts += 1;
+    err.attempts = send.attempts;
+    if (!isFirstByteTimeout(err)) return err;
+    send.firstByteTimeouts += 1;
+    send.firstByteWaitedMs += windowMs;
+    err.waitedMs = send.firstByteWaitedMs;
+    err.providerLabel = 'Antigravity';
+    if (firstByte.retries != null && send.firstByteTimeouts > firstByte.retries) {
+      markProviderRecoveryExhausted(err, { owner: 'antigravity-first-byte', attempts: send.attempts, terminal: true });
+    }
+    return err;
+  };
+  const attemptOnce = (send) =>
     withRetry(
       async ({ signal: attemptSignal }) => {
         try {
@@ -125,37 +168,63 @@ export function createAntigravityRequest({ fetchFn, endpoint, headers, body, opt
         } catch {
           /* heartbeat */
         }
-        const firstByte = createTimeoutSignal(attemptSignal, GEMINI_FIRST_BYTE_TIMEOUT_MS, 'Antigravity first byte');
-        let res;
+        const windowMs = firstByteWindowMs(firstByte, send.firstByteTimeouts);
         try {
-          res = await fetchFn(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
-            method: 'POST',
-            headers,
-            body,
-            signal: firstByte.signal,
-            dispatcher: getLlmDispatcher(),
-          });
-        } catch (err) {
-          // Fetch surfaces AbortError; rethrow the timer/parent
-          // reason so same-host retry sees EPROVIDERTIMEOUT and
-          // a caller cancel stays a cancel.
-          if (firstByte.signal.aborted && firstByte.signal.reason instanceof Error) {
-            throw firstByte.signal.reason;
+          const firstByteTimer = createTimeoutSignal(attemptSignal, windowMs, 'Antigravity first byte');
+          let res;
+          try {
+            const response = fetchFn(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+              method: 'POST',
+              headers,
+              body,
+              signal: firstByteTimer.signal,
+              dispatcher: getLlmDispatcher(),
+            });
+            // The request is on the wire and its headers are pending: the
+            // gateway sends them only with the first chunk, so this wait is
+            // the model's queueing and thinking time.
+            try {
+              opts.onStageChange?.(MODEL_THINKING_STAGE);
+            } catch {
+              /* heartbeat */
+            }
+            res = await response;
+          } catch (err) {
+            // Fetch surfaces AbortError; rethrow the timer/parent
+            // reason so same-host retry sees EPROVIDERTIMEOUT and
+            // a caller cancel stays a cancel.
+            if (firstByteTimer.signal.aborted && firstByteTimer.signal.reason instanceof Error) {
+              const reason = firstByteTimer.signal.reason;
+              if (!attemptSignal?.aborted) reason.timeoutPhase = TIMEOUT_PHASE.HEADERS;
+              throw reason;
+            }
+            throw err;
+          } finally {
+            firstByteTimer.cleanup();
           }
-          throw err;
-        } finally {
-          firstByte.cleanup();
-        }
-        if (!res.ok) {
-          const text = await res.text().catch(() => '');
-          const failure = antigravityError(res, text, endpoint);
-          // Capacity is paced by the local schedule below; the generic loop
-          // would sleep whatever wait the server names.
-          if (isCapacityFailure(failure)) markProviderRecoveryExhausted(failure, { owner: 'antigravity-capacity' });
-          throw failure;
+          // Headers arrived: the connection is live even while the model
+          // has not produced its first chunk.
+          try {
+            opts.onStreamDelta?.('transport');
+          } catch {}
+          if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            const failure = antigravityError(res, text, endpoint);
+            // Capacity is paced by the local schedule below; the generic loop
+            // would sleep whatever wait the server names.
+            if (isCapacityFailure(failure)) markProviderRecoveryExhausted(failure, { owner: 'antigravity-capacity' });
+            throw failure;
+          }
+          try {
+            opts.onStageChange?.('streaming');
+          } catch {
+            /* heartbeat */
+          }
+          collector.beginAttempt();
+          return await collector.consume(res, attemptSignal, { firstByteTimeoutMs: windowMs });
+        } catch (err) {
+          throw noteFailure(err, { attemptSignal, windowMs, send });
         }
-        collector.beginAttempt();
-        return collector.consume(res, attemptSignal);
       },
       {
         ...ANTIGRAVITY_RETRY,
@@ -170,9 +239,10 @@ export function createAntigravityRequest({ fetchFn, endpoint, headers, body, opt
   // gets one quick retry, a spent quota surfaces.
   return async () => {
     const state = { capacityRetries: 0, quickRetried: false };
+    const send = { attempts: 0, firstByteTimeouts: 0, firstByteWaitedMs: 0 };
     for (let tried = 1; ; tried++) {
       try {
-        return await attemptOnce();
+        return await attemptOnce(send);
       } catch (err) {
         const waitMs = antigravity429WaitMs(err, state);
         if (waitMs == null) {

package/src/runtime/agent/orchestrator/providers/command-code-oauth.mjs

@@ -79,7 +79,10 @@ export function modelEndpoints(item) {
 // The route for a model with these declared endpoints (null: undeclared, Chat).
 // `undefined`: nothing describes the model, so no wire is ruled out.
 function commandCodeRoute(model, endpoints, ctx = {}) {
-  return resolveWireRoute(PROVIDER_ID, model, { ...ctx, endpoints: endpoints === undefined ? null : (endpoints ?? ['chat']) });
+  return resolveWireRoute(PROVIDER_ID, model, {
+    ...ctx,
+    endpoints: endpoints === undefined ? null : (endpoints ?? ['chat']),
+  });
 }
 
 /**

package/src/runtime/agent/orchestrator/providers/cursor-auth.mjs

@@ -366,7 +366,9 @@ export async function resolveCursorOAuthAccessToken({ forceRefresh = false, fetc
               try {
                 saveCredentials({ ...persisted, reauth_required: true });
               } catch (saveError) {
-                process.stderr.write(`[cursor-oauth] dead-account mark failed: ${String(saveError?.message || saveError).slice(0, 200)}\n`);
+                process.stderr.write(
+                  `[cursor-oauth] dead-account mark failed: ${String(saveError?.message || saveError).slice(0, 200)}\n`
+                );
               }
             }
           }