mixdog 1.1.2 → 1.2.1

package/src/runtime/agent/orchestrator/mcp/lazy-output-validator.mjs

@@ -0,0 +1,25 @@
+// The MCP SDK Client compiles every tool's outputSchema with Ajv inside
+// listTools(), synchronously: a server listing ~180 tools held the daemon's
+// event loop for 1-2 s on every connect. This validator compiles each schema
+// on the tool's first structured result instead, and creates the SDK's Ajv
+// validator (same options and error text) on first use too.
+// A schema declaring an `$id` anywhere registers it in the client's Ajv, and a
+// schema referencing anything outside itself resolves against what is
+// registered by then (failing the listing when it is not); both still compile
+// when listed, in listing order, exactly as the SDK does.
+const LISTING_ORDER_SCHEMA = /"\$id"|"\$ref":"(?!#)/;
+
+export function createLazyOutputValidator(AjvJsonSchemaValidator) {
+  let provider = null;
+  const shared = () => (provider ??= new AjvJsonSchemaValidator());
+  return {
+    getValidator(schema) {
+      if (LISTING_ORDER_SCHEMA.test(JSON.stringify(schema))) return shared().getValidator(schema);
+      let validate = null;
+      return (input) => {
+        validate ??= shared().getValidator(schema);
+        return validate(input);
+      };
+    },
+  };
+}

package/src/runtime/agent/orchestrator/mcp/plugin-placeholders.mjs

@@ -0,0 +1,54 @@
+/**
+ * mcp/plugin-placeholders.mjs — plugin root/data placeholders in an MCP server
+ * config. Pure: no filesystem access; the caller supplies the directories.
+ */
+
+const ROOT_NAMES = ['CLAUDE_PLUGIN_ROOT', 'CODEX_PLUGIN_ROOT', 'PLUGIN_ROOT', 'MIXDOG_PLUGIN_ROOT'];
+const DATA_NAMES = ['CLAUDE_PLUGIN_DATA', 'PLUGIN_DATA', 'MIXDOG_PLUGIN_DATA'];
+const PLACEHOLDER_RE = new RegExp(`\\$\\{(${[...ROOT_NAMES, ...DATA_NAMES].join('|')})\\}`, 'g');
+const CONFIG_FIELDS = ['command', 'args', 'env', 'url', 'headers', 'cwd'];
+
+// Substituted paths use forward slashes on Windows so a path that lands in a
+// command line or argument is not read as backslash escapes; Windows accepts
+// them everywhere.
+function normalizePath(path, platform) {
+  return platform === 'win32' ? path.replace(/\\/g, '/') : path;
+}
+
+function substitute(value, replacements) {
+  if (typeof value === 'string') {
+    // Function replacement: `$` sequences in paths are inserted literally.
+    return value.replace(PLACEHOLDER_RE, (match, name) => replacements.get(name) ?? match);
+  }
+  if (Array.isArray(value)) return value.map((v) => substitute(v, replacements));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = substitute(v, replacements);
+    return out;
+  }
+  return value;
+}
+
+/**
+ * Returns a copy of `config` with plugin root/data placeholders replaced in
+ * command, args, env, url, headers and cwd. A placeholder whose directory is
+ * not supplied is left as written. Run before ordinary env expansion.
+ */
+export function resolvePluginPlaceholders(config, { root, data, platform = process.platform } = {}) {
+  const replacements = new Map();
+  if (root) for (const name of ROOT_NAMES) replacements.set(name, normalizePath(String(root), platform));
+  if (data) for (const name of DATA_NAMES) replacements.set(name, normalizePath(String(data), platform));
+  const out = { ...config };
+  for (const field of CONFIG_FIELDS) {
+    if (out[field] !== undefined) out[field] = substitute(out[field], replacements);
+  }
+  return out;
+}
+
+/** Environment variables a plugin-owned server process receives (raw paths). */
+export function pluginServerEnv({ root, data } = {}) {
+  const env = {};
+  if (root) for (const name of ['CLAUDE_PLUGIN_ROOT', 'MIXDOG_PLUGIN_ROOT', 'PLUGIN_ROOT']) env[name] = String(root);
+  if (data) for (const name of ['CLAUDE_PLUGIN_DATA', 'MIXDOG_PLUGIN_DATA', 'PLUGIN_DATA']) env[name] = String(data);
+  return env;
+}

package/src/runtime/agent/orchestrator/mcp/reconnect-singleflight.mjs

@@ -13,6 +13,10 @@ export function createKeyedSingleflight() {
       pending.set(lane, tracked);
       return tracked;
     },
+    /** The in-flight task promise for `key`, or undefined. */
+    wait(key) {
+      return pending.get(String(key || ''));
+    },
     has(key) {
       return pending.has(String(key || ''));
     },

package/src/runtime/agent/orchestrator/providers/account-pool.mjs

@@ -3,9 +3,11 @@ import {
   accountScopedSessionId,
   readProviderAccountPool,
   chooseProviderAccount,
-  changeProviderAccounts,
+  selectProviderAccountIf,
   blockProviderAccount,
   providerAccountExhausted,
+  providerAccountExhaustedForModelOnly,
+  providerAccountPolicy,
   providerAccountsResetAt,
 } from '../../../shared/provider-accounts.mjs';
 import { withProviderAccount, hasExplicitProviderAuthBinding } from '../../../shared/provider-auth-binding.mjs';
@@ -116,13 +118,82 @@ function boundAccountSend(providerName, row, messages, options) {
   return { opts, history, emitted: () => emitted };
 }
 
-// Commit only a successful fallback, without overwriting a newer selection.
-function commitFallbackAccount(providerName, pool, row) {
-  if (row.id === pool.selectedId) return;
-  const current = readProviderAccountPool(providerName);
-  if (current.selectedId === pool.selectedId && current.accounts.some((entry) => entry.id === row.id)) {
-    return changeProviderAccounts(providerName, { selectedId: row.id });
+// Commit only a successful fallback, without overwriting a newer selection:
+// the selection is compared under the write's lock, not before it. A fallback
+// forced by a model-scoped limit ("7D Fable" full, or a block attributed to
+// one family) serves this request only: the selected account still serves
+// every other model, so it stays the provider's account of record.
+async function commitFallbackAccount(providerName, pool, row, model, refusalScoped, policy) {
+  if (row.id === pool.selectedId || refusalScoped) return null;
+  if (accountExhaustedForModelOnly(providerName, pool.selectedId, model)) return null;
+  return selectProviderAccountIf(providerName, pool.selectedId, row.id, policy);
+}
+
+// The account each session runs on under the headroom policy. Every answer
+// records its provider and account in the assistant message's
+// `providerMetadata` (and in provider state when the adapter keeps one), so
+// the binding survives a restart and eviction from this map, which only
+// spares the history walk. Bounded, oldest binding first out.
+const SESSION_ACCOUNT_LIMIT = 1000;
+const ROUTING_METADATA_KEY = 'accountRouting';
+const sessionAccounts = new Map();
+
+// Forget every in-memory binding, as a restart does (tests).
+export function resetSessionAccountBindings() {
+  sessionAccounts.clear();
+}
+
+function rememberSessionAccount(key, id) {
+  sessionAccounts.delete(key);
+  sessionAccounts.set(key, id);
+  if (sessionAccounts.size > SESSION_ACCOUNT_LIMIT) sessionAccounts.delete(sessionAccounts.keys().next().value);
+}
+
+function accountExhaustedForModelOnly(providerName, id, model) {
+  const pool = readProviderAccountPool(providerName);
+  const row = pool.accounts.find((entry) => entry.id === id);
+  return (
+    Boolean(row) &&
+    providerAccountExhaustedForModelOnly(row, Date.now(), model, { useCredits: pool.useCredits === true })
+  );
+}
+
+// Only a binding recorded for THIS provider counts: a session that switched
+// providers carries another roster's account ids (every roster has a `default`).
+// The session's binding is read before the serving account, which differs
+// when a model-scoped limit lent this one answer to another account.
+function sessionAccountId(providerName, key, messages, options) {
+  if (key && sessionAccounts.has(key)) return sessionAccounts.get(key);
+  const state = options.providerState;
+  if (state?.providerAccountId && state.providerAccountProvider === providerName) {
+    return state.providerSessionAccountId || state.providerAccountId;
+  }
+  for (let index = (messages?.length || 0) - 1; index >= 0; index -= 1) {
+    const routing = messages[index]?.providerMetadata?.[ROUTING_METADATA_KEY];
+    if (routing?.accountId && routing.provider === providerName) return routing.sessionAccountId || routing.accountId;
+  }
+  return null;
+}
+
+// Stamp the serving account on the answer, independent of transport state,
+// with the account the session stays bound to (`bindingId`).
+function recordServingAccount(providerName, result, id, bindingId) {
+  if (!result || typeof result !== 'object') return;
+  if (result.providerReplay) result.providerReplay = { ...result.providerReplay, accountId: id };
+  if (result.providerState) {
+    result.providerState = {
+      ...result.providerState,
+      providerAccountId: id,
+      providerSessionAccountId: bindingId,
+      providerAccountProvider: providerName,
+    };
   }
+  const metadata =
+    result.providerMetadata && typeof result.providerMetadata === 'object' ? result.providerMetadata : {};
+  result.providerMetadata = {
+    ...metadata,
+    [ROUTING_METADATA_KEY]: { provider: providerName, accountId: id, sessionAccountId: bindingId },
+  };
 }
 
 // Whether the failed account's quota window is exhausted, plus the server's
@@ -158,12 +229,18 @@ function poolSend(providerName, account) {
     let lastError;
     let probed = false;
     const evidenced = new Set();
+    const sessionKey = options.sessionId ? `${providerName}:${options.sessionId}` : null;
+    const boundId = sessionAccountId(providerName, sessionKey, messages, options);
+    // Whether this send already left an account, and whether the latest quota
+    // refusal held only for this model's family.
+    let switched = false;
+    let refusalScoped = false;
     // Mark `error` only when every account in `ids` (default: the roster) is
     // exhausted with quota evidence: observed in this send, or a full window.
     const markExhausted = (error, ids) => {
       const pool = readProviderAccountPool(providerName);
-      // Auto switching off: the eligible set is the selected account alone.
-      const scope = ids || (pool.auto === false ? [pool.selectedId] : null);
+      // Manual policy: the eligible set is the selected account alone.
+      const scope = ids || (providerAccountPolicy(pool) === 'manual' ? [pool.selectedId] : null);
       const rows = scope ? pool.accounts.filter((entry) => scope.includes(entry.id)) : pool.accounts;
       const opts = { useCredits: pool.useCredits === true };
       const now = Date.now();
@@ -194,7 +271,8 @@ function poolSend(providerName, account) {
         }
         return account('default').send(messages, model, tools, options);
       }
-      const row = chooseProviderAccount(pool, attempted, Date.now(), model);
+      const policy = providerAccountPolicy(pool);
+      const row = chooseProviderAccount(pool, attempted, Date.now(), model, { sessionAccountId: boundId });
       if (!row) {
         // Once per send: a refusal built on a stale meter must not outlive the
         // meter. Re-measuring can only widen the roster, so it is tried before
@@ -209,9 +287,18 @@ function poolSend(providerName, account) {
       const bound = boundAccountSend(providerName, row, messages, options);
       try {
         const result = await account(row.id).send(bound.history, model, tools, bound.opts);
-        if (result?.providerReplay) result.providerReplay = { ...result.providerReplay, accountId: row.id };
-        if (result?.providerState) result.providerState = { ...result.providerState, providerAccountId: row.id };
-        if (commitFallbackAccount(providerName, pool, row)) {
+        // Headroom policy: a session's first pick, or its move off its account
+        // on a limit, becomes the selection; continuing on its account does
+        // not, so concurrent sessions never flip the selection back and forth.
+        // A move forced by a model-scoped limit serves this request only.
+        const leftBound = Boolean(boundId) && row.id !== boundId;
+        const scoped = switched
+          ? refusalScoped
+          : policy === 'headroom' && leftBound && accountExhaustedForModelOnly(providerName, boundId, model);
+        recordServingAccount(providerName, result, row.id, scoped && boundId ? boundId : row.id);
+        if (sessionKey && policy === 'headroom' && !scoped) rememberSessionAccount(sessionKey, row.id);
+        const commit = policy !== 'headroom' || !boundId || leftBound;
+        if (commit && (await commitFallbackAccount(providerName, pool, row, model, scoped, policy))) {
           // Publish only a committed selection, never a speculative retry or
           // one superseded by a manual switch. The existing progress channel
           // carries this across runtime shards to the attached UI.
@@ -230,7 +317,7 @@ function poolSend(providerName, account) {
         if (options.signal?.aborted) throw error;
         if (error?.reauthRequired === true) {
           if (
-            pool.auto === false ||
+            policy === 'manual' ||
             bound.emitted() ||
             error.unsafeToRetry ||
             error.liveTextEmitted ||
@@ -238,13 +325,15 @@ function poolSend(providerName, account) {
           )
             throw error;
           lastError = error;
+          switched = true;
+          refusalScoped = false;
           options.onStageChange?.('reconnecting', { message: 'Sign-in expired — switching to the next account' });
           continue;
         }
         const { exhausted, delay, evidence } = await accountQuotaExhausted(providerName, row, model, error, account);
         if (options.signal?.aborted || !exhausted) throw error;
         if (evidence) evidenced.add(row.id);
-        blockProviderAccount(
+        await blockProviderAccount(
           providerName,
           row.id,
           Date.now() + (delay > 0 ? delay : 5 * 60_000),
@@ -253,9 +342,11 @@ function poolSend(providerName, account) {
           { quota: evidence === true }
         );
         if (bound.emitted() || error.unsafeToRetry || error.liveTextEmitted || error.emittedToolCall) throw error;
-        // Auto switching off: the eligible set is the selected account alone.
-        if (pool.auto === false) throw markExhausted(error, [row.id]);
+        // Manual policy: the eligible set is the selected account alone.
+        if (policy === 'manual') throw markExhausted(error, [row.id]);
         lastError = error;
+        switched = true;
+        refusalScoped = accountExhaustedForModelOnly(providerName, row.id, model);
         options.onStageChange?.('reconnecting', { message: 'Quota exhausted — switching to the next account' });
       }
     }

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.296';
+export const DEFAULT_CLI_VERSION = '2.1.299';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

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

@@ -13,6 +13,7 @@ import { randomBytes } from 'node:crypto';
 import { updateJsonAtomicSync, writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+import { modelProxyClientMode, serverModelCredentialsDisabledError } from '../../../shared/model-proxy-mode.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { claudeCliUserAgent, resolveCliVersion } from './anthropic-oauth-client-version.mjs';
 import {
@@ -148,6 +149,7 @@ export function _credentialsMaxMtime() {
 }
 
 export function loadCredentials() {
+  if (modelProxyClientMode()) return null;
   const loaded = credentialCandidates().map(_loadCredentialsFile).filter(Boolean);
   if (!loaded.length) return null;
   loaded.sort((a, b) => (Number(b.expiresAt) || 0) - (Number(a.expiresAt) || 0));
@@ -382,6 +384,7 @@ async function _refreshOAuthCredentialsUnlocked(creds) {
 }
 
 export async function refreshOAuthCredentials(creds) {
+  if (modelProxyClientMode()) throw serverModelCredentialsDisabledError('Anthropic OAuth credentials');
   if (isAnthropicOAuthRefreshDisabled()) {
     throw new Error(
       'Anthropic OAuth refresh is disabled in this process; ' +

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

@@ -48,6 +48,7 @@ import { createAnthropicOAuthRecovery } from './anthropic-oauth-recovery.mjs';
 import { createMidState, createMidstreamRecovery } from './anthropic-oauth-midstream.mjs';
 import { assertAnthropicStreamNotEmpty } from './anthropic-midstream-recovery.mjs';
 import { applyAnthropicEffortToBody, shouldIncludeEffortBeta } from './anthropic-effort.mjs';
+import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-rejection.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import {
   applyAnthropicCacheMarkers,
@@ -408,6 +409,17 @@ export class AnthropicOAuthProvider {
   }
 
   async send(messages, model, tools, sendOpts) {
+    return withEffortRejectionFallback(
+      'anthropic-oauth',
+      model,
+      sendOpts || {},
+      undefined,
+      (opts) => this._sendOnce(messages, model, tools, opts),
+      { levels: ANTHROPIC_EFFORT_LEVELS }
+    );
+  }
+
+  async _sendOnce(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
@@ -625,7 +637,9 @@ export class AnthropicOAuthProvider {
     // without them (the request keeps its turn effort).
     if (isEffortConfigurationRejection(response.status, scrubbedText) && !opts._effortConfigurationRetry) {
       markEffortConfigurationUnsupported('anthropic-oauth', useModel);
-      process.stderr.write(`[anthropic-oauth] ${useModel} rejected the mid-conversation effort update; retrying once without it\n`);
+      process.stderr.write(
+        `[anthropic-oauth] ${useModel} rejected the mid-conversation effort update; retrying once without it\n`
+      );
       return this.send(messages, useModel, tools, {
         ...opts,
         effortConfigurationEnabled: false,

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

@@ -1,4 +1,4 @@
-import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
+import { reloadProviderApiKey, resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
 import { sanitizeToolPairs } from '../session/context-utils.mjs';
 import { AnthropicFallbackTriggeredError } from './retry-classifier.mjs';
 import { readStreamOutcome } from './lib/stream-outcome.mjs';
@@ -8,6 +8,7 @@ import { ANTHROPIC_MAX_MIDSTREAM_RETRIES, parseSSEStream } from './anthropic-sse
 import { buildAnthropicBetaHeaders } from './anthropic-betas.mjs';
 import { buildAnthropicApiRequest } from './anthropic-api-request.mjs';
 import { isCustomProviderName } from './custom-reasoning.mjs';
+import { ANTHROPIC_EFFORT_LEVELS, withEffortRejectionFallback } from './effort-rejection.mjs';
 import { armFirstByteWatchdog, createAnthropicApiTransport } from './anthropic-api-transport.mjs';
 import { createAnthropicApiRecovery } from './anthropic-api-recovery.mjs';
 import { buildAnthropicTurnResult } from './anthropic-turn-result.mjs';
@@ -41,9 +42,19 @@ export class AnthropicProvider {
   constructor(config) {
     this.config = config || {};
     this.name = this.config.name || 'anthropic';
-    this.apiKey = this.config.apiKey || (this.name === 'anthropic' ? process.env.ANTHROPIC_API_KEY : null);
+    this.apiKey = resolveProviderApiKey(this.name, this.config) || null;
     this.client = this._createClient(this.apiKey);
   }
+  // Client for the currently resolved key; rebuilt when the key changed since
+  // it was built (e.g. a keyless-constructed instance).
+  _currentClient() {
+    const key = resolveProviderApiKey(this.name, this.config) || null;
+    if (key && key !== this.apiKey) {
+      this.apiKey = key;
+      this.client = this._createClient(key);
+    }
+    return this.client;
+  }
   // Tool-search is a request capability, not an account capability. Keep it
   // off the client defaults and add it only on turns that actually serialize
   // defer_loading tools.
@@ -54,8 +65,10 @@ export class AnthropicProvider {
     const custom = isCustomProviderName(this.name);
     const keyless = custom && this.config.keyless === true;
     const betaHeaders = this.config.disableBetaHeaders || custom ? null : buildAnthropicBetaHeaders();
+    let credentials = { apiKey };
+    if (custom) credentials = { apiKey: keyless ? '' : apiKey || '', authToken: null };
     return new (loadAnthropic())({
-      ...(custom ? { apiKey: keyless ? '' : apiKey || '', authToken: null } : { apiKey }),
+      ...credentials,
       ...(this.config.baseURL ? { baseURL: this.config.baseURL } : {}),
       defaultHeaders: {
         ...(betaHeaders ? { 'anthropic-beta': betaHeaders } : {}),
@@ -67,10 +80,7 @@ export class AnthropicProvider {
   }
   reloadApiKey() {
     try {
-      const newKey =
-        getAgentApiKey(this.name) ||
-        this.config.apiKey ||
-        (this.name === 'anthropic' ? process.env.ANTHROPIC_API_KEY : null);
+      const newKey = reloadProviderApiKey(this.name, this.config);
       if (newKey) {
         this.config = { ...(this.config || {}), apiKey: newKey };
         this.apiKey = newKey;
@@ -106,10 +116,21 @@ export class AnthropicProvider {
       throw err;
     }
   }
+  // The `anthropic` API-key provider and every custom `anthropic`-protocol
+  // provider (a subclass of this one) share this send path.
   async _doSend(messages, model, tools, sendOpts) {
+    return withEffortRejectionFallback(
+      this.name,
+      model,
+      sendOpts || {},
+      this.config?.reasoningEffort,
+      (opts) => this._sendOnce(messages, model, tools, opts),
+      { levels: ANTHROPIC_EFFORT_LEVELS }
+    );
+  }
+  async _sendOnce(messages, model, tools, opts) {
     if (!model) throw new Error(`[${this.name}] model is required — pass it from the caller preset`);
     const useModel = model;
-    const opts = sendOpts || {};
     // Wire request (system/cache layout, tools, effort, fast mode, images)
     // and the per-request beta headers derived from that final body —
     // anthropic-api-request.mjs. Fast mode latches on the provider instance.
@@ -148,7 +169,7 @@ export class AnthropicProvider {
     // The SDK calls and their initial-response retry policy
     // (anthropic-api-transport.mjs).
     const transport = createAnthropicApiTransport({
-      client: this.client,
+      client: this._currentClient(),
       label: this.name,
       opts,
       useModel,
@@ -284,8 +305,7 @@ export class AnthropicProvider {
     }
   }
   async listModels() {
-    const apiKey =
-      this.apiKey || this.config?.apiKey || (this.name === 'anthropic' ? process.env.ANTHROPIC_API_KEY : null);
+    const apiKey = resolveProviderApiKey(this.name, this.config);
     if (!apiKey) return MODELS;
     try {
       const base = String(this.config?.baseURL || 'https://api.anthropic.com').replace(/\/+$/, '');
@@ -317,6 +337,6 @@ export class AnthropicProvider {
   async isAvailable() {
     // Availability probes must not spend tokens or depend on a live
     // network. Dispatch owns authentication validation and 401 reload.
-    return !!(this.apiKey || this.config?.apiKey || (this.name === 'anthropic' && process.env.ANTHROPIC_API_KEY));
+    return !!resolveProviderApiKey(this.name, this.config);
   }
 }

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

@@ -18,6 +18,7 @@ import { join, resolve } from 'node:path';
 import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
+import { modelProxyClientMode } from '../../../shared/model-proxy-mode.mjs';
 import {
   accountIdentityFields,
   normalizeExpiresAtMs as _normalizeExpiresAt,
@@ -192,6 +193,7 @@ function mtimeMs(path) {
 export { _normalizeExpiresAt };
 
 export function loadTokens() {
+  if (modelProxyClientMode()) return null;
   const path = getOwnTokenPath();
   if (!existsSync(path)) return null;
   try {

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

@@ -89,6 +89,15 @@ export function resolveAutoEffort({ base, options, probs }) {
   const ladder = autoEffortLadder(options);
   const at = ladder.indexOf(String(base ?? '').toLowerCase());
   if (at < 0) return null;
+  return resolveOnLadder(ladder, at, probs);
+}
+
+/** True when some judged outcome could apply: the base lies on the model's ladder. */
+export function autoEffortApplicable({ base, options }) {
+  return autoEffortLadder(options).includes(String(base ?? '').toLowerCase());
+}
+
+function resolveOnLadder(ladder, at, probs) {
   const { step, level, confidence } = judgedStep(probs);
   const effort = ladder[Math.max(0, Math.min(ladder.length - 1, at + step))];
   return { base: ladder[at], effort, step, level, confidence: Number(confidence.toFixed(3)) };