mixdog 0.9.174 → 1.0.0

package/src/runtime/{shared/llm/index.mjs → agent/orchestrator/maintenance-preset.mjs}

@@ -11,8 +11,8 @@
  * preset id.
  */
 
-import { DEFAULT_MAINTENANCE } from '../../agent/orchestrator/config.mjs';
-import { readSection } from '../config.mjs';
+import { DEFAULT_MAINTENANCE } from './config.mjs';
+import { readSection } from '../../shared/config.mjs';
 
 function loadAgentConfig() {
   try {

package/src/runtime/agent/orchestrator/mcp/client-config.mjs

@@ -4,7 +4,8 @@
  * and the log scrubbing that keeps credentials out of connection messages.
  */
 
-/** Known auto-detect targets: port file path relative to tmpdir.
+/** Known auto-detect targets: the discovery-advert service name and the MCP
+ *  endpoint path on its port.
  *  Note: `mixdog` used to self-loopback via active-instance.json's
  *  httpPort, but that path went through channels' owner HTTP server which
  *  only exposes a subset of tools. The plugin's own tools are now injected

package/src/runtime/agent/orchestrator/mcp/client-transport.mjs

@@ -3,11 +3,7 @@
  * for: autoDetect (port discovered from a live service), streamable HTTP, SSE,
  * WebSocket, or a stdio child.
  */
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
 import { readServicePort } from '../../../shared/service-discovery.mjs';
-import { resolveRuntimeRoot } from '../../../shared/runtime-root.mjs';
 import {
   AUTO_DETECT_PORTS,
   expandEnvVars,
@@ -19,46 +15,21 @@ import {
   scrubMcpConnectionMessage,
 } from './client-config.mjs';
 
-function readPortFile(name, spec) {
-  const portFile = spec.dir === 'mixdog' ? join(resolveRuntimeRoot(), spec.file) : join(tmpdir(), spec.dir, spec.file);
-  if (!existsSync(portFile)) {
-    throw new Error(`autoDetect server "${name}": port file missing (${portFile})`);
-  }
-  const raw = readFileSync(portFile, 'utf-8').trim();
-  if (!spec.portField) return { port: parseInt(raw, 10), portFile };
-  try {
-    const json = JSON.parse(raw);
-    const v = json[spec.portField];
-    const port = typeof v === 'number' && Number.isFinite(v) ? v : Number(v);
-    if (!Number.isFinite(port)) {
-      throw new Error(`autoDetect server "${name}": portField "${spec.portField}" is not numeric in ${portFile}`);
-    }
-    return { port, portFile };
-  } catch (jsonErr) {
-    if (jsonErr instanceof Error && jsonErr.message.startsWith('autoDetect server')) throw jsonErr;
-    throw new Error(`autoDetect server "${name}": invalid JSON in port file ${portFile}`);
-  }
-}
-
 /**
- * Auto-detect: the port of a running service, from its pid-validated
- * discovery advert first, else the legacy port file. When the port came from
- * an advert, `advert` names it so a connect failure can distrust it — a
- * pid-live advert can point at a recycled-pid corpse port, and this transport
- * has no other health probe of its own.
+ * Auto-detect: the port of a running service from its pid-validated discovery
+ * advert. `advert` names it so a connect failure can distrust it — a pid-live
+ * advert can point at a recycled-pid corpse port, and this transport has no
+ * other health probe of its own.
  */
 function resolveAutoDetectUrl(name, cfg) {
   const spec = AUTO_DETECT_PORTS[cfg.autoDetect];
   if (!spec) throw new Error(`Unknown autoDetect target: "${cfg.autoDetect}"`);
-  let port = spec.discovery ? readServicePort(spec.discovery, { requirePid: false }) : null;
-  const advert = port && spec.discovery ? { service: spec.discovery, port } : null;
-  let portFile = null;
-  if (!port && spec.file) ({ port, portFile } = readPortFile(name, spec));
+  const port = readServicePort(spec.discovery, { requirePid: false });
   if (!port) throw new Error(`autoDetect server "${name}": live service advert missing`);
   if (!Number.isFinite(port) || port < 1 || port > 65535) {
-    throw new Error(`autoDetect server "${name}": invalid port value${portFile ? ` in ${portFile}` : ''}`);
+    throw new Error(`autoDetect server "${name}": invalid port value`);
   }
-  return { url: `http://127.0.0.1:${port}${spec.endpoint}`, advert };
+  return { url: `http://127.0.0.1:${port}${spec.endpoint}`, advert: { service: spec.discovery, port } };
 }
 
 function requestInitFor(cfg) {

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -1,3 +1,4 @@
+import { setMaxListeners } from 'node:events';
 import { mkdirSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import { basename, join, resolve } from 'node:path';
@@ -323,12 +324,12 @@ export async function executeMcpTool(name, args, options = {}) {
   const server = scopedServer(scopeId, serverName);
   if (!server) throw new Error(`MCP server "${serverName}" not connected`);
   const definition = (server.tools || []).find((tool) => tool.name === name);
+  const callSignal = options?.signal || null;
   const dispatch = (target) =>
     definition?.mcpOperation
       ? _callMcpFeatureWithTimeout(target, definition.mcpOperation, args, callSignal)
       : _callToolWithTimeout(target, toolName, args, callSignal);
   const gate = callAdmissionFor(server);
-  const callSignal = options?.signal || null;
   return gate.run(
     options?.ownerKey || currentToolExecutionOwner(),
     async () => {
@@ -502,11 +503,31 @@ function isMcpCallAbortError(err) {
   return err?.code === 'EMCPCALLABORTED' || err?.name === 'AbortError';
 }
 
+// One turn signal is shared by every parallel MCP call of that turn, and each
+// in-flight call holds two abort listeners on it (this race and the SDK
+// request), both removed when the call settles. Node's default of 50 warned at
+// ~25 parallel calls (`MaxListenersExceededWarning: 51 abort listeners`) although
+// nothing accumulated. The ceiling is high enough for real fan-out and still
+// warns on a genuine leak.
+const MCP_ABORT_LISTENER_CEILING = 1024;
+const abortCeilingRaised = new WeakSet();
+
+function allowConcurrentAbortListeners(signal) {
+  if (abortCeilingRaised.has(signal)) return;
+  abortCeilingRaised.add(signal);
+  try {
+    setMaxListeners(MCP_ABORT_LISTENER_CEILING, signal);
+  } catch {
+    /* not an EventTarget (test doubles) */
+  }
+}
+
 /** Settle as soon as `signal` aborts. Promise.race keeps a later rejection of
  *  `promise` handled, so the abandoned call cannot surface as an unhandled
  *  rejection. */
-function raceMcpAbort(promise, signal, message) {
+export function raceMcpAbort(promise, signal, message) {
   if (!signal) return promise;
+  allowConcurrentAbortListeners(signal);
   if (signal.aborted) {
     void Promise.resolve(promise).catch(() => {});
     return Promise.reject(mcpAbortError(signal, message));
@@ -756,6 +777,11 @@ async function connectServer(
       closeServer: _closeServer,
     });
     if (!toolsResult || !Array.isArray(toolsResult.tools)) {
+      try {
+        await _closeServer({ client, transport });
+      } catch {
+        /* ignore */
+      }
       throw new Error(`[mcp-client] ListTools returned invalid shape for "${name}": missing or non-array tools field`);
     }
     if (genAtStart !== currentConnectAbortGeneration(scopeId)) {

package/src/runtime/agent/orchestrator/providers/admission-scheduler.mjs

@@ -493,7 +493,7 @@ function providerAdmissionKey(providerName, provider) {
     provider?.config?.apiKey ||
     // OAuth access tokens rotate. Prefer stable account identity above and
     // a stable refresh credential below so a refresh cannot open a second
-    // 64-wide lane while old-token requests are still running.
+    // admission lane while old-token requests are still running.
     provider?.tokens?.refresh_token ||
     provider?.credentials?.refreshToken ||
     provider?.tokens?.access_token ||

package/src/runtime/agent/orchestrator/providers/anthropic-api-transport.mjs

@@ -21,6 +21,7 @@ import {
 } from './retry-classifier.mjs';
 import { PROVIDER_FIRST_BYTE_TIMEOUT_MS, createTimeoutSignal } from '../stall-policy.mjs';
 import { noteFastModeCapacityError } from './anthropic-fast-mode.mjs';
+import { noteRequestServiceTier } from '../../../shared/llm/usage-context.mjs';
 import { notifyCurrentAnthropicRateLimit } from './admission-scheduler.mjs';
 
 /**
@@ -103,6 +104,7 @@ export function createAnthropicApiTransport({ client, label, opts, useModel, par
   const requestStreamingResponse = () =>
     withRetry(
       async ({ signal: attemptSignal }) => {
+        noteRequestServiceTier(params.speed);
         const res = await client.messages.create(params, requestOptions(attemptSignal)).asResponse();
         if (!res.ok) {
           const text = await res.text().catch(() => '');
@@ -156,7 +158,10 @@ export function createAnthropicApiTransport({ client, label, opts, useModel, par
 
   const requestNonStreamingMessage = (nonStreamingParams, signal) =>
     withRetry(
-      async ({ signal: attemptSignal }) => client.messages.create(nonStreamingParams, requestOptions(attemptSignal)),
+      async ({ signal: attemptSignal }) => {
+        noteRequestServiceTier(nonStreamingParams.speed);
+        return client.messages.create(nonStreamingParams, requestOptions(attemptSignal));
+      },
       {
         ...retryPolicy(signal, `${label} Anthropic non-streaming fallback`, `${label}-nonstreaming-request`),
         onRetry: ({ attempt, maxAttempts, lastErr, delayMs }) =>

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

@@ -1,47 +1 @@
-import { EFFORT_BETA_HEADER } from './anthropic-effort.mjs';
-
-const EXTENDED_CACHE_TTL_BETA_HEADER = 'extended-cache-ttl-2025-04-11';
-const INTERLEAVED_THINKING_BETA_HEADER = 'interleaved-thinking-2025-05-14';
-const FAST_MODE_BETA_HEADER = 'fast-mode-2026-02-01';
-const TOOL_SEARCH_BETA_HEADER = 'advanced-tool-use-2025-11-20';
-const THINKING_DISPLAY_UPDATES_BETA_HEADER = 'thinking-display-updates-2026-08-18';
-export const SERVER_SIDE_FALLBACK_BETA_HEADER = 'server-side-fallback-2026-07-01';
-
-// Fast mode ships on Opus 5.5, Opus 5 and Opus 4.8 only. Opus 4.7 rejects
-// `speed: "fast"` and Opus 4.6 silently runs at standard speed.
-export function supportsAnthropicFastMode(model) {
-  const id = String(model || '')
-    .toLowerCase()
-    .replace(/\./g, '-');
-  return /^claude-opus-(?:4-8|5)(?:$|[-@])/.test(id);
-}
-
-export function buildAnthropicBetaHeaders({
-  base = `${INTERLEAVED_THINKING_BETA_HEADER},${EXTENDED_CACHE_TTL_BETA_HEADER}`,
-  fastMode = false,
-  toolSearch = false,
-  effort = false,
-  serverFallback = false,
-  thinkingDisplayUpdates = false,
-} = {}) {
-  const headers = String(base || '')
-    .split(',')
-    .map((item) => item.trim())
-    .filter(Boolean);
-  if (fastMode && !headers.includes(FAST_MODE_BETA_HEADER)) {
-    headers.push(FAST_MODE_BETA_HEADER);
-  }
-  if (toolSearch && !headers.includes(TOOL_SEARCH_BETA_HEADER)) {
-    headers.push(TOOL_SEARCH_BETA_HEADER);
-  }
-  if (effort && !headers.includes(EFFORT_BETA_HEADER)) {
-    headers.push(EFFORT_BETA_HEADER);
-  }
-  if (serverFallback && !headers.includes(SERVER_SIDE_FALLBACK_BETA_HEADER)) {
-    headers.push(SERVER_SIDE_FALLBACK_BETA_HEADER);
-  }
-  if (thinkingDisplayUpdates && !headers.includes(THINKING_DISPLAY_UPDATES_BETA_HEADER)) {
-    headers.push(THINKING_DISPLAY_UPDATES_BETA_HEADER);
-  }
-  return headers.join(',');
-}
+export * from '../../../shared/llm/anthropic-betas.mjs';

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

@@ -1,383 +1 @@
-/**
- * Anthropic "effort" (extended-thinking budget) request parameter handling.
- */
-import {
-  assertAnthropicManualBudgetSupported,
-  emitsAnthropicProgressUpdates,
-  isAnthropicAdaptiveOnlyModel,
-} from './anthropic-thinking-contract.mjs';
-
-const EFFORT_LEVELS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
-const THINKING_DISPLAYS = new Set(['summarized', 'omitted', 'updates']);
-
-// Canonical display/transport ordering for effort levels. Used only to sort
-// whatever set the catalog actually advertises — NOT as an allowlist. The
-// catalog (capabilities.effort) is the source of truth for which levels a
-// model exposes; this array just keeps them in a stable low→max order.
-const EFFORT_LEVEL_ORDER = Object.freeze(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
-function _sortEffortLevels(levels) {
-  const rank = (l) => {
-    const i = EFFORT_LEVEL_ORDER.indexOf(l);
-    return i === -1 ? EFFORT_LEVEL_ORDER.length : i;
-  };
-  return [...levels].sort((a, b) => rank(a) - rank(b));
-}
-
-// Control flags that ride the capabilities.effort map alongside real levels
-// (`{supported:true, low:true, …}`). They are NOT selectable effort levels;
-// letting them through minted a bogus "supported" level that got persisted
-// into the on-disk catalog and offered in the UI.
-const CONTROL_EFFORT_KEYS = new Set(['supported', 'enabled', 'default']);
-
-// ── Catalog-first capability index ───────────────────────────────────────
-// The provider catalog already carries what each model advertises
-// (capabilities.effort → reasoningOptions:[{type:'effort',values:[…]}]), so it
-// — not a hardcoded regex ladder — is the source of truth for what we put on
-// the wire. anthropic-model-resolve feeds this whenever the in-memory catalog
-// moves. The regex ladder below stays as the fallback for ids the catalog does
-// not know (offline start, api-key provider, first run before /v1/models).
-const _catalogEffortLevels = new Map();
-
-function _catalogKeys(model) {
-  const id = normalizeModelId(model);
-  if (!id) return [];
-  // A dated id and its bare version alias describe the SAME model — index
-  // both so `claude-opus-5` and `claude-opus-5-20260101` resolve alike.
-  const undated = id.replace(/-\d{8}$/, '');
-  return undated !== id ? [id, undated] : [id];
-}
-
-/**
- * Replace the catalog-derived capability index. Records without a
- * `reasoningOptions` array are treated as UNKNOWN (skipped, so the regex
- * fallback still applies) rather than as "no effort" — offline/static fallback
- * lists carry no capability data and must not disable effort.
- */
-export function setModelEffortCapabilities(models) {
-  _catalogEffortLevels.clear();
-  if (!Array.isArray(models)) return;
-  for (const model of models) {
-    if (!model?.id || !Array.isArray(model.reasoningOptions)) continue;
-    const option = model.reasoningOptions.find(
-      (entry) =>
-        String(entry?.type || '')
-          .trim()
-          .toLowerCase() === 'effort'
-    );
-    const levels = new Set(
-      (Array.isArray(option?.values) ? option.values : [])
-        .map((value) =>
-          String(value || '')
-            .trim()
-            .toLowerCase()
-        )
-        .filter((value) => value && !CONTROL_EFFORT_KEYS.has(value))
-    );
-    for (const key of _catalogKeys(model.id)) {
-      const existing = _catalogEffortLevels.get(key);
-      // A bare alias shared by several records keeps the richer entry.
-      if (existing?.size && levels.size === 0) continue;
-      _catalogEffortLevels.set(key, levels);
-    }
-  }
-}
-
-/** Advertised levels for `model`, or null when the catalog has no record. */
-function _catalogLevels(model) {
-  for (const key of _catalogKeys(model)) {
-    const levels = _catalogEffortLevels.get(key);
-    if (levels) return levels;
-  }
-  return null;
-}
-
-export const EFFORT_BETA_HEADER = 'effort-2025-11-24';
-
-export const LEGACY_EFFORT_BUDGET = Object.freeze({
-  low: 1024,
-  medium: 4096,
-  high: 16384,
-  xhigh: 32768,
-  max: 32768,
-});
-const _LOGGED_EFFORT_NORMALIZATION = new Set();
-const _LOGGED_UNKNOWN_EFFORT = new Set();
-const MAX_LOGGED_UNKNOWN_EFFORTS = 100;
-
-function normalizeModelId(model) {
-  return String(model || '')
-    .toLowerCase()
-    .replace(/\./g, '-');
-}
-
-function parseClaudeVersion(model) {
-  const m = normalizeModelId(model);
-  const triple = m.match(/^claude-(haiku|sonnet|opus|fable)-(\d+)-(\d+)/);
-  if (triple) {
-    return { family: triple[1], major: Number(triple[2]), minor: Number(triple[3]) };
-  }
-  // Bare version ids carry family + major only (claude-opus-5). opus/haiku
-  // were missing here, so `claude-opus-5` parsed to null and fell through
-  // every capability check as an unknown shape.
-  const pair = m.match(/^claude-(sonnet|fable|opus|haiku)-(\d+)(?:$|[-@])/);
-  if (pair) {
-    return { family: pair[1], major: Number(pair[2]), minor: null };
-  }
-  // Legacy naming: version comes BEFORE the family (claude-3-7-sonnet,
-  // claude-3-5-sonnet, claude-3-opus). These are manual-thinking models —
-  // parse them so isLegacyAnthropicReasoningModel excludes them instead of
-  // letting modelSupportsEffort's `startsWith('claude-')` fallthrough grant
-  // them adaptive thinking + the effort beta (a hard 400).
-  const legacy = m.match(/^claude-(\d+)-(\d+)-(haiku|sonnet|opus)/);
-  if (legacy) {
-    return { family: legacy[3], major: Number(legacy[1]), minor: Number(legacy[2]) };
-  }
-  return null;
-}
-
-function isLegacyAnthropicReasoningModel(model) {
-  const parsed = parseClaudeVersion(model);
-  if (!parsed) return false;
-  if (parsed.family === 'haiku') return true;
-  if (parsed.family === 'fable') return false;
-  if (parsed.family === 'sonnet' || parsed.family === 'opus') {
-    if (parsed.major < 4) return true;
-    if (parsed.major === 4 && parsed.minor !== null && parsed.minor < 6) return true;
-    // Bare major, no minor (claude-opus-4 / claude-sonnet-4): adaptive
-    // effort only ships from 5 up, so 4.x aliases stay manual-thinking.
-    if (parsed.minor === null && parsed.major < 5) return true;
-    return false;
-  }
-  return false;
-}
-
-// @[MODEL LAUNCH]: extend allowlist when new Claude models ship with effort support.
-export function modelSupportsEffort(model) {
-  if (isEnvTruthy(process.env.MIXDOG_ANTHROPIC_ALWAYS_ENABLE_EFFORT)) return true;
-  const advertised = _catalogLevels(model);
-  if (advertised) return advertised.size > 0;
-  return _regexSupportsEffort(model);
-}
-
-// Fallback ladder for ids the catalog does not carry. Also used by
-// effortValuesForModel, which BUILDS the catalog records and therefore must
-// never consult the index it feeds.
-function _regexSupportsEffort(model) {
-  const m = normalizeModelId(model);
-  if (!m.includes('claude')) return false;
-  if (isLegacyAnthropicReasoningModel(model)) return false;
-  if (isAnthropicAdaptiveOnlyModel(model)) return true;
-  if (m.includes('opus-4-6') || m.includes('sonnet-4-6')) return true;
-  if (m.includes('sonnet-5') || m.includes('fable-5')) return true;
-  if (/^claude-mythos-5-1(?:-\d{8})?$/.test(m)) return true;
-  if (/^claude-opus-4-(6|7|8)(?:$|[-@])/.test(m)) return true;
-  if (/^claude-opus-5(?:$|[-@])/.test(m)) return true;
-  // Fallthrough for not-yet-enumerated modern models: only grant effort when
-  // parseClaudeVersion resolves a family with major>=4 (and not a manual-
-  // thinking legacy already excluded above). A bare `startsWith('claude-')`
-  // here would hand thinking:adaptive + the effort beta to legacy/unknown
-  // IDs (e.g. claude-3-7-sonnet) → hard 400. Unknown-shape IDs (no version
-  // parsed) fall through to false: no effort, no adaptive thinking.
-  const parsed = parseClaudeVersion(model);
-  if (
-    parsed &&
-    (parsed.family === 'sonnet' || parsed.family === 'opus' || parsed.family === 'fable') &&
-    parsed.major >= 4
-  ) {
-    return true;
-  }
-  return false;
-}
-
-// @[MODEL LAUNCH]: extend when new models support xhigh effort.
-// Per platform.claude.com/docs/en/build-with-claude/effort — xhigh is
-// supported by: Fable 5, Mythos 5, Opus 4.8, Opus 4.7, Sonnet 5.
-// NOT Opus 4.6 / Sonnet 4.6 (those support max but not xhigh).
-export function modelSupportsXhighEffort(model) {
-  const advertised = _catalogLevels(model);
-  if (advertised) return advertised.has('xhigh');
-  return _regexSupportsXhighEffort(model);
-}
-
-function _regexSupportsXhighEffort(model) {
-  const m = normalizeModelId(model);
-  if (/^claude-opus-4-(7|8)(?:$|[-@])/.test(m)) return true;
-  if (/^claude-opus-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-sonnet-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-fable-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-mythos-5(?:$|[-@])/.test(m)) return true;
-  if (/^claude-mythos-preview(?:$|[-@])/.test(m)) return true;
-  return false;
-}
-
-// @[MODEL LAUNCH]: extend when new Opus models support max effort.
-// Max list = xhigh list PLUS Opus 4.6, Sonnet 4.6, Opus 4.5.
-export function modelSupportsMaxEffort(model) {
-  const advertised = _catalogLevels(model);
-  // xhigh support implies max support (kept from the ladder below).
-  if (advertised) return advertised.has('max') || advertised.has('xhigh');
-  return _regexSupportsMaxEffort(model);
-}
-
-function _regexSupportsMaxEffort(model) {
-  if (_regexSupportsXhighEffort(model)) return true;
-  const m = normalizeModelId(model);
-  if (/^claude-opus-4-(5|6)(?:$|[-@])/.test(m)) return true;
-  if (/^claude-sonnet-4-6(?:$|[-@])/.test(m)) return true;
-  return false;
-}
-
-function isEnvTruthy(value) {
-  const s = String(value ?? '')
-    .trim()
-    .toLowerCase();
-  return s === '1' || s === 'true' || s === 'yes' || s === 'on';
-}
-
-function logOnce(key, write) {
-  if (_LOGGED_EFFORT_NORMALIZATION.has(key)) return;
-  _LOGGED_EFFORT_NORMALIZATION.add(key);
-  try {
-    write();
-  } catch {
-    /* ignore */
-  }
-}
-
-/**
- * Normalize user/config effort to API levels (low/medium/high/xhigh/max).
- * Accepts extra-high / very-high aliases as xhigh; clamps xhigh/max down to
- * high on models that don't support the top Opus tiers.
- */
-export function normalizeAnthropicEffortInput(raw, model, logTag = 'anthropic') {
-  if (raw === undefined || raw === null || raw === '') return undefined;
-  let level = String(raw).trim().toLowerCase();
-  if (level === 'extra-high' || level === 'very-high') level = 'xhigh';
-
-  if (level === 'xhigh' && !modelSupportsXhighEffort(model)) {
-    logOnce(`xhigh:high`, () => {
-      process.stderr.write(`[${logTag}] effort "xhigh" downgraded to "high" for model ${model}\n`);
-    });
-    return 'high';
-  }
-
-  if (level === 'max' && !modelSupportsMaxEffort(model)) {
-    logOnce(`max:high`, () => {
-      process.stderr.write(`[${logTag}] effort "max" downgraded to "high" for model ${model}\n`);
-    });
-    return 'high';
-  }
-
-  if (EFFORT_LEVELS.includes(level)) return level;
-  return undefined;
-}
-
-// The effort beta rides every request that sends output_config effort; an
-// explicit thinkingBudgetTokens takes the manual-budget path instead.
-export function shouldIncludeEffortBeta(model, opts = {}) {
-  const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
-  if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) return false;
-  return modelSupportsEffort(model);
-}
-
-/**
- * Apply effort / thinking to a Messages API body or SDK params object (mutates).
- */
-export function applyAnthropicEffortToBody(
-  body,
-  { model, opts = {}, maxTokens, clampThinkingBudgetTokens, logTag = 'anthropic', progressUpdates = false }
-) {
-  if (!body || typeof body !== 'object') return;
-
-  const thinkingBudgetTokens = Number(opts.thinkingBudgetTokens);
-  if (Number.isFinite(thinkingBudgetTokens) && thinkingBudgetTokens > 0) {
-    assertAnthropicManualBudgetSupported(model);
-    const budgetTokens = clampThinkingBudgetTokens(thinkingBudgetTokens, maxTokens);
-    if (budgetTokens) {
-      body.thinking = { type: 'enabled', budget_tokens: budgetTokens };
-    }
-    return;
-  }
-
-  const normalized = normalizeAnthropicEffortInput(opts.effort, model, logTag);
-
-  if (modelSupportsEffort(model)) {
-    if (normalized) {
-      const existing = body.output_config && typeof body.output_config === 'object' ? body.output_config : {};
-      body.output_config = { ...existing, effort: normalized };
-    }
-    // Adaptive-thinking models (4.6+) require `thinking:{type:"adaptive"}`
-    // rather than the legacy budget_tokens shape — sending
-    // `thinking:{type:"enabled"}` here 400s on sonnet-5/opus-4-7/4-8.
-    // Models that write tool preambles as progress-update thinking blocks
-    // default to `updates` (beta) where beta headers are allowed, so those
-    // notes arrive as text; every other model keeps the API default. The
-    // env var overrides either way (e.g. `omitted` turns preambles off).
-    const envDisplay = (process.env.MIXDOG_ANTHROPIC_THINKING_DISPLAY || '').trim();
-    let display = '';
-    if (THINKING_DISPLAYS.has(envDisplay)) display = envDisplay;
-    else if (progressUpdates && emitsAnthropicProgressUpdates(model)) display = 'updates';
-    body.thinking = display ? { type: 'adaptive', display } : { type: 'adaptive' };
-    // Adaptive/4.7+ models reject any non-default sampling param with a 400.
-    delete body.temperature;
-    delete body.top_p;
-    delete body.top_k;
-    return;
-  }
-
-  if (normalized && LEGACY_EFFORT_BUDGET[normalized]) {
-    // Contradictory/stale catalog data must not route an adaptive-only
-    // model back to a manual request that its backend rejects.
-    assertAnthropicManualBudgetSupported(model);
-    const budgetTokens = clampThinkingBudgetTokens(LEGACY_EFFORT_BUDGET[normalized], maxTokens);
-    if (budgetTokens) {
-      body.thinking = { type: 'enabled', budget_tokens: budgetTokens };
-    }
-    return;
-  }
-
-  const unknownEffort = String(opts.effort ?? '');
-  if (opts.effort && normalized === undefined && !_LOGGED_UNKNOWN_EFFORT.has(unknownEffort)) {
-    if (_LOGGED_UNKNOWN_EFFORT.size >= MAX_LOGGED_UNKNOWN_EFFORTS) {
-      _LOGGED_UNKNOWN_EFFORT.delete(_LOGGED_UNKNOWN_EFFORT.values().next().value);
-    }
-    _LOGGED_UNKNOWN_EFFORT.add(unknownEffort);
-    try {
-      process.stderr.write(
-        `[${logTag}] unknown effort=${opts.effort} ignored (known legacy: ${Object.keys(LEGACY_EFFORT_BUDGET).join(', ')})\n`
-      );
-    } catch {
-      /* ignore */
-    }
-  }
-}
-
-export function effortValuesForModel(capabilities, modelId) {
-  const effort = capabilities?.effort;
-  if (!effort) return [];
-  // Catalog-first: when capabilities.effort enumerates per-level support,
-  // that map is the source of truth — expose exactly the levels the model
-  // advertises (xhigh, max, or anything future), no hardcoded allowlist.
-  if (typeof effort === 'object') {
-    const advertised = Object.keys(effort).filter(
-      (level) =>
-        !CONTROL_EFFORT_KEYS.has(String(level).trim().toLowerCase()) &&
-        (effort[level] === true || effort[level]?.supported === true)
-    );
-    if (advertised.length) return _sortEffortLevels(advertised);
-    // Object with no per-level flags: fall through to the boolean/supported
-    // fallback below only when it explicitly marks blanket support.
-    if (effort.supported !== true) return [];
-  }
-  // Fallback (effort === true, or {supported:true} with no per-level map):
-  // the model supports effort but doesn't enumerate levels, so derive the
-  // set from the known level ladder, gated by the top-tier model check.
-  let levels = [...EFFORT_LEVELS];
-  if (!_regexSupportsMaxEffort(modelId)) {
-    levels = levels.filter((level) => level !== 'max');
-  }
-  if (!_regexSupportsXhighEffort(modelId)) {
-    levels = levels.filter((level) => level !== 'xhigh');
-  }
-  return levels;
-}
+export * from '../../../shared/llm/anthropic-effort.mjs';