mixdog 1.2.0 → 1.2.2

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

@@ -1,6 +1,11 @@
 import { GoogleGenerativeAI } from '@google/generative-ai';
-import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
-import { canFallbackNonStreaming, emitProviderRetryStage, withRetry } from './retry-classifier.mjs';
+import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/provider-api-key.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;
@@ -153,8 +165,9 @@ export class GeminiProvider {
     this._createGenAI =
       typeof config.createGenAI === 'function' ? config.createGenAI : (apiKey) => new GoogleGenerativeAI(apiKey);
     this._modelCache = config.modelCache || _modelCache;
-    const apiKey = config.apiKey || process.env.GEMINI_API_KEY || '';
-    this.genAI = config.genAI || this._createGenAI(apiKey);
+    this._injectedGenAI = Boolean(config.genAI);
+    this._genAIKey = resolveProviderApiKey('gemini', config);
+    this.genAI = config.genAI || this._createGenAI(this._genAIKey);
     // Warm a kept-alive socket to the Gemini REST API so the first cache/
     // generateContent request skips the cold TLS handshake. Best-effort.
     this._preconnect('https://generativelanguage.googleapis.com');
@@ -162,12 +175,13 @@ export class GeminiProvider {
 
   reloadApiKey() {
     try {
-      const newKey = getAgentApiKey('gemini') || this.config?.apiKey || process.env.GEMINI_API_KEY;
+      const newKey = reloadProviderApiKey('gemini', this.config);
       if (newKey) {
-        // Keep this.config in sync so REST/cache paths (which read the
-        // key via _getApiKey() → this.config.apiKey) don't keep using
-        // the stale key after a rotation; genAI alone is not enough.
+        // Keep this.config in sync so REST/cache paths don't keep using the
+        // stale key after a rotation; genAI alone is not enough.
         this.config = { ...(this.config || {}), apiKey: newKey };
+        this._injectedGenAI = false;
+        this._genAIKey = newKey;
         this.genAI = this._createGenAI(newKey);
       }
       return newKey || '';
@@ -178,7 +192,18 @@ export class GeminiProvider {
   }
 
   _getApiKey() {
-    return this.config?.apiKey || process.env.GEMINI_API_KEY || '';
+    return resolveProviderApiKey('gemini', this.config);
+  }
+
+  // SDK client for the currently resolved key; rebuilt when the key changed
+  // since construction (e.g. a keyless-constructed instance).
+  _currentGenAI() {
+    const key = this._getApiKey();
+    if (!this._injectedGenAI && key !== this._genAIKey) {
+      this._genAIKey = key;
+      this.genAI = this._createGenAI(key);
+    }
+    return this.genAI;
   }
 
   /**
@@ -250,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;
@@ -430,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;
     }
@@ -561,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);
   }
 
@@ -630,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,
@@ -645,8 +689,7 @@ export class GeminiProvider {
           });
           return { response, textLeakGuard };
         },
-        { signal: totalSignal, onRetry: geminiRetryLogger(opts, '[gemini-rest]') }
-      );
+      });
     } catch (err) {
       if (
         !internal.skipExplicitCache &&
@@ -673,7 +716,7 @@ export class GeminiProvider {
 
   async _streamViaSdk(stream) {
     const { opts, signal, useModel, systemInstruction, geminiTools, toolConfig, generationConfig, contents } = stream;
-    const genModel = this.genAI.getGenerativeModel({
+    const genModel = this._currentGenAI().getGenerativeModel({
       model: useModel,
       systemInstruction,
       tools: geminiTools,
@@ -685,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,
@@ -714,7 +760,7 @@ export class GeminiProvider {
     const cached = this._modelCache.loadSync();
     if (cached) return cached;
     // Dynamic lookup via Gemini v1beta /models. Requires API key.
-    const apiKey = this.config.apiKey || process.env.GEMINI_API_KEY;
+    const apiKey = this._getApiKey();
     if (!apiKey) return MODELS; // no key — return minimal static list
     try {
       return await this._fetchAndCacheModels(apiKey);
@@ -738,26 +784,26 @@ export class GeminiProvider {
 
   // Force a catalog refresh (ignores the 24h disk TTL). De-duped via
   // _modelRefreshInFlight so concurrent callers share one HTTP round-trip.
-  // Fire-and-forget context: failures are caught/logged, returning null.
+  // Resolves null when there is no key; fetch/normalize failures reject so
+  // callers (registry refresh) report them.
   async _refreshModelCache() {
     if (_modelRefreshInFlight) return _modelRefreshInFlight;
-    _modelRefreshInFlight = (async () => {
-      try {
-        const apiKey = this.config.apiKey || process.env.GEMINI_API_KEY;
-        if (!apiKey) return null; // no key — nothing to refresh
-        const enriched = await this._fetchAndCacheModels(apiKey);
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(`[gemini] catalog refreshed (${enriched.length} models)\n`);
-        return enriched;
-      } catch (err) {
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(`[gemini] catalog refresh failed (${err.message})\n`);
-        return null;
-      } finally {
-        _modelRefreshInFlight = null;
-      }
+    const refresh = (async () => {
+      const apiKey = this._getApiKey();
+      if (!apiKey) return null; // no key — nothing to refresh
+      const enriched = await this._fetchAndCacheModels(apiKey);
+      if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
+        process.stderr.write(`[gemini] catalog refreshed (${enriched.length} models)\n`);
+      return enriched;
     })();
-    return _modelRefreshInFlight;
+    // Clear only after the shared promise is published: a refresh that settles
+    // synchronously (no key) must not leave its settled promise memoized.
+    _modelRefreshInFlight = refresh;
+    try {
+      return await refresh;
+    } finally {
+      if (_modelRefreshInFlight === refresh) _modelRefreshInFlight = null;
+    }
   }
 
   async isAvailable() {
@@ -766,7 +812,7 @@ export class GeminiProvider {
       controller.abort(providerTimeoutError('Gemini availability probe', GEMINI_AVAILABILITY_TIMEOUT_MS));
     }, GEMINI_AVAILABILITY_TIMEOUT_MS);
     try {
-      const model = this.genAI.getGenerativeModel({ model: DEFAULT_MODEL });
+      const model = this._currentGenAI().getGenerativeModel({ model: DEFAULT_MODEL });
       const generation = Promise.resolve(model.generateContent('hi', { signal: controller.signal }));
       generation.catch(() => {});
       await Promise.race([

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/lib/gemini-model-catalog.mjs

@@ -79,7 +79,13 @@ function resolveLatestGeminiModel() {
 export async function ensureLatestGeminiModel(provider) {
   let model = resolveLatestGeminiModel();
   if (model) return model;
-  await provider._refreshModelCache();
+  try {
+    await provider._refreshModelCache();
+  } catch (err) {
+    throw new Error(`[gemini] model catalog refresh failed — cannot resolve default model (${err.message})`, {
+      cause: err,
+    });
+  }
   model = resolveLatestGeminiModel();
   if (model) return model;
   throw new Error('[gemini] model catalog unavailable after warmup — cannot resolve default model');

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;