mixdog 1.2.1 → 1.2.3

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

@@ -24,6 +24,8 @@ import {
 } from './retry-classifier.mjs';
 import { _classifyMidstreamError, _midstreamSleepWithAbort, stampAnthropicStreamOutcome } from './anthropic-sse.mjs';
 import { notifyCurrentAnthropicRateLimit } from './admission-scheduler.mjs';
+import { applyAnthropicErrorContract } from './anthropic-error-contract.mjs';
+import { isAnthropicOverloadError } from './anthropic-overload-fallback.mjs';
 import { noteAbandonedUsage } from '../../../shared/llm/usage-context.mjs';
 
 export function createAnthropicMidState(attemptIndex) {
@@ -88,6 +90,8 @@ export function assertAnthropicStreamNotEmpty(midState, result, label) {
  * @param {{ recoverNonStreaming: Function, issueNonStreamingFallback: Function, requireTransportRecoveryBudget: Function }} deps.recovery
  * @param {Function|null} [deps.onStageChange]  receives the display-only 'reconnecting' stage per retry
  * @param {boolean} [deps.retry529]  false for a background call: an overload mid-stream is not retried
+ * @param {ReturnType<typeof import('./anthropic-overload-fallback.mjs').createAnthropicOverloadTracker>|null} [deps.overload]
+ *   the send's shared overload counter (SSE overloads feed it)
  */
 export function createAnthropicMidstreamRecovery({
   label,
@@ -101,6 +105,7 @@ export function createAnthropicMidstreamRecovery({
   recovery,
   onStageChange = null,
   retry529 = true,
+  overload = null,
 }) {
   const log = (line) => {
     try {
@@ -128,7 +133,7 @@ export function createAnthropicMidstreamRecovery({
     firstAttemptClassifier = classifier;
     abortStream(controller, err);
     log(message);
-    const waitMs = delayMs ?? midstreamBackoffFor(attemptIndex + 1);
+    const waitMs = delayMs ?? midstreamBackoffFor(attemptIndex + 1, undefined, err);
     emitProviderRetryStage(onStageChange, {
       attempt: attemptIndex + 1,
       maxAttempts: maxRetries,
@@ -192,6 +197,16 @@ export function createAnthropicMidstreamRecovery({
       abortStream(controller, err);
       throw err;
     }
+    // An SSE overload counts toward the same limit as a request-loop 529; at
+    // the limit the configured fallback model takes over (the provider's
+    // send loop catches the trigger around this whole recovery).
+    if (overload && isAnthropicOverloadError(err)) {
+      const trigger = overload.noteStreamOverload(err);
+      if (trigger) {
+        abortStream(controller, err);
+        throw trigger;
+      }
+    }
     const canRetry = attemptIndex < maxRetries;
     const attemptLabel = `${attemptIndex + 1}/${maxRetries}`;
     // Empty/dropped stream (no message_start): safe to retry once —
@@ -270,10 +285,9 @@ export function createAnthropicMidstreamRecovery({
       const status = Number(err?.httpStatus || err?.status || 0);
       let retryDelayMs = null;
       if (status === 429) {
-        if (!err.headers && response?.headers) err.headers = response.headers;
         if (!err.response && response) err.response = { status, headers: response.headers };
+        applyAnthropicErrorContract(err, { status, headers: response?.headers });
         retryDelayMs = retryAfterMsFromError(err);
-        if (retryDelayMs != null) err.retryAfterMs = retryDelayMs;
         notifyCurrentAnthropicRateLimit(err);
       }
       try {
@@ -283,7 +297,7 @@ export function createAnthropicMidstreamRecovery({
         log(`abort on stream error failed: ${abortErr?.message ?? String(abortErr)}`);
       }
       log(`mid-stream recovered: retry ${attemptLabel} (cause: ${classifier})`);
-      const waitMs = retryDelayMs ?? midstreamBackoffFor(attemptIndex + 1);
+      const waitMs = retryDelayMs ?? midstreamBackoffFor(attemptIndex + 1, undefined, err);
       emitProviderRetryStage(onStageChange, {
         attempt: attemptIndex + 1,
         maxAttempts: maxRetries,

package/src/runtime/agent/orchestrator/providers/anthropic-model-resolve.mjs

@@ -8,7 +8,12 @@
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
-import { effortValuesForModel, setModelEffortCapabilities } from './anthropic-effort.mjs';
+import {
+  effortValuesForModel,
+  setModelEffortCapabilities,
+  thinkingTypesFromCapabilities,
+} from './anthropic-effort.mjs';
+import { getModelMetadataSync } from './model-catalog.mjs';
 
 // Disk-backed cache so repeated process starts (cron, tool calls) don't
 // hammer /v1/models. 24h TTL matches the upstream client cadence.
@@ -85,6 +90,7 @@ export function _normalizeAnthropicModel(raw) {
   const tier = modelTier(dated, versioned);
   const releaseDate = dated ? id.match(/-(\d{4})(\d{2})(\d{2})$/) : null;
   const effortValues = effortValuesForModel(raw?.capabilities, id);
+  const thinkingTypes = thinkingTypesFromCapabilities(raw?.capabilities);
   return {
     id,
     display: raw?.display_name || _prettyName(id, family),
@@ -98,6 +104,7 @@ export function _normalizeAnthropicModel(raw) {
     releaseDate: releaseDate ? `${releaseDate[1]}-${releaseDate[2]}-${releaseDate[3]}` : null,
     supportsReasoning: effortValues.length > 0 || _capabilitySupported(raw?.capabilities?.thinking),
     reasoningOptions: effortValues.length ? [{ type: 'effort', values: effortValues }] : [],
+    ...(thinkingTypes ? { thinkingTypes } : {}),
   };
 }
 
@@ -115,7 +122,12 @@ export function _prettyName(id, family) {
   return `${base} ${v[1]}${minor}`;
 }
 
+// Context window for a roster row that reports none: the shared model catalog
+// (cached roster / LiteLLM / models.dev) first, else the pre-catalog family
+// windows.
 export function _defaultContextForModel(id) {
+  const declared = Number(getModelMetadataSync(id, 'anthropic')?.contextWindow);
+  if (Number.isFinite(declared) && declared > 0) return declared;
   const text = String(id || '');
   const version = text.match(/^claude-[a-z]+-(\d+)(?:-(\d+))?/i);
   if (Number(version?.[1] || 0) >= 5) return 1000000;

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

@@ -10,7 +10,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // source release just to advance the user-agent version.
 // Claude Opus 5.5 requires 2.1.280 or newer. The release workflow raises this
 // to the published CLI version (scripts/sync-client-version-floors.mjs).
-export const DEFAULT_CLI_VERSION = '2.1.299';
+export const DEFAULT_CLI_VERSION = '2.1.301';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

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

@@ -21,8 +21,16 @@ export function createMidState(attemptIndex) {
  * @param {ReturnType<import('./anthropic-oauth-recovery.mjs').createAnthropicOAuthRecovery>} deps.recovery
  * @param {Function|null} [deps.onStageChange]
  * @param {boolean} [deps.retry529]
+ * @param {object|null} [deps.overload]  the send's shared overload counter
  */
-export function createMidstreamRecovery({ maxRetries, totalSignal, recovery, onStageChange = null, retry529 = true }) {
+export function createMidstreamRecovery({
+  maxRetries,
+  totalSignal,
+  recovery,
+  onStageChange = null,
+  retry529 = true,
+  overload = null,
+}) {
   return createAnthropicMidstreamRecovery({
     label: 'anthropic-oauth',
     outcomeProvider: 'anthropic-oauth',
@@ -33,5 +41,6 @@ export function createMidstreamRecovery({ maxRetries, totalSignal, recovery, onS
     recovery,
     onStageChange,
     retry529,
+    overload,
   });
 }

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

@@ -8,7 +8,10 @@ import { PROVIDER_NONSTREAM_TOTAL_TIMEOUT_MS, createTimeoutSignal } from '../sta
 import { AnthropicFallbackTriggeredError, markProviderRecoveryExhausted } from './retry-classifier.mjs';
 import { cloneAnthropicEffortBody } from './effort-configuration.mjs';
 import { normalizeAnthropicNonStreamingResponse } from './lib/anthropic-request-utils.mjs';
+import { capForNonStreaming } from './anthropic-max-tokens-recovery.mjs';
 import { createAnthropicRecoveryGuards } from './anthropic-recovery-guards.mjs';
+import { applyAnthropicErrorContract } from './anthropic-error-contract.mjs';
+import { isRefreshableAuthRejection } from './anthropic-oauth-request/initial-status.mjs';
 
 /**
  * @param {object} deps
@@ -70,7 +73,7 @@ export function createAnthropicOAuthRecovery({
     const requestFallback = async (accessToken) => {
       const result = await requestWithRetry(
         accessToken,
-        cloneAnthropicEffortBody(body, { stream: false }),
+        capForNonStreaming(cloneAnthropicEffortBody(body, { stream: false })),
         lifetime.signal
       );
       fallback = result;
@@ -89,19 +92,30 @@ export function createAnthropicOAuthRecovery({
     };
     try {
       fallback = await requestFallback(auth.creds.accessToken);
-      if (fallback.response.status === 401) {
-        releaseFallback('Anthropic OAuth non-streaming fallback refreshing auth');
-        auth.creds = await provider.ensureAuth({ forceRefresh: true, reason: '401' });
-        fallback = await requestFallback(auth.creds.accessToken);
+      // Same refresh rule as the streaming request: every 401 and only the
+      // exact revoked-token 403 are refreshed and replayed once; an ordinary
+      // 403 stays terminal. A rejected body is drained once and reused below.
+      let rejectedBody = null;
+      if (fallback.response.status === 401 || fallback.response.status === 403) {
+        rejectedBody = await fallback.response.text().catch(() => '');
+        if (isRefreshableAuthRejection(fallback.response.status, rejectedBody)) {
+          const rejectedStatus = fallback.response.status;
+          releaseFallback('Anthropic OAuth non-streaming fallback refreshing auth');
+          auth.creds = await provider.ensureAuth({ forceRefresh: true, reason: String(rejectedStatus) });
+          fallback = await requestFallback(auth.creds.accessToken);
+          rejectedBody = null;
+        }
       }
       if (!fallback.response.ok) {
-        const text = await fallback.response.text().catch(() => '');
+        const text = rejectedBody ?? (await fallback.response.text().catch(() => ''));
         const fallbackError = new Error(
           `Anthropic OAuth API ${fallback.response.status}: ${provider.scrubTokens(text).slice(0, 200)}`
         );
-        fallbackError.status = fallback.response.status;
-        fallbackError.httpStatus = fallback.response.status;
-        throw fallbackError;
+        throw applyAnthropicErrorContract(fallbackError, {
+          status: fallback.response.status,
+          headers: fallback.response.headers,
+          bodyText: provider.scrubTokens(text),
+        });
       }
       const message = await fallback.response.json();
       return normalizeAnthropicNonStreamingResponse(message, useModel);

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

@@ -2,9 +2,23 @@
 // sampled: a 429 becomes a typed quota error and a transient status a
 // retryable error; both drain the response and release its abort wiring so
 // re-issuing the POST is safe.
-import { noteFastModeCapacityError } from '../anthropic-fast-mode.mjs';
+import { fastModeDowngraded, noteFastModeCapacityError } from '../anthropic-fast-mode.mjs';
+import { applyAnthropicErrorContract, retryAfterMsFromHeaders } from '../anthropic-error-contract.mjs';
 import { headerValue } from '../retry-classification.mjs';
-import { classifyError, retryAfterMsFromError } from '../retry-classifier.mjs';
+import { classifyError } from '../retry-classifier.mjs';
+
+// Anthropic's exact official revoked-token 403 body; any other 403 is an
+// ordinary permission/policy refusal and stays terminal.
+const REVOKED_TOKEN_MARKER = 'OAuth token has been revoked';
+
+/**
+ * True when a rejected initial response is one a forced credential refresh can
+ * fix: every 401, and only the exact revoked-token 403 signature. Shared by
+ * the streaming request and the non-streaming fallback.
+ */
+export function isRefreshableAuthRejection(status, bodyText) {
+  return status === 401 || (status === 403 && String(bodyText ?? '').includes(REVOKED_TOKEN_MARKER));
+}
 
 // A subscription-window refusal carries these unified quota headers. A 429
 // without them is an entitlement/routing refusal or a capacity blip — the
@@ -31,16 +45,13 @@ function formatRetryAfter(ms) {
 }
 
 export function anthropicQuotaError(status, headers, bodyText = '') {
-  const retryAfterMs = retryAfterMsFromError({ headers, response: { headers } });
+  const retryAfterMs = retryAfterMsFromHeaders(headers);
   const retryAfter = formatRetryAfter(retryAfterMs);
   const detail = bodyText ? `: ${String(bodyText).slice(0, 200)}` : '';
   const retry = retryAfter ? ` retryAfter=${retryAfter}` : '';
   const quota = hasQuotaHeaders(headers);
   const err = new Error(`Anthropic OAuth API ${status} ${quota ? 'quota/rate limit' : 'request rejected'}${retry}${detail}`);
   err.name = quota ? 'ProviderQuotaError' : 'ProviderRequestRejectedError';
-  err.code = quota ? 'PROVIDER_QUOTA' : 'PROVIDER_REQUEST_REJECTED';
-  err.httpStatus = status;
-  err.status = status;
   err.headers = headers;
   err.response = { status, headers };
   err.retryAfterMs = retryAfterMs;
@@ -50,7 +61,7 @@ export function anthropicQuotaError(status, headers, bodyText = '') {
   // SSE parsing can expose text or a tool call. It is therefore safe for the
   // request-local withRetry loop. Mid-stream paths stamp unsafeToRetry when
   // output/tool exposure actually occurs.
-  return err;
+  return applyAnthropicErrorContract(err, { status, headers, bodyText });
 }
 
 export async function judgeInitialStatus(result, requestBody, { provider, cleanupCancelHandler }) {
@@ -71,26 +82,41 @@ export async function judgeInitialStatus(result, requestBody, { provider, cleanu
     // in-loop; a drained or unavailable fast pool says nothing about
     // standard-speed capacity, so `speed` is dropped and the error is
     // flagged for a single standard-speed replay by the caller.
-    const fastDecision = noteFastModeCapacityError(
-      { httpStatus: status, headers: result?.response?.headers, message: quotaText },
-      { fast: requestBody?.speed === 'fast' }
-    );
-    const fastDowngraded = fastDecision === 'downgrade' || fastDecision === 'disabled';
-    if (fastDowngraded) delete requestBody.speed;
+    const fastDowngraded = dropFastSpeed(requestBody, status, result?.response?.headers, quotaText);
     throw Object.assign(anthropicQuotaError(status, result?.response?.headers, provider.scrubTokens(quotaText)), {
       initialResponseError: true,
       fastDowngraded,
     });
   }
+  let overloadText = '';
+  try {
+    overloadText = await result.response.text();
+  } catch {}
+  release();
+  // A drained fast pool (529) is replayed at standard speed within the same
+  // attempt, exactly like a fast-pool 429, instead of waiting out its window.
+  const fastDowngraded = dropFastSpeed(requestBody, status, result?.response?.headers, overloadText);
   const err = new Error(`Anthropic OAuth API ${status}`);
-  err.httpStatus = status;
-  err.status = status;
   err.headers = result?.response?.headers;
   err.response = { status, headers: result?.response?.headers };
   err.initialResponseError = true;
-  try {
-    await result.response.text();
-  } catch {}
-  release();
-  throw err;
+  err.fastDowngraded = fastDowngraded;
+  throw applyAnthropicErrorContract(err, {
+    status,
+    headers: result?.response?.headers,
+    bodyText: provider.scrubTokens(overloadText),
+  });
+}
+
+// Records a fast-pool capacity refusal; on an explicit downgrade/disable the
+// request drops `speed` and the caller replays once at standard speed. Any
+// other verdict ('ignored', 'retry-fast') leaves the request untouched.
+function dropFastSpeed(requestBody, status, headers, text) {
+  const decision = noteFastModeCapacityError(
+    { httpStatus: status, headers, message: text },
+    { fast: requestBody?.speed === 'fast' }
+  );
+  if (!fastModeDowngraded(decision)) return false;
+  delete requestBody.speed;
+  return true;
 }

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

@@ -11,7 +11,6 @@
 import { traceAgentFetch } from '../agent-trace.mjs';
 import { createAbortController } from '../../../shared/abort-controller.mjs';
 import { notifyCurrentAnthropicRateLimit } from './admission-scheduler.mjs';
-import { noteFastModeCapacityError } from './anthropic-fast-mode.mjs';
 import { noteRequestServiceTier } from '../../../shared/llm/usage-context.mjs';
 import {
   ANTHROPIC_RETRY_BACKOFF_MS,
@@ -21,6 +20,7 @@ import {
   emitProviderRetryStage,
   withRetry,
 } from './retry-classifier.mjs';
+import { ANTHROPIC_MAX_CONSECUTIVE_529 } from './retry-backoff.mjs';
 import { postMessages } from './anthropic-oauth-request/gzip-post.mjs';
 import { removeAbortListener, wireRequestAbort } from './anthropic-oauth-request/abort-wiring.mjs';
 import { judgeInitialStatus } from './anthropic-oauth-request/initial-status.mjs';
@@ -38,6 +38,7 @@ export { anthropicQuotaError } from './anthropic-oauth-request/initial-status.mj
  * @param {AbortSignal|null} deps.totalSignal  session-lifetime pass-through
  * @param {(requestBody: object) => string} deps.betaHeadersFor
  * @param {((stage: string) => void)|null} deps.onStageChange
+ * @param {{ state: { consecutive529Errors: number } }|null} [deps.overload]  the send's shared overload counter
  */
 export function createAnthropicOAuthRequest({
   provider,
@@ -48,8 +49,10 @@ export function createAnthropicOAuthRequest({
   totalSignal,
   betaHeadersFor,
   onStageChange,
+  overload = null,
 }) {
   const requestTimeoutMs = anthropicRequestTimeoutMs();
+  const isEnterprise = String(provider?.credentials?.subscriptionType || '').toLowerCase() === 'enterprise';
   const cleanupCancelHandler = (handler) => removeAbortListener(totalSignal, handler);
 
   const doRequest = async (accessToken, requestSignal = null, requestBody = body) => {
@@ -100,7 +103,7 @@ export function createAnthropicOAuthRequest({
         try {
           await judgeInitialStatus(result, requestBody, { provider, cleanupCancelHandler });
         } catch (err) {
-          // Fast-pool 429 before any byte was sampled: `speed` is already
+          // Fast-pool 429/529 before any byte was sampled: `speed` is already
           // dropped, so replay once at standard speed within this attempt.
           if (err?.fastDowngraded !== true) throw err;
           const replay = await doRequestImpl(accessToken, attemptSignal, requestBody);
@@ -118,23 +121,25 @@ export function createAnthropicOAuthRequest({
         // Max/Pro OAuth sessions use subscription quota windows. Claude
         // Code fails their 429s immediately rather than waiting through
         // the API-key/PAYG retry budget (which may carry hours-long
-        // Retry-After values).
-        retry429: false,
+        // Retry-After values). Enterprise bills PAYG-style, so its 429s
+        // are retried like an API key's.
+        retry429: isEnterprise,
         retry529: opts.retry529,
         perAttemptTimeoutMs: requestTimeoutMs,
         perAttemptLabel: 'Anthropic OAuth initial response',
         provider: 'anthropic',
+        // This transport honors the positive x-should-retry override.
+        honorShouldRetryTrue: true,
         model: useModel,
         fallbackModel: opts._fallbackTriggered ? undefined : opts.fallbackModel,
+        // One overload counter for the send: SSE overloads count toward the
+        // same limit as request-loop 529s.
+        overloadState: overload?.state,
+        overloadFallbackAfter: ANTHROPIC_MAX_CONSECUTIVE_529,
         onRetry: ({ attempt, maxAttempts, lastErr, delayMs, delayReason }) => {
           emitProviderRetryStage(onStageChange, { attempt: attempt + 1, maxAttempts, lastErr, delayMs });
           const status = Number(lastErr?.httpStatus || lastErr?.status || lastErr?.response?.status || 0) || null;
           if (status === 429) notifyCurrentAnthropicRateLimit(lastErr);
-          // Fast capacity exhausted: drop `speed` so the replay runs at
-          // standard speed instead of re-hitting the drained pool.
-          if (requestBody?.speed === 'fast' && noteFastModeCapacityError(lastErr, { fast: true }) !== 'retry-fast') {
-            delete requestBody.speed;
-          }
           const reason = status || lastErr?.code || lastErr?.message || 'network error';
           const suffix = delayReason ? ` (${delayReason})` : '';
           try {