mixdog 1.2.1 → 1.2.2

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

@@ -1,6 +1,11 @@
 import { GoogleGenerativeAI } from '@google/generative-ai';
 import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
-import { canFallbackNonStreaming, emitProviderRetryStage, withRetry } from './retry-classifier.mjs';
+import {
+  canFallbackNonStreaming,
+  emitProviderRetryStage,
+  markProviderRecoveryExhausted,
+  withRetry,
+} from './retry-classifier.mjs';
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
 import { traceNonStreamingFallback } from './lib/transport-fallback-trace.mjs';
 import {
@@ -12,6 +17,13 @@ import {
 } from '../stall-policy.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { GEMINI_FIRST_BYTE_TIMEOUT_MS, consumeGeminiRestStreamResponse } from './gemini-stream.mjs';
+import { applyGeminiErrorContract } from './gemini-error-contract.mjs';
+import {
+  GEMINI_MIDSTREAM_MAX_ATTEMPTS,
+  geminiEndsWithFunctionResponse,
+  geminiInvalidStreamReason,
+  runGeminiStreamAttempts,
+} from './gemini-retry-policy.mjs';
 import { geminiTextLeakGuardFor, streamGeminiSdkAttempt } from './gemini-sdk-request.mjs';
 import { emitGeminiToolCalls } from './gemini-schema.mjs';
 import { buildGeminiRequest, geminiCachedRestBody } from './gemini-request-body.mjs';
@@ -32,6 +44,8 @@ import {
   GEMINI_GLOBAL_CACHE_DELETE_GRACE_MS,
   _geminiCredentialFingerprint,
   _invalidateGeminiCachesForCredentialFingerprint,
+  geminiExplicitCacheRefused,
+  markGeminiExplicitCacheRefused,
 } from './gemini-cache.mjs';
 import {
   awaitSharedCreate,
@@ -59,7 +73,7 @@ import {
 let _modelRefreshInFlight = null;
 const GEMINI_AVAILABILITY_TIMEOUT_MS = 1_000;
 
-function geminiRestError(res, text, label) {
+export function geminiRestError(res, text, label) {
   let payload = null;
   try {
     payload = text ? JSON.parse(text) : null;
@@ -78,16 +92,11 @@ function geminiRestError(res, text, label) {
     err.error = detail;
     err.data = payload;
     if (detail.status) err.geminiStatus = detail.status;
-    if (Array.isArray(detail.details)) err.details = detail.details;
-    const retryAfter = res.headers?.get?.('retry-after') ?? res.headers?.get?.('retry-after-ms');
-    // RESOURCE_EXHAUSTED without a server retry window is deterministic
-    // quota exhaustion. With Retry-After present, leave it request-local
-    // so withRetry can honor the mandated delay.
-    // A 429 RESOURCE_EXHAUSTED is a request-local rate limit even without
-    // Retry-After (Google/LiteLLM retry). Do not stamp it as a quota code.
-    if (detail.status && (retryAfter == null || retryAfter === '') && res.status !== 429) {
-      err.code = detail.status;
-    }
+    const details = detail.details ?? detail.errorDetails;
+    if (Array.isArray(details)) err.details = details;
+    // Typed contract (code/retryAfterMs/resetAt/quotaScope); the core decides
+    // whether a 429 RESOURCE_EXHAUSTED is request-local or a quota refusal.
+    applyGeminiErrorContract(err, { details, googleStatus: detail.status, message: detail.message });
   }
   return err;
 }
@@ -139,6 +148,9 @@ export class GeminiProvider {
   // input already includes cache. See registry.mjs.
   static inputExcludesCache = false;
   name = 'gemini';
+  // The two-phase ladder (gemini-retry-policy.mjs) is the whole recovery:
+  // a spent ladder surfaces instead of parking on loop recovery cycles.
+  retryPolicy = Object.freeze({ recoveryCycles: false });
   genAI;
   config;
   _fetch;
@@ -263,7 +275,7 @@ export class GeminiProvider {
     if (decision.canReuseState) {
       return state.cacheName;
     }
-    if (!apiKey) return null;
+    if (!apiKey || geminiExplicitCacheRefused(model)) return null;
     const { canAttachState } = decision;
     if (geminiPrefixBelowMinimum({ model, systemInstruction, geminiTools, contents, opts, currentIter })) {
       return canAttachState ? state.cacheName : null;
@@ -443,6 +455,7 @@ export class GeminiProvider {
       _setGeminiGlobalCache(globalCacheKey, entry);
       return entry;
     } catch (err) {
+      markGeminiExplicitCacheRefused(model, err);
       process.stderr.write(`[gemini] cachedContents.create error: ${err?.message || err}\n`);
       return null;
     }
@@ -574,7 +587,18 @@ export class GeminiProvider {
     emitGeminiToolCalls(parsed.nativeToolCalls, callbacks.onToolCall);
     const usage = resolveGeminiUsage(response, opts, cachedContent, useModel);
     const incomplete = geminiIncompleteError(response, parsed, useModel, usage);
-    if (incomplete) throw incomplete;
+    if (incomplete) {
+      // A malformed / unexpected tool call that survived the stream ladder
+      // (4 attempts) is spent; the loop must not multiply that budget.
+      if (
+        geminiInvalidStreamReason(response, textLeakGuard, {
+          afterToolResult: geminiEndsWithFunctionResponse(request.contents),
+        })
+      ) {
+        markProviderRecoveryExhausted(incomplete, { owner: 'gemini-stream', attempts: GEMINI_MIDSTREAM_MAX_ATTEMPTS });
+      }
+      throw incomplete;
+    }
     return geminiSendResult(parsed, useModel, opts, usage);
   }
 
@@ -643,12 +667,19 @@ export class GeminiProvider {
     const restPassthrough = createPassthroughSignal(signal);
     const totalSignal = restPassthrough.signal;
     try {
-      return await withRetry(
-        async ({ signal: attemptSignal }) => {
+      const afterToolResult = geminiEndsWithFunctionResponse(contents);
+      return await runGeminiStreamAttempts({
+        signal: totalSignal,
+        sleepFn: this.config?.sleepFn,
+        onRetry: geminiRetryLogger(opts, '[gemini-rest]'),
+        afterToolResult,
+        run: async ({ signal: attemptSignal, connected }) => {
           signalRequesting(opts);
           const res = await this._openRestStream(genUrl, body, attemptSignal);
+          connected();
           const textLeakGuard = geminiTextLeakGuardFor(stream);
           const response = await consumeGeminiRestStreamResponse(res, {
+            acceptEmptyNoFinish: afterToolResult,
             signal: attemptSignal,
             onStreamDelta: callbacks.onStreamDelta,
             onTextDelta: callbacks.onTextDelta,
@@ -658,8 +689,7 @@ export class GeminiProvider {
           });
           return { response, textLeakGuard };
         },
-        { signal: totalSignal, onRetry: geminiRetryLogger(opts, '[gemini-rest]') }
-      );
+      });
     } catch (err) {
       if (
         !internal.skipExplicitCache &&
@@ -698,13 +728,16 @@ export class GeminiProvider {
     const sdkPassthrough = createPassthroughSignal(signal);
     const totalSignal = sdkPassthrough.signal;
     try {
-      return await withRetry(
-        async ({ signal: attemptSignal }) => {
+      return await runGeminiStreamAttempts({
+        signal: totalSignal,
+        sleepFn: this.config?.sleepFn,
+        onRetry: geminiRetryLogger(opts, '[gemini]'),
+        afterToolResult: geminiEndsWithFunctionResponse(contents),
+        run: async ({ signal: attemptSignal, connected }) => {
           signalRequesting(opts);
-          return await streamGeminiSdkAttempt(genModel, stream, attemptSignal);
+          return await streamGeminiSdkAttempt(genModel, stream, attemptSignal, connected);
         },
-        { signal: totalSignal, onRetry: geminiRetryLogger(opts, '[gemini]') }
-      );
+      });
     } catch (err) {
       const recovered = await this._recoverGeminiNonStreaming({
         streamErr: err,

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

@@ -333,6 +333,9 @@ async function _postRefresh(tokens) {
         isTerminalRefresh,
         reauthRequired: isTerminalRefresh,
         oauthError: oauthError || null,
+        status: res.status,
+        headers: res.headers,
+        ...(oauthError ? { code: oauthError } : {}),
       });
     }
     const accessToken = json?.access_token;

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

@@ -18,6 +18,8 @@ import { enrichModels, getModelMetadataSync } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
+import { xaiModelSupportsReasoningEffort } from './openai-compat-xai.mjs';
+import { XAI_COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
 import { createTimeoutSignal } from '../stall-policy.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { normalizeGrokToolSchemas } from './lib/grok-tool-schema.mjs';
@@ -48,19 +50,44 @@ export {
 } from './grok-oauth-tokens.mjs';
 export { beginOAuthLogin, loginOAuth } from './grok-oauth-login.mjs';
 
+// Typed wire codes that say the bearer itself expired or was revoked. An
+// ordinary permission 403 carries none of them and is never a refresh signal.
+const EXPIRED_TOKEN_CODES = new Set([
+  'token_expired',
+  'expired_token',
+  'access_token_expired',
+  'token_revoked',
+  'revoked_token',
+  'invalid_token',
+]);
+
+function hasExpiredTokenSignature(err) {
+  return [err?.code, err?.type, err?.providerErrorCode, err?.error?.code, err?.error?.type].some(
+    (field) => typeof field === 'string' && EXPIRED_TOKEN_CODES.has(field.trim().toLowerCase())
+  );
+}
+
 const _modelCache = makeModelCache({
   fileName: 'grok-oauth-models.json',
   ttlMs: MODEL_CACHE_TTL_MS,
   version: GROK_MODEL_CACHE_SCHEMA_VERSION,
 });
 
-function _grokModelSupportsEffort(id) {
+// A model takes a reasoning effort when its own roster row or the catalog
+// publishes effort values; otherwise the shared xAI rule decides (catalog row
+// first, then pass-through). Two id tokens are kept: xAI's own
+// `non-reasoning` variant marker, and the Build endpoint family. Neither
+// publishes capabilities, and both 400 on any effort.
+function _grokModelSupportsEffort(id, model = null) {
   const text = String(id || '').toLowerCase();
   if (!text) return false;
   if (NON_CHAT_MODEL_RE.test(text)) return false;
-  if (text.includes('non-reasoning')) return false;
-  if (text === 'grok-build' || text.startsWith('grok-build-')) return false;
-  return text.includes('reasoning') || /^grok-\d/.test(text);
+  if (_grokCatalogEffortValues(model).length || _grokApiEffortValues(model).length) return true;
+  if (/non[-_]?reasoning/.test(text)) return false;
+  // Build endpoint models reject reasoning_effort outright; a catalog or
+  // roster that publishes effort values has already answered above.
+  if (/^grok[-_]build/.test(text)) return false;
+  return xaiModelSupportsReasoningEffort(text);
 }
 
 // Pre-catalog fallback matches Grok 4.5 (low/medium/high). Grok 4.6 adds
@@ -86,7 +113,8 @@ function _grokApiEffortValues(model) {
     model?.reasoningEfforts ??
     model?.reasoning_efforts ??
     model?._meta?.reasoningEfforts ??
-    model?._meta?.reasoning_efforts;
+    model?._meta?.reasoning_efforts ??
+    model?.capabilities?.reasoning_effort;
   return Array.isArray(raw) ? _uniqueKnownGrokEfforts(raw) : [];
 }
 
@@ -103,7 +131,7 @@ function _grokCatalogEffortValues(model) {
 }
 
 function _grokReasoningLevels(id, model) {
-  if (!_grokModelSupportsEffort(id)) return [];
+  if (!_grokModelSupportsEffort(id, model)) return [];
   const catalog = _grokCatalogEffortValues(model);
   if (catalog.length) return catalog;
   const api = _grokApiEffortValues(model);
@@ -144,13 +172,14 @@ function _normalizeGrokModel(m) {
   const contextWindow = _grokApiContextWindow(m);
   const apiEfforts = _grokApiEffortValues(m);
   const reasoningOptions = apiEfforts.length ? [{ type: 'effort', values: apiEfforts }] : undefined;
+  const row = { ...m, reasoningOptions };
   return {
     id,
     name: id,
     display: _displayGrokModel(m),
     provider: 'grok-oauth',
-    family: _normalizeGrokFamily(id),
-    reasoningLevels: _grokReasoningLevels(id, { ...m, reasoningOptions }),
+    family: _normalizeGrokFamily(id, row),
+    reasoningLevels: _grokReasoningLevels(id, row),
     ...(reasoningOptions ? { reasoningOptions } : {}),
     tier: 'version',
     latest: false,
@@ -165,7 +194,7 @@ function _sanitizeGrokModels(models) {
   const next = models.map((m) => {
     let out = m;
     const display = _displayGrokModel(m);
-    const family = _normalizeGrokFamily(m?.id);
+    const family = _normalizeGrokFamily(m?.id, out);
     const reasoningLevels = _grokReasoningLevels(m?.id, out);
     // api.x.ai /models does not expose a max-output field. Historical
     // enrichment could persist contextWindow as outputTokens (for example
@@ -248,6 +277,15 @@ function resolveLatestGrokModel() {
   return _newestDatedGrokChatModel(cached)?.id || null;
 }
 
+// Whether a request for this model may carry an effort: the levels its cached
+// roster row already resolved from the roster and catalog answer, else the id
+// alone follows the catalog rule.
+function _grokSendSupportsEffort(id) {
+  const cached = _modelCache.loadSync();
+  const row = Array.isArray(cached) ? cached.find((m) => m?.id === id) : null;
+  return Array.isArray(row?.reasoningLevels) ? row.reasoningLevels.length > 0 : _grokModelSupportsEffort(id);
+}
+
 async function ensureLatestGrokModel(provider) {
   let m = resolveLatestGrokModel();
   if (m) return m;
@@ -265,6 +303,8 @@ export class GrokOAuthProvider {
   // OpenAI-compatible usage: prompt_tokens includes cached. See registry.mjs.
   static inputExcludesCache = false;
   name = 'grok-oauth';
+  // The inner xai profile's limits are final: no loop-level recovery cycles on top.
+  retryPolicy = XAI_COMPAT_RETRY_POLICY;
   config;
   tokens = null;
   _inner = null;
@@ -395,11 +435,12 @@ export class GrokOAuthProvider {
     });
     const inner = this._ensureInner(tokens.access_token, useModel, requestHeaders);
     const grokTools = normalizeGrokToolSchemas(tools);
-    // Effort-less models (grok-build, composer): the service 400s on ANY
-    // reasoningEffort parameter, and pinned model settings can carry one
-    // (e.g. the bench harness pins effort per route). Strip it here so a
-    // saved effort never breaks a model that cannot accept it.
-    if (!_grokModelSupportsEffort(useModel) && sendOpts) {
+    // Effort-less models: the service 400s on ANY reasoningEffort parameter,
+    // and pinned model settings can carry one (e.g. the bench harness pins
+    // effort per route). Strip it here so a saved effort never breaks a model
+    // that cannot accept it. The model's own roster row decides; a model not
+    // on the roster yet follows the catalog rule.
+    if (sendOpts && !_grokSendSupportsEffort(useModel)) {
       // 'none' (not null) so the ?? fallback chain in the xai builder
       // cannot fall through to a config/env effort; the normalizer maps
       // it to "omit the parameter".
@@ -414,9 +455,10 @@ export class GrokOAuthProvider {
       return await inner._doSend(messages, useModel, grokTools, sendOpts);
     } catch (err) {
       noteErrorUsage(err);
-      // Refresh-and-retry on a server-rejected OAuth session (401/403).
-      // TYPED status only: a rejection whose only evidence is message
-      // text is never treated as an auth failure worth re-issuing.
+      // Refresh-and-retry on a server-rejected OAuth session: 401, or a 403
+      // carrying an explicit expired/revoked-token code. TYPED evidence only:
+      // message text is never an auth verdict, and a plain permission 403 is
+      // surfaced as-is.
       const rejectedStatus = Number(err?.httpStatus || err?.status);
       // 426 = client version gate. Retry once only when the body stated a
       // minimum we did not already satisfy; nothing was emitted before it.
@@ -434,7 +476,7 @@ export class GrokOAuthProvider {
           sendOpts
         );
       }
-      if (rejectedStatus === 401 || rejectedStatus === 403) {
+      if (rejectedStatus === 401 || (rejectedStatus === 403 && hasExpiredTokenSignature(err))) {
         // A stream-level rejection after text/tool dispatch cannot be safely
         // replayed: the client has already observed output or may have
         // executed a side-effecting tool.
@@ -444,7 +486,14 @@ export class GrokOAuthProvider {
         process.stderr.write(`[grok-oauth] ${rejectedStatus}, force-refreshing token...\n`);
         const fresh = await this.ensureAuth({ forceRefresh: true });
         const retryInner = this._ensureInner(fresh.access_token, useModel, requestHeaders);
-        return await retryInner._doSend(messages, useModel, grokTools, sendOpts);
+        try {
+          return await retryInner._doSend(messages, useModel, grokTools, sendOpts);
+        } catch (retryErr) {
+          // Rejected again on a token that was just refreshed: re-login is the
+          // only remaining path.
+          if (Number(retryErr?.httpStatus || retryErr?.status) === 401) retryErr.reauthRequired = true;
+          throw retryErr;
+        }
       }
       throw err;
     }

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

@@ -9,6 +9,7 @@
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
 import { fileMtimeMs, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
 import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
+import { COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
 import { fetchCompatModelItems, listCompatModels } from './openai-compat-models.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import {
@@ -114,6 +115,8 @@ export class MimoOAuthProvider {
   // OpenAI-compatible usage: prompt_tokens includes cached. See registry.mjs.
   static inputExcludesCache = false;
   name = 'mimo-oauth';
+  // The retry profile's limits are final: no loop-level recovery cycles on top.
+  retryPolicy = COMPAT_RETRY_POLICY;
   config;
   tokens = null;
   _inner = null;

package/src/runtime/agent/orchestrator/providers/model-list-sanitize.mjs

@@ -208,7 +208,8 @@ function _stalenessFamily(row, id) {
   const modelId = String(id || row?.id || row?.name || '')
     .trim()
     .toLowerCase();
-  const claude = modelId.match(/(?:^|\/)claude-(opus|sonnet|haiku|fable)(?:-|$)/);
+  // Claude ids name their family right after the brand (`claude-<family>-<version>`).
+  const claude = modelId.match(/(?:^|\/)claude-([a-z]+)(?:-|$)/);
   if (claude) return `claude-${claude[1]}`;
   const family = row && typeof row.family === 'string' ? row.family.trim().toLowerCase() : '';
   return family || null;

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

@@ -10,8 +10,10 @@ import { createHash } from 'node:crypto';
 import { noteErrorUsage } from './lib/note-error-usage.mjs';
 import { fileMtimeMs } from './lib/oauth-token-utils.mjs';
 import { OpenAICompatProvider, preloadOpenAICompatRuntime } from './openai-compat.mjs';
+import { COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
 import { getModelMetadataSync } from './model-catalog.mjs';
 import { makeModelCache } from './model-cache.mjs';
+import { normalizeCacheKey } from '../agent-runtime/cache-strategy.mjs';
 import { PRICING_RATE_KEYS } from '../../../shared/llm/model-pricing-rates.mjs';
 import {
   MUSE_DEFAULT_EFFORT_LEVELS as FIVE_LEVELS,
@@ -100,15 +102,6 @@ function museRow(id, discovered = null) {
 const EFFORT_DOWNGRADE = { max: 'xhigh' };
 const SUMMARY_MODES = new Set(['auto', 'detailed', 'concise']);
 
-// Cache identities beyond the wire limit become a bounded hash identity.
-function normalizeCacheKey(value) {
-  const text = String(value ?? '').trim();
-  if (!text) return '';
-  const wellFormed = text.toWellFormed();
-  if (wellFormed.length <= 64) return wellFormed;
-  return `pc_${createHash('sha256').update(wellFormed).digest('hex').slice(0, 32)}`;
-}
-
 // Final request shaping on the Responses wire (installed through the shared
 // transport's opt-in params hook).
 function shapeResponsesParams(params, { opts, modelInfo }, config = {}) {
@@ -321,6 +314,8 @@ export class MuseCodeOAuthProvider {
   nativePdf = false;
   static inputExcludesCache = false;
   name = 'muse-code-oauth';
+  // The retry profile's limits are final: no loop-level recovery cycles on top.
+  retryPolicy = COMPAT_RETRY_POLICY;
   config;
   tokens = null;
   _inner = null;

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-send.mjs

@@ -21,6 +21,7 @@ import { normalizeCompatChatResponse } from './openai-compat-response-normalizat
 import { applyCompatToolChoice, compatStreamRetryReporter } from './compat-request-policy.mjs';
 import { ensureChatToolPairs } from './lib/wire-pairing.mjs';
 import { xaiCacheRouting } from './openai-compat-xai.mjs';
+import { compatRetryOptions, withCompatRetryProfile } from './openai-compat-retry-profile.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
 import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
 
@@ -85,7 +86,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
   try {
     try {
       assembled = await withRetry(
-        refineAttemptErrors(profile, async ({ signal: attemptSignal }) => {
+        withCompatRetryProfile(provider.name, refineAttemptErrors(profile, async ({ signal: attemptSignal }) => {
           try {
             opts.onStageChange?.('requesting');
           } catch {
@@ -139,11 +140,12 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
             }
             throw error;
           }
-        }),
+        })),
         {
           signal: totalSignal.signal,
           onRetry: compatStreamRetryReporter(provider.name, opts),
           retry529: opts.retry529,
+          ...compatRetryOptions(provider.name),
         }
       );
     } catch (streamErr) {

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/stream-result.mjs

@@ -8,6 +8,7 @@ import { truncatedCompatStreamError } from '../lib/openai-tool-args.mjs';
 import {
   emitCompatToolCallOnce,
   firstByteCompatStreamError,
+  failingFinishReasonError,
   markErrorLiveTextEmitted,
   markUnsafeRetryIfToolEmitted,
 } from '../openai-compat-stream-common.mjs';
@@ -61,7 +62,28 @@ function parseAccumulatedToolCalls(state, { label, parseToolCalls }) {
   }
 }
 
+// A gateway-reported failing finish_reason (`network_error`, `error`) is an
+// interruption: the stream carries no terminal, so exposure keeps its replay
+// gates.
+function finishReasonInterruption(state, err) {
+  attachPartial(state, err);
+  if (state.emittedText) {
+    markErrorLiveTextEmitted(err);
+    try {
+      err.streamStalled = true;
+    } catch {
+      /* best-effort */
+    }
+  }
+  return stampCompatOutcome(state, markUnsafeRetryIfToolEmitted(err, state.streamEmitState), {
+    terminalObserved: false,
+    continuation: true,
+  });
+}
+
 export function settleCompatStream(state, { label, parseToolCalls }) {
+  const failing = failingFinishReasonError(state.stopReason, label);
+  if (failing) throw finishReasonInterruption(state, failing);
   const response = buildResponse(state);
   let toolCalls = parseAccumulatedToolCalls(state, { label, parseToolCalls });
   if (Array.isArray(toolCalls) && toolCalls.length) {

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream.mjs

@@ -71,6 +71,7 @@ export async function consumeCompatChatCompletionStream(
         idleDeadlineAt: state.semanticIdleDeadlineAt,
         idleEnabled: state.sawFirstEvent && idleEnabled && state.semanticIdleDeadlineAt > 0,
         idleLabel: `${label} SSE idle`,
+        streamLabel: label,
         emittedToolCall: () => toolWorkStarted(state),
       });
       if (done) {

package/src/runtime/agent/orchestrator/providers/openai-compat-error-contract.mjs

@@ -0,0 +1,50 @@
+/**
+ * openai-compat-error-contract.mjs — the error contract of the OpenAI-compatible
+ * provider boundary: `status`, lowercased `code` (from the wire error's `code`
+ * or `type`), `headers`, `retryAfterMs` and `resetAt` when the provider sent
+ * them. Evidence is structural only; message text is never parsed.
+ */
+import { retryAfterMsFromError, typedStatusFrom } from './retry-classifier.mjs';
+
+const lowered = (value) => (typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : '');
+
+// Epoch seconds, epoch ms or an ISO date → epoch ms; `resets_in_seconds` is relative.
+function resetAtFrom(wire, now) {
+  const inSeconds = Number(wire?.resets_in_seconds);
+  if (wire?.resets_in_seconds != null && Number.isFinite(inSeconds) && inSeconds >= 0) {
+    return now + Math.ceil(inSeconds * 1000);
+  }
+  const raw = wire?.resets_at ?? wire?.reset_at;
+  if (raw == null || raw === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric) && numeric > 0) return numeric < 1e12 ? Math.round(numeric * 1000) : Math.round(numeric);
+  const parsed = Date.parse(String(raw));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+/** Stamp the boundary contract onto a provider error in place and return it. */
+export function applyCompatErrorContract(err, detail = err?.error ?? err?.providerError, now = Date.now()) {
+  if (!err || typeof err !== 'object') return err;
+  try {
+    const wire = detail && typeof detail === 'object' ? detail : null;
+    const status = typedStatusFrom(err, err.response, wire);
+    if (status && !(Number(err.status) >= 100)) err.status = status;
+    const wireCode = lowered(wire?.code) || lowered(wire?.type) || lowered(err.type);
+    // Keep an errno / SDK-local code (ECONNRESET, ...) that is not the wire code.
+    if (wireCode && (typeof err.code !== 'string' || !err.code.trim() || lowered(err.code) === wireCode)) {
+      err.code = wireCode;
+    }
+    if (!err.headers && err.response?.headers) err.headers = err.response.headers;
+    if (!Number.isFinite(err.retryAfterMs)) {
+      const retryAfterMs = retryAfterMsFromError(err);
+      if (retryAfterMs != null) err.retryAfterMs = retryAfterMs;
+    }
+    if (!Number.isFinite(err.resetAt)) {
+      const resetAt = resetAtFrom(wire, now);
+      if (resetAt) err.resetAt = resetAt;
+    }
+  } catch {
+    /* the contract is best-effort; the original error stays authoritative */
+  }
+  return err;
+}

package/src/runtime/agent/orchestrator/providers/openai-compat-response-normalization.mjs

@@ -7,6 +7,8 @@ import {
   writeXaiResponsesCacheTrace,
 } from './openai-compat-xai.mjs';
 import { createProviderReplay } from './lib/provider-replay.mjs';
+import { stampStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
+import { failingFinishReasonError } from './openai-compat-stream-common.mjs';
 
 const reportedNumber = (value) =>
   value == null || (typeof value === 'string' && value.trim() === '') ? Number.NaN : Number(value);
@@ -141,6 +143,27 @@ export function normalizeCompatChatResponse({
   const choice = response.choices[0];
   const toolCalls = assembled.toolCalls;
   const stopReason = choice?.finish_reason || null;
+  const failingFinish = failingFinishReasonError(stopReason, providerName);
+  if (failingFinish) {
+    const err = failingFinish;
+    const partialContent = choice?.message?.content || '';
+    Object.assign(err, {
+      partialContent,
+      partialToolCalls: Array.isArray(toolCalls) && toolCalls.length ? toolCalls : undefined,
+      pendingToolUse: false,
+      partialModel: response.model || useModel,
+      ...(response.usage ? { partialUsage: chatCompletionUsage(providerName, response.usage) } : {}),
+    });
+    stampStreamOutcome(err, {
+      transport: STREAM_TRANSPORTS.NON_STREAMING,
+      provider: 'openai-compat',
+      terminalObserved: false,
+      continuation: true,
+      textObservedChars: partialContent.length,
+      toolCallsComplete: err.partialToolCalls?.length || 0,
+    });
+    throw err;
+  }
   if (
     (stopReason === 'length' && Array.isArray(toolCalls) && toolCalls.length > 0) ||
     stopReason === 'content_filter'