mixdog 0.9.174 → 1.0.0

package/src/runtime/agent/orchestrator/providers/anthropic-recovery-guards.mjs

@@ -55,6 +55,13 @@ export function createAnthropicRecoveryGuards({ label, budgetOwner, opts, onText
     const exposedChars = Number(midState?.emittedTextChars) || 0;
     const exposedReasoning = midState?.emittedThinking === true;
     const outcome = readStreamOutcome(streamingError, midState);
+    const refuseReplay = () => {
+      try {
+        streamingError.liveTextEmitted = true;
+        streamingError.unsafeToRetry = true;
+      } catch {}
+      throw streamingError;
+    };
     if (
       !onTextReset ||
       (exposedChars <= 0 && !exposedReasoning) ||
@@ -63,11 +70,7 @@ export function createAnthropicRecoveryGuards({ label, budgetOwner, opts, onText
       outcome.dispatchAmbiguous ||
       outcome.toolCallsComplete > 0
     ) {
-      try {
-        streamingError.liveTextEmitted = true;
-        streamingError.unsafeToRetry = true;
-      } catch {}
-      throw streamingError;
+      refuseReplay();
     }
     let resetAccepted = false;
     try {
@@ -78,13 +81,7 @@ export function createAnthropicRecoveryGuards({ label, budgetOwner, opts, onText
           reason: 'anthropic-streaming-fallback',
         })) === true;
     } catch {}
-    if (!resetAccepted) {
-      try {
-        streamingError.liveTextEmitted = true;
-        streamingError.unsafeToRetry = true;
-      } catch {}
-      throw streamingError;
-    }
+    if (!resetAccepted) refuseReplay();
     requireTransportRecoveryBudget(streamingError, controller);
     return issueNonStreamingFallback(controller, streamingError);
   };

package/src/runtime/agent/orchestrator/providers/anthropic-server-fallback.mjs

@@ -1,3 +1,5 @@
+import { normalizeClaudeModelId } from './anthropic-thinking-contract.mjs';
+
 function normalizedModelId(value) {
   if (typeof value === 'string') return value.trim();
   const raw = value && typeof value === 'object' ? value.model : '';
@@ -5,7 +7,7 @@ function normalizedModelId(value) {
 }
 
 export function supportsAnthropicServerFallback(model) {
-  const id = normalizedModelId(model).toLowerCase().replace(/\./g, '-');
+  const id = normalizeClaudeModelId(normalizedModelId(model));
   return /^claude-(?:opus|fable)-5(?:$|[-@])/.test(id);
 }
 

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

@@ -8,7 +8,7 @@
  * additive: the native tool_use path is untouched.
  */
 import { randomBytes } from 'node:crypto';
-import { scanLeakedToolCalls, createToolCallDedupe, knownToolNameSet } from '../anthropic-leaked-toolcall.mjs';
+import { scanLeakedToolCalls, createToolCallDedupe, knownToolNameSet } from '../lib/leaked-toolcall.mjs';
 
 export function createLeakGuard({ turn, state, knownToolNames, onToolCall, relayText, progress }) {
   const knownTools = knownToolNameSet(knownToolNames);

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

@@ -4,13 +4,8 @@
  * into a dispatched tool call (parsed args, leak dedupe, ordered replay copy,
  * eager dispatch).
  */
-import { makeInvalidToolArgsMarker } from '../../openai-compat-stream.mjs';
-
-const log = (line) => {
-  try {
-    process.stderr.write(`[anthropic-oauth] ${line}\n`);
-  } catch {}
-};
+import { makeInvalidToolArgsMarker } from '../../lib/openai-tool-args.mjs';
+import { OAUTH_STREAM_LABELS } from '../../lib/anthropic-stream-labels.mjs';
 
 // Bare JSON.parse used to throw straight up into the surrounding broad catch,
 // which swallowed the whole tool_call — the loop never saw it and the
@@ -20,7 +15,7 @@ const log = (line) => {
 // be a plain object: Anthropic's tool_use input is always a JSON object, but
 // a malformed stream could parse to an array/string/number — wrap those as {}
 // to keep the contract (invariant-based, no heuristic coercion).
-function parseClientToolArgs(pending) {
+function parseClientToolArgs(pending, log) {
   let parsedArgs = {};
   if (pending.inputJson) {
     try {
@@ -42,7 +37,7 @@ function parseClientToolArgs(pending) {
   return parsedArgs;
 }
 
-function parseNativeToolInput(nativeBlock, rawInput) {
+function parseNativeToolInput(nativeBlock, rawInput, log) {
   let input = nativeBlock.input && typeof nativeBlock.input === 'object' ? nativeBlock.input : {};
   if (rawInput) {
     try {
@@ -58,20 +53,33 @@ function parseNativeToolInput(nativeBlock, rawInput) {
   return input;
 }
 
-export function createContentBlockStop({ turn, blocks, state, leak, progress, onToolCall }) {
+export function createContentBlockStop({
+  turn,
+  blocks,
+  state,
+  leak,
+  progress,
+  onToolCall,
+  labels = OAUTH_STREAM_LABELS,
+}) {
+  const log = (line) => {
+    try {
+      process.stderr.write(`[${labels.tag}] ${line}\n`);
+    } catch {}
+  };
   return (index) => {
     if (blocks.pendingNativeToolInputs.has(index)) {
       const rawInput = blocks.pendingNativeToolInputs.get(index);
       blocks.pendingNativeToolInputs.delete(index);
       const nativeBlock = blocks.nativeServerTool.get(index);
-      if (nativeBlock) nativeBlock.input = parseNativeToolInput(nativeBlock, rawInput);
+      if (nativeBlock) nativeBlock.input = parseNativeToolInput(nativeBlock, rawInput, log);
     }
     const pending = blocks.pendingToolInputs.get(index);
     if (!pending) return;
     const call = {
       id: pending.id,
       name: pending.name,
-      arguments: parseClientToolArgs(pending),
+      arguments: parseClientToolArgs(pending, log),
     };
     blocks.pendingToolInputs.delete(index);
     // Skip the ENTIRE call (push + dispatch) when a text-leaked synthetic of

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

@@ -9,7 +9,17 @@ import { createContentBlockDelta } from './turn-events/content-block-delta.mjs';
 import { createContentBlockStop } from './turn-events/content-block-stop.mjs';
 import { createMessageEvents } from './turn-events/message-events.mjs';
 
-export function createTurnEvents({ turn, blocks, state, leak, relayText, progress, onToolCall, relayProgressUpdates }) {
+export function createTurnEvents({
+  turn,
+  blocks,
+  state,
+  leak,
+  relayText,
+  progress,
+  onToolCall,
+  relayProgressUpdates,
+  labels,
+}) {
   const { onMessageStart, onMessageDelta, onMessageStop } = createMessageEvents({ turn, blocks, state });
   return {
     onMessageStart,
@@ -23,7 +33,7 @@ export function createTurnEvents({ turn, blocks, state, leak, relayText, progres
       progress,
       relayProgressUpdates,
     }),
-    onContentBlockStop: createContentBlockStop({ turn, blocks, state, leak, progress, onToolCall }),
+    onContentBlockStop: createContentBlockStop({ turn, blocks, state, leak, progress, onToolCall, labels }),
     onMessageDelta,
     onMessageStop,
   };

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

@@ -7,9 +7,10 @@
  */
 import { stampStreamOutcome, STREAM_TRANSPORTS } from '../lib/stream-outcome.mjs';
 import { createProviderReplay } from '../lib/provider-replay.mjs';
+import { OAUTH_STREAM_LABELS } from '../lib/anthropic-stream-labels.mjs';
 import { anthropicFallbackProviderMetadata } from '../anthropic-server-fallback.mjs';
 
-export function createTurnOutcome({ turn, blocks, state }) {
+export function createTurnOutcome({ turn, blocks, state, labels = OAUTH_STREAM_LABELS }) {
   const partialFields = () => ({
     partialContent: turn.content,
     partialToolCalls: turn.toolCalls.length ? turn.toolCalls.slice() : undefined,
@@ -85,8 +86,8 @@ export function createTurnOutcome({ turn, blocks, state }) {
     const err = Object.assign(
       new Error(
         (turn.sawTerminalFrameWithPendingInput
-          ? `Anthropic OAuth SSE stream truncated: terminal frame with incomplete tool input`
-          : `Anthropic OAuth SSE stream truncated: message_start without message_stop`) +
+          ? `${labels.display} SSE stream truncated: terminal frame with incomplete tool input`
+          : `${labels.display} SSE stream truncated: message_start without message_stop`) +
           (pendingToolUse ? ` (pending tool_use input)` : '')
       ),
       {

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

@@ -13,6 +13,7 @@ import { createTurnBlocks } from './anthropic-sse-turn/turn-blocks.mjs';
 import { createLeakGuard } from './anthropic-sse-turn/leak-guard.mjs';
 import { createTurnEvents } from './anthropic-sse-turn/turn-events.mjs';
 import { createTurnOutcome } from './anthropic-sse-turn/turn-outcome.mjs';
+import { OAUTH_STREAM_LABELS } from './lib/anthropic-stream-labels.mjs';
 
 /**
  * @param {object} deps
@@ -22,6 +23,7 @@ import { createTurnOutcome } from './anthropic-sse-turn/turn-outcome.mjs';
  * @param {(text: string) => void} [deps.onTextDelta]
  * @param {Iterable<string>} [deps.knownToolNames]
  * @param {boolean} [deps.relayProgressUpdates]  request used thinking.display "updates"
+ * @param {{ display: string, tag: string }} [deps.labels]  provider name for errors and stderr lines
  */
 export function createAnthropicSseTurn({
   state,
@@ -30,6 +32,7 @@ export function createAnthropicSseTurn({
   onTextDelta,
   knownToolNames,
   relayProgressUpdates = false,
+  labels = OAUTH_STREAM_LABELS,
 }) {
   const progress = (kind) => {
     try {
@@ -60,8 +63,9 @@ export function createAnthropicSseTurn({
     progress,
     onToolCall,
     relayProgressUpdates,
+    labels,
   });
-  const outcome = createTurnOutcome({ turn, blocks, state });
+  const outcome = createTurnOutcome({ turn, blocks, state, labels });
 
   return {
     ...events,

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

@@ -6,6 +6,7 @@
  * half-open socket — the 391s-hang root cause).
  */
 import { runAbortable } from '../../../shared/abort-race.mjs';
+import { OAUTH_STREAM_LABELS } from './lib/anthropic-stream-labels.mjs';
 import {
   PROVIDER_FIRST_BYTE_TIMEOUT_MS,
   PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
@@ -13,12 +14,6 @@ import {
   streamStalledError,
 } from '../stall-policy.mjs';
 
-const log = (line) => {
-  try {
-    process.stderr.write(`[anthropic-oauth] ${line}\n`);
-  } catch {}
-};
-
 function positiveMs(value) {
   return Number.isFinite(Number(value)) && Number(value) > 0 ? Number(value) : 0;
 }
@@ -30,8 +25,21 @@ function positiveMs(value) {
  * @param {AbortSignal|null} deps.signal
  * @param {((reason?: Error) => void)|null} deps.abortStream
  * @param {(err: Error) => Error} deps.attachStallPartial  enriches the idle-stall error
+ * @param {{ display: string, tag: string }} deps.labels  provider name for errors and stderr lines
  */
-export function createAnthropicSseWatchdogs({ state, reader, signal, abortStream, attachStallPartial }) {
+export function createAnthropicSseWatchdogs({
+  state,
+  reader,
+  signal,
+  abortStream,
+  attachStallPartial,
+  labels = OAUTH_STREAM_LABELS,
+}) {
+  const log = (line) => {
+    try {
+      process.stderr.write(`[${labels.tag}] ${line}\n`);
+    } catch {}
+  };
   // Transport-idle window. The legacy semanticIdleTimeoutMs seam remains as
   // a fallback for existing tests/callers, but production uses the shared
   // byte/event inactivity policy.
@@ -66,7 +74,7 @@ export function createAnthropicSseWatchdogs({ state, reader, signal, abortStream
   };
 
   const firstMessageTimeoutError = () => {
-    const err = new Error(`Anthropic OAuth SSE stream produced no message_start within ${firstMessageTimeoutMs}ms`);
+    const err = new Error(`${labels.display} SSE stream produced no message_start within ${firstMessageTimeoutMs}ms`);
     err.code = 'EEMPTYSTREAM';
     err.isEmptyStream = true;
     err.firstByteTimeout = true;
@@ -104,7 +112,7 @@ export function createAnthropicSseWatchdogs({ state, reader, signal, abortStream
 
   const stallError = () =>
     attachStallPartial(
-      streamStalledError('Anthropic OAuth SSE', idleTimeoutMs, { emittedToolCall: !!state?.emittedToolCall })
+      streamStalledError(`${labels.display} SSE`, idleTimeoutMs, { emittedToolCall: !!state?.emittedToolCall })
     );
   // Only actual transport silence trips this. Anthropic keepalives prove
   // that the generation connection is still alive.
@@ -141,7 +149,7 @@ export function createAnthropicSseWatchdogs({ state, reader, signal, abortStream
             idleReject = reject;
             reader.read().then(resolve, reject);
           }),
-        'Anthropic OAuth SSE stream aborted'
+        `${labels.display} SSE stream aborted`
       );
     } finally {
       idleReject = null;

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

@@ -12,6 +12,7 @@ import {
 } from './retry-classifier.mjs';
 import { frameProviderSseChunk, releaseProviderSseStream, retainProviderSseStream } from './stream-json-pool.mjs';
 import { splitSseRegion } from './lib/sse-framing.mjs';
+import { OAUTH_STREAM_LABELS } from './lib/anthropic-stream-labels.mjs';
 import { stampStreamOutcome, STREAM_TRANSPORTS, STREAM_OUTCOME_VERSION } from './lib/stream-outcome.mjs';
 import { createAnthropicSseTurn } from './anthropic-sse-turn.mjs';
 import { createAnthropicSseWatchdogs } from './anthropic-sse-watchdogs.mjs';
@@ -55,8 +56,13 @@ function _captureMidstreamAbort(state, reason) {
 
 // Abort-aware mid-stream backoff sleep → shared sleepWithAbort
 // (retry-classifier.mjs). abortMessage preserves the prior fallback text.
-export function _midstreamSleepWithAbort(ms, signal, sleepFn) {
-  return sleepWithAbort(ms, signal, sleepFn, 'Anthropic OAuth mid-stream retry backoff aborted');
+export function _midstreamSleepWithAbort(
+  ms,
+  signal,
+  sleepFn,
+  abortMessage = 'Anthropic OAuth mid-stream retry backoff aborted'
+) {
+  return sleepWithAbort(ms, signal, sleepFn, abortMessage);
 }
 
 // Anthropic's documented error-event `type` enumeration → HTTP equivalent.
@@ -88,11 +94,11 @@ function _statusForAnthropicSseError(event, payload) {
   return 0;
 }
 
-function _anthropicSseError(event) {
+function _anthropicSseError(event, labels) {
   const payload = event?.error && typeof event.error === 'object' ? event.error : event;
   const type = payload?.type || event?.type || 'error';
   const message = payload?.message || 'Anthropic SSE error';
-  const err = new Error(`Anthropic OAuth SSE error ${type}: ${message}`);
+  const err = new Error(`${labels.display} SSE error ${type}: ${message}`);
   err.name = 'AnthropicSseError';
   err.code = 'EANTHROPIC_SSE_ERROR';
   err.providerErrorType = type;
@@ -115,11 +121,11 @@ function _anthropicSseError(event) {
 // must stop reading (a terminal frame). A malformed record is skipped exactly
 // like the former per-event JSON.parse throw — and, unlike a whole-batch
 // rejection, the well-formed records beside it still run.
-function applyAnthropicSseEvent(framedEvent, { turn, watchdogs, state, progress }) {
+function applyAnthropicSseEvent(framedEvent, { turn, watchdogs, state, progress, labels }) {
   const event = framedEvent.value;
   try {
     if (framedEvent.name === 'error' || event?.type === 'error' || event?.error) {
-      throw _anthropicSseError(event);
+      throw _anthropicSseError(event, labels);
     }
     switch (event.type) {
       case 'message_start':
@@ -170,7 +176,7 @@ export async function parseSSEStream(
   state,
   onTextDelta,
   knownToolNames,
-  { relayProgressUpdates = false } = {}
+  { relayProgressUpdates = false, labels = OAUTH_STREAM_LABELS } = {}
 ) {
   // Anthropic/Claude parity: every received SSE byte proves transport
   // activity, including comment and named ping keepalives. Content kinds
@@ -191,6 +197,7 @@ export async function parseSSEStream(
     onTextDelta,
     knownToolNames,
     relayProgressUpdates,
+    labels,
   });
   const watchdogs = createAnthropicSseWatchdogs({
     state,
@@ -198,10 +205,11 @@ export async function parseSSEStream(
     signal,
     abortStream,
     attachStallPartial: turn.attachStallPartial,
+    labels,
   });
   const abortedError = () => {
     _captureMidstreamAbort(state, signal.reason);
-    return signal.reason instanceof Error ? signal.reason : new Error('Anthropic OAuth SSE stream aborted');
+    return signal.reason instanceof Error ? signal.reason : new Error(`${labels.display} SSE stream aborted`);
   };
   const onAbort = () => {
     try {
@@ -252,7 +260,7 @@ export async function parseSSEStream(
       currentEvent = framedChunk.currentEvent;
       for (const framedEvent of framedChunk.events) {
         if (framedEvent.error) continue;
-        if (applyAnthropicSseEvent(framedEvent, { turn, watchdogs, state, progress })) break streamLoop;
+        if (applyAnthropicSseEvent(framedEvent, { turn, watchdogs, state, progress, labels })) break streamLoop;
       }
     }
     turn.flushLeak();
@@ -274,7 +282,7 @@ export async function parseSSEStream(
       reader.releaseLock();
     } catch (err) {
       try {
-        process.stderr.write(`[anthropic-oauth] reader releaseLock failed: ${err?.message ?? String(err)}\n`);
+        process.stderr.write(`[${labels.tag}] reader releaseLock failed: ${err?.message ?? String(err)}\n`);
       } catch {}
     }
   }
@@ -288,12 +296,8 @@ export async function parseSSEStream(
  * That keeps recovery limited to transport/stream stalls without risking
  * duplicate eager tool execution.
  */
-// Thin wrapper: the SSE mid-stream decision tree now lives in the shared
-// classifyMidstreamError (retry-classifier.mjs, policy.mode='sse'). Kept as a
-// named export so internal call sites AND anthropic.mjs (which imports this
-// symbol) keep resolving it. Behavior is byte-identical — the shared function
-// is the relocated original, gated by SSE_MIDSTREAM_POLICY (defaultRetries=3,
-// perClassifierGate:false).
+// Thin wrapper over the shared classifyMidstreamError (retry-classifier.mjs,
+// policy.mode='sse'), gated by SSE_MIDSTREAM_POLICY.
 export function _classifyMidstreamError(err, state) {
   return classifyMidstreamError(err, state, SSE_MIDSTREAM_POLICY);
 }

package/src/runtime/agent/orchestrator/providers/anthropic-thinking-contract.mjs

@@ -1,26 +1 @@
-// One classification owns request shaping and manual-budget validation.
-export function isAnthropicAdaptiveOnlyModel(model) {
-  const id = String(model || '')
-    .toLowerCase()
-    .replace(/\./g, '-');
-  return (
-    /^claude-(?:fable|mythos)-5(?:-|$)/.test(id) ||
-    /^claude-(?:opus|sonnet)-5(?:-|$)/.test(id) ||
-    /^claude-opus-4-(?:7|8)(?:-|$)/.test(id)
-  );
-}
-
-// Models that write their user-facing notes between tool calls (tool
-// preambles) as progress-update thinking blocks instead of text blocks.
-export function emitsAnthropicProgressUpdates(model) {
-  const id = String(model || '')
-    .toLowerCase()
-    .replace(/\./g, '-');
-  return /^claude-(?:opus-5-5|fable-5-1|mythos-5-1|fable-5)(?:-\d{8})?$/.test(id);
-}
-
-export function assertAnthropicManualBudgetSupported(model) {
-  if (isAnthropicAdaptiveOnlyModel(model)) {
-    throw new TypeError(`${model} does not support thinkingBudgetTokens; use effort with adaptive thinking instead.`);
-  }
-}
+export * from '../../../shared/llm/anthropic-thinking-contract.mjs';

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

@@ -19,13 +19,9 @@ import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 
-import {
-  loadAnthropic,
-  MODELS,
-  ANTHROPIC_VERSION,
-  _normalizeAnthropicModel,
-  _setApiKeyCatalogMirror,
-} from './anthropic-messages.mjs';
+import { loadAnthropic, _normalizeAnthropicModel, _setApiKeyCatalogMirror } from './anthropic-messages.mjs';
+import { ANTHROPIC_VERSION, MODELS } from './lib/anthropic-models.mjs';
+import { streamCallbacks } from './lib/send-callbacks.mjs';
 export { _test, _toAnthropicMessagesForTest } from './anthropic-messages.mjs';
 
 export class AnthropicProvider {
@@ -115,11 +111,7 @@ export class AnthropicProvider {
     });
     this.fastModeBetaHeaderLatched = fastModeLatched;
 
-    const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
-    const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
-    const onToolCall = typeof opts.onToolCall === 'function' ? opts.onToolCall : null;
-    const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
-    const onTextReset = typeof opts.onTextReset === 'function' ? opts.onTextReset : null;
+    const { onStageChange, onStreamDelta, onToolCall, onTextDelta, onTextReset } = streamCallbacks(opts);
 
     // No absolute wall-clock cap on streaming generation: a stream still
     // emitting SSE deltas must not be killed by a fixed total-lifetime timer.
@@ -172,6 +164,7 @@ export class AnthropicProvider {
     // anthropic-oauth).
     const midstream = createAnthropicMidstreamRecovery({
       label: this.name,
+      displayName: 'Anthropic',
       outcomeProvider: 'anthropic',
       midstreamOwner: `${this.name}-midstream`,
       unreachableMessage: 'Anthropic mid-stream retry: unreachable',
@@ -231,7 +224,10 @@ export class AnthropicProvider {
             midState,
             onTextDelta,
             knownToolNames,
-            { relayProgressUpdates: params.thinking?.display === 'updates' }
+            {
+              relayProgressUpdates: params.thinking?.display === 'updates',
+              labels: { display: 'Anthropic', tag: this.name },
+            }
           );
           try {
             streamController.abort?.('Anthropic SSE complete');

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

@@ -11,7 +11,13 @@
  * comes from `retrieveUserQuotaSummary`, not the per-model catalog counters.
  */
 import { makeModelCache } from './model-cache.mjs';
-import { ANTIGRAVITY_MODELS, PROJECT_ENDPOINT, antigravityHeaders, _scrubTokens } from './antigravity-oauth-tokens.mjs';
+import {
+  ANTIGRAVITY_MODELS,
+  PROJECT_ENDPOINT,
+  antigravityHeaders,
+  _scrubTokens,
+  withTimeoutSignal,
+} from './antigravity-oauth-tokens.mjs';
 
 const ANTIGRAVITY_MODEL_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 const ANTIGRAVITY_MODEL_CACHE_VERSION = 1;
@@ -35,7 +41,6 @@ export const antigravityModelCache = makeModelCache({
 });
 
 async function postInternalJson(methodName, { accessToken, projectId, fetchFn = fetch, signal = null }) {
-  const timeout = AbortSignal.timeout(FETCH_MODELS_TIMEOUT_MS);
   const res = await fetchFn(`${PROJECT_ENDPOINT}/v1internal:${methodName}`, {
     method: 'POST',
     headers: {
@@ -45,7 +50,7 @@ async function postInternalJson(methodName, { accessToken, projectId, fetchFn =
     },
     body: JSON.stringify(projectId ? { project: projectId } : {}),
     redirect: 'error',
-    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    signal: withTimeoutSignal(signal, FETCH_MODELS_TIMEOUT_MS),
   });
   if (!res.ok) {
     const text = await res.text().catch(() => '');

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

@@ -30,6 +30,7 @@ import {
   antigravityHeaders,
   codeAssistMetadata,
   saveTokens,
+  withTimeoutSignal,
 } from './antigravity-oauth-tokens.mjs';
 
 const ONBOARD_INTERVAL_MS = 1_000;
@@ -58,7 +59,6 @@ function accountVerificationError(validationUrl, reason, email) {
 async function requestCodeAssist(action, body, context, timeoutMs = PROJECT_TIMEOUT_MS) {
   const { accessToken, fetchFn, signal } = context;
   signal?.throwIfAborted();
-  const timeout = AbortSignal.timeout(timeoutMs);
   const isPost = body !== undefined;
   const res = await fetchFn(`${PROJECT_ENDPOINT}/v1internal${isPost ? ':' : '/'}${action}`, {
     method: isPost ? 'POST' : 'GET',
@@ -69,7 +69,7 @@ async function requestCodeAssist(action, body, context, timeoutMs = PROJECT_TIME
     },
     ...(isPost ? { body: JSON.stringify(body) } : {}),
     redirect: 'error',
-    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    signal: withTimeoutSignal(signal, timeoutMs),
   });
   if (res.status !== 200) {
     const text = await res.text();
@@ -106,9 +106,7 @@ async function fetchAccountEmail(accessToken, { fetchFn = fetch, signal = null }
     const res = await fetchFn(USERINFO_URL, {
       headers: { Authorization: `Bearer ${accessToken}` },
       redirect: 'error',
-      signal: signal
-        ? AbortSignal.any([signal, AbortSignal.timeout(TOKEN_TIMEOUT_MS)])
-        : AbortSignal.timeout(TOKEN_TIMEOUT_MS),
+      signal: withTimeoutSignal(signal, TOKEN_TIMEOUT_MS),
     });
     if (!res.ok) return '';
     const json = await res.json();
@@ -256,9 +254,7 @@ export async function exchangeAuthorizationCode({ code, verifier, fetchFn = fetc
     // Secret-bearing (code + verifier): refuse redirects so neither can be
     // replayed against an untrusted host.
     redirect: 'error',
-    signal: signal
-      ? AbortSignal.any([signal, AbortSignal.timeout(TOKEN_TIMEOUT_MS)])
-      : AbortSignal.timeout(TOKEN_TIMEOUT_MS),
+    signal: withTimeoutSignal(signal, TOKEN_TIMEOUT_MS),
   });
   if (!res.ok) {
     const text = await res.text().catch(() => '');

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

@@ -18,9 +18,9 @@ import { join, resolve } from 'node:path';
 import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
-import { scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
-import { ANTIGRAVITY_MODELS } from './provider-model-identities.mjs';
-export { ANTIGRAVITY_MODELS } from './provider-model-identities.mjs';
+import { normalizeExpiresAtMs as _normalizeExpiresAt, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
+import { ANTIGRAVITY_MODELS } from '../../../shared/llm/provider-model-identities.mjs';
+export { ANTIGRAVITY_MODELS } from '../../../shared/llm/provider-model-identities.mjs';
 
 // The Antigravity IDE's installed-app OAuth client, which every copy of that
 // IDE ships (a native-app client is not a confidential credential). It is
@@ -140,6 +140,12 @@ export function antigravityHeaders() {
   };
 }
 
+/** Request signal bounded by `timeoutMs`, and by the caller's `signal` when given. */
+export function withTimeoutSignal(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
 /** `loadCodeAssist` / `onboardUser` metadata block. */
 export function codeAssistMetadata() {
   return { ideType: 'ANTIGRAVITY' };
@@ -164,15 +170,7 @@ function mtimeMs(path) {
   }
 }
 
-export function _normalizeExpiresAt(value) {
-  if (typeof value === 'string') {
-    const ms = Date.parse(value);
-    return Number.isFinite(ms) ? ms : 0;
-  }
-  const n = Number(value || 0);
-  if (!Number.isFinite(n) || n <= 0) return 0;
-  return n < 1e12 ? n * 1000 : n;
-}
+export { _normalizeExpiresAt };
 
 export function loadTokens() {
   const path = getOwnTokenPath();
@@ -221,19 +219,19 @@ export function hasAntigravityOAuthCredentials() {
   }
 }
 
+const credentialsNotSet = () => ({
+  authenticated: false,
+  usable: false,
+  refreshable: false,
+  reauthRequired: false,
+  status: 'Not Set',
+  detail: 'Mixdog token store',
+});
+
 export function describeAntigravityOAuthCredentials() {
   try {
     const tokens = loadTokens();
-    if (!tokens?.access_token) {
-      return {
-        authenticated: false,
-        usable: false,
-        refreshable: false,
-        reauthRequired: false,
-        status: 'Not Set',
-        detail: 'Mixdog token store',
-      };
-    }
+    if (!tokens?.access_token) return credentialsNotSet();
     const hasRefresh = Boolean(tokens.refresh_token);
     const expiresAt = Number(tokens.expires_at || 0);
     const expired = expiresAt > 0 && expiresAt <= Date.now();
@@ -254,14 +252,7 @@ export function describeAntigravityOAuthCredentials() {
       projectId: tokens.project_id || '',
     };
   } catch {
-    return {
-      authenticated: false,
-      usable: false,
-      refreshable: false,
-      reauthRequired: false,
-      status: 'Not Set',
-      detail: 'Mixdog token store',
-    };
+    return credentialsNotSet();
   }
 }
 

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

@@ -23,7 +23,7 @@ export function finalizeAntigravityTurn({ response, collector, useModel, opts, o
   const candidate = response.candidates?.[0] || null;
   const responseParts = candidate?.content?.parts ?? [];
   const textParts = responseParts.filter((p) => p?.thought !== true && 'text' in p);
-  const rawContent = textParts.map((p) => ('text' in p ? p.text : '')).join('');
+  const rawContent = textParts.map((p) => p.text).join('');
   const providerMetadata = parseGeminiTextPartMetadata(responseParts);
   const content = textLeakGuard?.enabled ? textLeakGuard.scrubAssistantText(rawContent) : rawContent;
   const leakedToolCalls = textLeakGuard?.getLeakedToolCalls() ?? [];