mixdog 0.9.174 → 1.0.0

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

@@ -10,24 +10,7 @@ import {
   toAnthropicMessages,
 } from './lib/anthropic-request-utils.mjs';
 import { _capabilitySupported, _defaultContextForModel, _prettyName, modelTier } from './anthropic-model-resolve.mjs';
-
-// System blocks carry their own cache tier; anything else is the default tier.
-const SYSTEM_CACHE_TIERS = new Set(['tier3', 'env']);
-const systemCacheTier = (cacheTier) => (SYSTEM_CACHE_TIERS.has(cacheTier) ? cacheTier : 'system');
-
-/** Non-empty system messages as `{ text, tier }` block items; a non-array yields none. */
-export function systemBlockItems(systemMsgs) {
-  const items = [];
-  for (const m of Array.isArray(systemMsgs) ? systemMsgs : []) {
-    const text = typeof m?.content === 'string' ? m.content.trim() : '';
-    if (text) items.push({ text, tier: systemCacheTier(m?.cacheTier) });
-  }
-  return items;
-}
-/** cacheTier:'env' (volatile session/project environment) is never marked —
- *  it rides the messages-tail breakpoint; a null TTL leaves the block uncached. */
-export const systemBlockTtl = (tier, { tier3Ttl, systemTtl }) =>
-  ({ tier3: tier3Ttl, env: null, system: systemTtl })[tier];
+import { systemBlockItems, systemBlockTtl } from './lib/anthropic-system-blocks.mjs';
 
 // Message lowering lives in the shared request-utils lib (one implementation
 // for both Anthropic providers); re-exported here for existing importers.
@@ -82,15 +65,6 @@ export function buildSystemBlocks(systemMsgs, systemTtl, tier3Ttl) {
   });
 }
 
-// Offline fallback for both Anthropic routes when /v1/models is unavailable:
-// the current generation only, one id per family.
-export const MODELS = [
-  { id: 'claude-opus-5-5', name: 'Claude Opus 5.5', provider: 'anthropic', family: 'opus', contextWindow: 1000000 },
-  { id: 'claude-fable-5-1', name: 'Claude Fable 5.1', provider: 'anthropic', family: 'fable', contextWindow: 1000000 },
-  { id: 'claude-sonnet-5', name: 'Claude Sonnet 5', provider: 'anthropic', family: 'sonnet', contextWindow: 1000000 },
-];
-export const ANTHROPIC_VERSION = '2023-06-01';
-
 export function _normalizeAnthropicModel(raw, provider = 'anthropic') {
   const id = raw?.id || raw?.name || raw?.model;
   if (!id) return null;
@@ -110,7 +84,7 @@ export function _normalizeAnthropicModel(raw, provider = 'anthropic') {
       raw?.max_input_tokens ||
       raw?.input_token_limit ||
       raw?.inputTokenLimit ||
-      _defaultContextForModel(id, family),
+      _defaultContextForModel(id),
     outputTokens: raw?.max_tokens || raw?.max_output_tokens || raw?.output_token_limit || raw?.outputTokenLimit || null,
     tier: modelTier(dated, versioned),
     latest: false,
@@ -118,8 +92,6 @@ export function _normalizeAnthropicModel(raw, provider = 'anthropic') {
     reasoningOptions: effortValues.length ? [{ type: 'effort', values: effortValues }] : [],
   };
 }
-// Family-based heuristic so new model ids (including custom user-configured
-// ones) resolve a sensible max_tokens without requiring a code change.
 // The API-key provider has no catalog cache of its own — it reads the same
 // anthropic-oauth-models.json disk cache (read-only) that the OAuth provider
 // maintains. Both providers hit the same Anthropic /v1/models catalog, so a
@@ -170,21 +142,6 @@ export const _test = {
   sanitizeInputSchema: (schema, toolName) => sanitizeAnthropicInputSchema(schema, toolName, 'anthropic'),
 };
 
-// Anthropic forbids oneOf / allOf / anyOf at the TOP level of input_schema.
-// Mirror the same sanitizer as anthropic-oauth.mjs so both providers are safe.
-// Map the orchestrator-level opts.toolChoice into Anthropic's tool_choice.
-// Only 'none' is activated: it lets the hard-cap final turn keep the tool
-// DEFINITIONS in-request (so the tools->system->messages prefix — and its
-// prompt-cache prefix — stay byte-identical to prior turns) while forbidding
-// tool USE, so the model can only emit text. Forced values
-// ('required'->{type:'any'}, {name}->{type:'tool'}) are deliberately NOT
-// mapped: Anthropic returns a 400 for any forced tool_choice while
-// extended/adaptive thinking is enabled, and the only caller that sets
-// opts.toolChoice='required' (the forced-first-tool turn) runs with
-// effort/thinking active on reasoning models — activating it would convert a
-// previously-harmless no-op into a hard 400 on exactly that turn. Attached
-// only when the request actually carries tools (see _doSend). Mirrors
-// anthropic-oauth.mjs.
 function deferredAnthropicTools(activeTools, messages, opts) {
   return sharedDeferredAnthropicTools(activeTools, messages, opts, 'anthropic');
 }
@@ -197,17 +154,3 @@ export function requestAnthropicTools(tools, messages, opts) {
 export function _toAnthropicMessagesForTest(messages, availableTools) {
   return toAnthropicMessages(messages, availableTools);
 }
-
-// Applies cache_control markers to the FINAL, already-sanitized Anthropic
-// message array — by INVARIANT, never by pre-sanitize index. Because
-// sanitizeAnthropicContentPairs has already run (and must NOT run again
-// after this), the blocks we mark here are exactly the blocks the provider
-// sees, so the cache breakpoint is stable across turns.
-//   message-anchor: prefer a safe tool_result tail, then a previous real user
-//                   text turn if another slot remains. Synthetic
-//                   synthetic reminder messages and current pure-text prompts
-//                   are excluded so per-call prompt content never becomes a
-//                   1h prefix key.
-// messageTtl === null disables the tail. BP3 (tier3) now rides a system block,
-// so it is no longer marked here.
-// ANTHROPIC_MSG_SLOTS=0 is honoured upstream by passing messageTtl = null.

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

@@ -43,21 +43,6 @@ export function createAnthropicMidState(attemptIndex) {
   };
 }
 
-/**
- * @param {object} deps
- * @param {string} deps.label  stderr log tag (provider instance name)
- * @param {string} deps.outcomeProvider  provider id on the canonical outcome stamp
- * @param {string} deps.midstreamOwner  recovery owner recorded when retries are exhausted
- * @param {string} deps.unreachableMessage  message of the never-observed loop-exit error
- * @param {boolean} [deps.initialResponseErrorTerminal]  true when the caller's
- *   request-level retry already spent the budget for a non-OK initial response,
- *   so such an error must not earn an extra SSE retry here
- * @param {number} deps.maxRetries  bounded mid-stream retries for transient stream loss
- * @param {AbortSignal|null} deps.totalSignal
- * @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
- */
 /**
  * Empty-stream guard. Invariant: a valid Anthropic SSE response ALWAYS opens
  * with message_start (which carries usage.input_tokens). A 200 whose body
@@ -87,8 +72,25 @@ export function assertAnthropicStreamNotEmpty(midState, result, label) {
   }
 }
 
+/**
+ * @param {object} deps
+ * @param {string} deps.label  stderr log tag (provider instance name)
+ * @param {string} [deps.displayName]  provider name in error text (default "Anthropic OAuth")
+ * @param {string} deps.outcomeProvider  provider id on the canonical outcome stamp
+ * @param {string} deps.midstreamOwner  recovery owner recorded when retries are exhausted
+ * @param {string} deps.unreachableMessage  message of the never-observed loop-exit error
+ * @param {boolean} [deps.initialResponseErrorTerminal]  true when the caller's
+ *   request-level retry already spent the budget for a non-OK initial response,
+ *   so such an error must not earn an extra SSE retry here
+ * @param {number} deps.maxRetries  bounded mid-stream retries for transient stream loss
+ * @param {AbortSignal|null} deps.totalSignal
+ * @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
+ */
 export function createAnthropicMidstreamRecovery({
   label,
+  displayName = 'Anthropic OAuth',
   outcomeProvider,
   midstreamOwner,
   unreachableMessage,
@@ -108,17 +110,22 @@ export function createAnthropicMidstreamRecovery({
   let firstAttemptClassifier = null;
   const retry = { retry: true };
   const settled = (value) => ({ retry: false, value });
+  const sleepBackoff = (ms) =>
+    _midstreamSleepWithAbort(ms, totalSignal, undefined, `${displayName} mid-stream retry backoff aborted`);
+  const abortStream = (controller, err) => {
+    try {
+      controller?.abort?.(err);
+    } catch {
+      /* best-effort teardown */
+    }
+  };
 
   // Jittered backoff between streaming attempts; the dead stream is torn
   // down first so its socket returns to the pool.
   const retryStreaming = async ({ err, classifier, controller, attemptIndex, message, delayMs = null }) => {
     firstAttemptError = err;
     firstAttemptClassifier = classifier;
-    try {
-      controller?.abort?.(err);
-    } catch {
-      /* best-effort teardown */
-    }
+    abortStream(controller, err);
     log(message);
     const waitMs = delayMs ?? midstreamBackoffFor(attemptIndex + 1);
     emitProviderRetryStage(onStageChange, {
@@ -127,7 +134,7 @@ export function createAnthropicMidstreamRecovery({
       lastErr: err,
       delayMs: waitMs,
     });
-    await _midstreamSleepWithAbort(waitMs, totalSignal);
+    await sleepBackoff(waitMs);
     return retry;
   };
 
@@ -154,9 +161,7 @@ export function createAnthropicMidstreamRecovery({
     // agent loop retracts any exposed text and replays it with a split-call
     // notice.
     if (!midState.userAbort && isToolInputCut(err)) {
-      try {
-        controller?.abort?.(err);
-      } catch {}
+      abortStream(controller, err);
       throw err;
     }
     // Acknowledged reset semantics let the owner tombstone this
@@ -173,9 +178,7 @@ export function createAnthropicMidstreamRecovery({
     // incomplete, never dispatched tool input stays replay-safe.
     // Every retry branch below relies on this early exit.
     if (outcome?.replayUnsafe === true) {
-      try {
-        controller?.abort?.(err);
-      } catch {}
+      abortStream(controller, err);
       throw err;
     }
     // The request-level retry loop already exhausted its full budget on a
@@ -185,9 +188,7 @@ export function createAnthropicMidstreamRecovery({
     // A background call never retries an overload, mid-stream included (see
     // withRetry): nobody waits on it and every retry adds load.
     if (retry529 === false && Number(err?.httpStatus || err?.status || 0) === 529) {
-      try {
-        controller?.abort?.(err);
-      } catch {}
+      abortStream(controller, err);
       throw err;
     }
     const canRetry = attemptIndex < maxRetries;
@@ -288,7 +289,7 @@ export function createAnthropicMidstreamRecovery({
         lastErr: err,
         delayMs: waitMs,
       });
-      await _midstreamSleepWithAbort(waitMs, totalSignal);
+      await sleepBackoff(waitMs);
       return retry;
     }
     if (classifier && !canRetry) {

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

@@ -91,7 +91,7 @@ export function _normalizeAnthropicModel(raw) {
     family,
     provider: 'anthropic-oauth',
     contextWindow:
-      raw?.context_window || raw?.max_context_window || raw?.max_input_tokens || _defaultContextForModel(id, family),
+      raw?.context_window || raw?.max_context_window || raw?.max_input_tokens || _defaultContextForModel(id),
     outputTokens: raw?.max_tokens || raw?.max_output_tokens || null,
     tier,
     latest: false, // assigned in a second pass once full list is known
@@ -115,7 +115,7 @@ export function _prettyName(id, family) {
   return `${base} ${v[1]}${minor}`;
 }
 
-export function _defaultContextForModel(id, _family) {
+export function _defaultContextForModel(id) {
   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

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 
 // Anthropic validates the Claude Code client identity carried by OAuth
 // requests. This floor ships with Mixdog, while a newer server-advertised
@@ -15,6 +16,9 @@ const CACHE_FILE_NAME = 'anthropic-oauth-cli-version.json';
 const VERSION_GATE_PATTERN =
   /Claude Code\s+(\d{1,4}\.\d{1,4}\.\d{1,6})\s+does not support this model;\s*version\s+(\d{1,4}\.\d{1,4}\.\d{1,6})\s+or newer is required\b/i;
 
+// Effective version = max(floor, learned minimum, live @anthropic-ai/claude-code).
+const liveCliVersion = createNpmVersionSource('@anthropic-ai/claude-code');
+
 let learnedCliVersion = null;
 let learnedCliVersionLoaded = false;
 
@@ -86,7 +90,12 @@ function persistLearnedCliVersion(cliVersion) {
 export function resolveCliVersion() {
   const explicit = String(process.env.MIXDOG_CLI_VERSION || '').trim();
   if (explicit) return explicit;
-  return loadLearnedCliVersion() || DEFAULT_CLI_VERSION;
+  return maxSemver(DEFAULT_CLI_VERSION, loadLearnedCliVersion(), liveCliVersion.sync());
+}
+
+/** Await before the first request so a cold start never sends a stale floor. */
+export async function warmCliVersion() {
+  if (!String(process.env.MIXDOG_CLI_VERSION || '').trim()) await liveCliVersion.warm();
 }
 
 /** The `user-agent` every Claude OAuth request sends for the resolved CLI version. */

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

@@ -15,8 +15,8 @@ import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { claudeCliUserAgent, resolveCliVersion } from './anthropic-oauth-client-version.mjs';
-import { expiryFromAccessToken, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
-import { createOAuthPkce } from './lib/oauth-pkce.mjs';
+import { expiryFromAccessToken, oauthCredentialStatus, scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
+import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
 
 // SSRF guard for the OAuth token endpoint override. Env-supplied URLs must be
 // https with a valid http(s) URL shape; reject file:/data:/ftp:/etc. and any
@@ -162,8 +162,6 @@ export function describeAnthropicOAuthCredentials() {
     const hasInferenceScope = Array.isArray(creds.scopes) && creds.scopes.includes('user:inference');
     const hasRefresh = Boolean(creds.refreshToken);
     const expiresAt = _normalizeExpiresAt(creds.expiresAt);
-    const expiring = expiresAt > 0 && expiresAt < Date.now() + TOKEN_REFRESH_SKEW_MS;
-    const expired = expiresAt > 0 && expiresAt <= Date.now();
     const detail = creds.path || DEFAULT_CREDENTIALS_PATH;
     if (!hasInferenceScope) {
       return {
@@ -176,46 +174,7 @@ export function describeAnthropicOAuthCredentials() {
         expiresAt,
       };
     }
-    if (!hasRefresh) {
-      return {
-        authenticated: expiresAt === 0 || !expired,
-        usable: expiresAt === 0 || !expired,
-        refreshable: false,
-        reauthRequired: expired,
-        status: expired ? 'Reauth Required' : 'Access Only',
-        detail: `${detail}; no refresh token`,
-        expiresAt,
-      };
-    }
-    if (expired)
-      return {
-        authenticated: true,
-        usable: false,
-        refreshable: true,
-        reauthRequired: false,
-        status: 'Refresh Required',
-        detail,
-        expiresAt,
-      };
-    if (expiring)
-      return {
-        authenticated: true,
-        usable: true,
-        refreshable: true,
-        reauthRequired: false,
-        status: 'Refresh Soon',
-        detail,
-        expiresAt,
-      };
-    return {
-      authenticated: true,
-      usable: true,
-      refreshable: true,
-      reauthRequired: false,
-      status: 'Valid',
-      detail,
-      expiresAt,
-    };
+    return oauthCredentialStatus({ hasRefresh, expiresAt, detail, refreshSkewMs: TOKEN_REFRESH_SKEW_MS });
   } catch (err) {
     return {
       authenticated: false,
@@ -303,7 +262,7 @@ async function _refreshOAuthCredentialsUnlocked(creds) {
   }
 
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 30_000);
+  const timeout = setTimeout(() => controller.abort(), OAUTH_TOKEN_TIMEOUT_MS);
   try {
     const res = await fetch(TOKEN_URL, {
       method: 'POST',
@@ -529,26 +488,18 @@ function _oauthParseScopeField(scope) {
     .filter(Boolean);
 }
 
+// A pasted callback URL also names the redirect_uri it came from; every other
+// shape (code#state, code=…, bare code) is the shared parser's.
 function _parseOAuthCodeInput(input) {
-  const value = String(input || '').trim();
-  if (!value) return { code: '', state: '' };
   try {
-    const url = new URL(value);
+    const url = new URL(String(input || '').trim());
     const code = url.searchParams.get('code') || '';
     const state = url.searchParams.get('state') || '';
     if (code || state) return { code, state, redirectUri: `${url.origin}${url.pathname}` };
   } catch {
     /* not a URL */
   }
-  if (value.includes('#')) {
-    const [code, state] = value.split('#', 2);
-    return { code: String(code || '').trim(), state: String(state || '').trim() };
-  }
-  if (value.includes('code=')) {
-    const params = new URLSearchParams(value.startsWith('?') ? value.slice(1) : value);
-    return { code: params.get('code') || '', state: params.get('state') || '' };
-  }
-  return { code: value, state: '' };
+  return parseOAuthCodeInput(input, { allowHashState: true });
 }
 
 async function exchangeAuthorizationCode({ pkce, code, state, redirectUri }) {
@@ -611,7 +562,7 @@ async function exchangeAuthorizationCode({ pkce, code, state, redirectUri }) {
   };
 }
 
-export async function beginOAuthLogin() {
+export async function beginOAuthLogin({ openBrowserFn = null } = {}) {
   const pkce = createOAuthPkce();
   const state = randomBytes(32).toString('base64url');
   const buildUrl = (redirectUri) => {
@@ -630,8 +581,8 @@ export async function beginOAuthLogin() {
   const manualUrl = buildUrl(OAUTH_MANUAL_REDIRECT_URI);
   const openLoginUrl = async (targetUrl, label = 'login') => {
     try {
-      const { openInBrowser } = await import('../../../shared/open-url.mjs');
-      openInBrowser(targetUrl.toString());
+      const openInBrowser = openBrowserFn || (await import('../../../shared/open-url.mjs')).openInBrowser;
+      await openInBrowser(targetUrl.toString());
     } catch (err) {
       process.stderr.write(
         `[anthropic-oauth] browser open failed for ${label} URL: ${String(err?.message || err).slice(0, 200)}\n`
@@ -665,9 +616,9 @@ export async function beginOAuthLogin() {
       }
       const code = u.searchParams.get('code');
       if (!code || u.searchParams.get('state') !== state) {
+        // Reject this request only; the valid callback may still arrive.
         res.writeHead(400);
         res.end('Invalid');
-        finish(null);
         return;
       }
       try {

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

@@ -9,9 +9,10 @@ import { promisify } from 'node:util';
 import { gzip } from 'node:zlib';
 import { getLlmDispatcher } from '../../../../shared/llm/http-agent.mjs';
 import { claudeCliUserAgent } from '../anthropic-oauth-client-version.mjs';
+import { ANTHROPIC_VERSION } from '../lib/anthropic-models.mjs';
 
 const API_URL = 'https://api.anthropic.com/v1/messages';
-export const ANTHROPIC_VERSION = '2023-06-01';
+export { ANTHROPIC_VERSION };
 
 const ANTHROPIC_REQ_GZIP_MIN_BYTES = 8 * 1024;
 let gzipLatchedOff = false;

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

@@ -12,6 +12,7 @@ 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,
   ANTHROPIC_RETRY_JITTER_RATIO,
@@ -66,6 +67,7 @@ export function createAnthropicOAuthRequest({
       // provider-visible cache breakpoint off the cached one — the
       // exact COLD-turn bug this change fixes. Order is fixed:
       // build → sanitize (once) → mark → prepare image bytes → JSON.stringify.
+      noteRequestServiceTier(requestBody?.speed);
       const response = await postMessages({
         accessToken,
         requestBody,

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

@@ -8,8 +8,10 @@
 import { traceAgentSse, traceAgentUsage } from '../agent-trace.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { resolveAnthropicMaxTokens } from './anthropic-max-tokens.mjs';
-import { MODELS, systemBlockItems, systemBlockTtl } from './anthropic-messages.mjs';
+import { MODELS } from './lib/anthropic-models.mjs';
+import { systemBlockItems, systemBlockTtl } from './lib/anthropic-system-blocks.mjs';
 import { prepareAnthropicImages } from './lib/anthropic-image-input.mjs';
+import { streamCallbacks } from './lib/send-callbacks.mjs';
 import {
   _loadModelCache,
   _setInMemoryCatalog,
@@ -34,7 +36,7 @@ import {
   beginOAuthLogin,
   loginOAuth,
 } from './anthropic-oauth-credentials.mjs';
-import { claudeCliUserAgent, learnRequiredCliVersion } from './anthropic-oauth-client-version.mjs';
+import { claudeCliUserAgent, learnRequiredCliVersion, warmCliVersion } from './anthropic-oauth-client-version.mjs';
 import { createPassthroughSignal } from '../stall-policy.mjs';
 import { AnthropicFallbackTriggeredError } from './retry-classifier.mjs';
 import { ANTHROPIC_MAX_MIDSTREAM_RETRIES, parseSSEStream, _classifyMidstreamError } from './anthropic-sse.mjs';
@@ -58,6 +60,13 @@ import {
   toAnthropicMessages,
   toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
+import {
+  EFFORT_CONFIGURATION_BETA,
+  projectEffortConfiguration,
+  lowerAnthropicEffortHistory,
+  markAnthropicEffortBody,
+  usesAnthropicEffortBody,
+} from './effort-configuration.mjs';
 
 // SSE progress emits (per-request "Response …" and "Done:" lines). Off by default.
 const SSE_VERBOSE = process.env.MIXDOG_SSE_VERBOSE === '1';
@@ -75,13 +84,10 @@ const _oauthRefreshes = new Map();
 const CLAUDE_CODE_SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
 const OAUTH_BETA_HEADERS =
   'oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,extended-cache-ttl-2025-04-11';
-import {
-  EFFORT_CONFIGURATION_BETA,
-  projectEffortConfiguration,
-  lowerAnthropicEffortHistory,
-  markAnthropicEffortBody,
-  usesAnthropicEffortBody,
-} from './effort-configuration.mjs';
+
+function logQuiet(line) {
+  if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[anthropic-oauth] ${line}\n`);
+}
 
 function requiresSystemPrefix(model) {
   // High-tier Claude OAuth models require the first-party system prefix for
@@ -172,22 +178,6 @@ function resolveMaxTokens(model) {
 
 // --- Message conversion ---
 
-// Anthropic's tool spec forbids oneOf / allOf / anyOf at the TOP level of
-// input_schema (nested usage inside properties is allowed). External MCP
-// servers sometimes emit such schemas.
-// Convert them to a flat object schema so the API never sees a 400.
-// Map the orchestrator-level opts.toolChoice into Anthropic's tool_choice.
-// Only 'none' is activated: it lets the hard-cap final turn keep the tool
-// DEFINITIONS in-request (so the tools->system->messages prefix — and its
-// prompt-cache prefix — stay byte-identical to prior turns) while forbidding
-// tool USE, so the model can only emit text. Forced values
-// ('required'->{type:'any'}, {name}->{type:'tool'}) are deliberately NOT
-// mapped: Anthropic returns a 400 for any forced tool_choice while
-// extended/adaptive thinking is enabled, and the only caller that sets
-// opts.toolChoice='required' (the forced-first-tool turn) runs with
-// effort/thinking active on reasoning models — activating it would convert a
-// previously-harmless no-op into a hard 400 on exactly that turn. Attached
-// only when the request actually carries tools (see buildRequestBody).
 function deferredAnthropicTools(activeTools, messages, opts) {
   return sharedDeferredAnthropicTools(activeTools, messages, opts, 'anthropic-oauth');
 }
@@ -195,19 +185,6 @@ function requestAnthropicTools(tools, messages, opts) {
   return sharedRequestAnthropicTools(tools, messages, opts, 'anthropic-oauth');
 }
 
-// Applies cache_control markers to the FINAL, already-sanitized Anthropic
-// message array — by INVARIANT, never by pre-sanitize index. Because
-// sanitizeAnthropicContentPairs has already run (and must NOT run again
-// after this), the blocks we mark here are exactly the blocks the provider
-// sees, so the cache breakpoint is stable across turns.
-//   message-anchor: prefer a safe tool_result tail, then a previous real user
-//                   text turn if another slot remains. Synthetic
-//                   <system-reminder> messages and current pure-text prompts
-//                   are excluded so first-turn prompts do not create a fresh
-//                   BP4 write on every new session.
-// messageTtl === null disables the tail. BP3 (tier3) now rides a system block,
-// so it is no longer marked here.
-// ANTHROPIC_MSG_SLOTS=0 is honoured upstream by passing messageTtl = null.
 // --- Build request body ---
 
 // BP3 (tier3) is injected by session/manager as its own `system` role block —
@@ -312,6 +289,7 @@ export class AnthropicOAuthProvider {
   }
 
   async ensureAuth({ forceRefresh = false, reason = 'preemptive' } = {}) {
+    await warmCliVersion();
     if (!this.credentials) {
       this.credentials = loadCredentials();
     }
@@ -327,8 +305,7 @@ export class AnthropicOAuthProvider {
       const fresh = loadCredentials();
       if (fresh?.accessToken) {
         this.credentials = fresh;
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk (mtime change)\n`);
+        logQuiet('Credentials reloaded from disk (mtime change)');
       }
     }
 
@@ -358,8 +335,7 @@ export class AnthropicOAuthProvider {
     const validAfter = Date.now() + (force ? 0 : TOKEN_REFRESH_SKEW_MS);
     if (disk?.accessToken && disk.accessToken !== currentToken && (!disk.expiresAt || disk.expiresAt >= validAfter)) {
       this.credentials = disk;
-      if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-        process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk\n`);
+      logQuiet('Credentials reloaded from disk');
       return disk;
     }
     if (!this.credentials && disk) this.credentials = disk;
@@ -380,36 +356,29 @@ export class AnthropicOAuthProvider {
         latest.accessToken !== currentToken &&
         (!latest.expiresAt || latest.expiresAt >= latestValidAfter)
       ) {
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(`[anthropic-oauth] Credentials reloaded from disk\n`);
+        logQuiet('Credentials reloaded from disk');
         return latest;
       }
 
       if (!latest?.refreshToken) {
         if (!force && latest?.accessToken && (!latest.expiresAt || latest.expiresAt > Date.now())) {
-          if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-            process.stderr.write(
-              `[anthropic-oauth] WARNING: token expiring but no refresh token; using current token until expiry\n`
-            );
+          logQuiet('WARNING: token expiring but no refresh token; using current token until expiry');
           return latest;
         }
         throw new Error('Anthropic OAuth refresh token not available. Open /providers in mixdog to sign in again.');
       }
 
       try {
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(`[anthropic-oauth] Token ${reason}, refreshing...\n`);
+        logQuiet(`Token ${reason}, refreshing...`);
         const refreshed = await refreshOAuthCredentials(latest);
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(
-            `[anthropic-oauth] Token refreshed, expires in ${Math.round(((refreshed.expiresAt || Date.now()) - Date.now()) / 1000)}s\n`
-          );
+        logQuiet(
+          `Token refreshed, expires in ${Math.round(((refreshed.expiresAt || Date.now()) - Date.now()) / 1000)}s`
+        );
         return refreshed;
       } catch (err) {
         if (!force && latest?.accessToken && (!latest.expiresAt || latest.expiresAt > Date.now())) {
           const msg = err instanceof Error ? err.message : String(err);
-          if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-            process.stderr.write(`[anthropic-oauth] Refresh failed (${msg}); using still-valid current token\n`);
+          logQuiet(`Refresh failed (${msg}); using still-valid current token`);
           return latest;
         }
         throw err;
@@ -428,6 +397,7 @@ export class AnthropicOAuthProvider {
   }
 
   async send(messages, model, tools, sendOpts) {
+    await warmCliVersion();
     // Re-warm the kept-alive socket before the turn. preconnect() is a
     // best-effort no-op while a socket is still hot (TTL gate), but after an
     // idle gap longer than the keep-alive window it re-opens one in parallel
@@ -441,11 +411,7 @@ export class AnthropicOAuthProvider {
     // a hard 400. Pairing here closes the gap regardless of caller.
     messages = sanitizeToolPairs(messages);
     const opts = sendOpts || {};
-    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);
     const externalSignal = opts.signal || null;
     // Test seam: lets the retry harness drive stream outcomes without a
     // live OAuth session.
@@ -772,8 +738,7 @@ export class AnthropicOAuthProvider {
     try {
       return await this._fetchModelCatalog();
     } catch (err) {
-      if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-        process.stderr.write(`[anthropic-oauth] listModels fetch failed (${err.message})\n`);
+      logQuiet(`listModels fetch failed (${err.message})`);
       // Fallback with full API model IDs (the shared offline list). Short
       // family tokens leaked through here would be accepted by setup and
       // reintroduce the legacy shape. ANTHROPIC_DEFAULT_<FAMILY>_MODEL
@@ -797,12 +762,10 @@ export class AnthropicOAuthProvider {
     _modelRefreshInFlight = (async () => {
       try {
         const enriched = await this._fetchModelCatalog();
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(`[anthropic-oauth] catalog refreshed (${enriched.length} models)\n`);
+        logQuiet(`catalog refreshed (${enriched.length} models)`);
         return enriched;
       } catch (err) {
-        if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
-          process.stderr.write(`[anthropic-oauth] catalog refresh failed (${err.message})\n`);
+        logQuiet(`catalog refresh failed (${err.message})`);
         return null;
       } finally {
         _modelRefreshInFlight = null;