claude-autorouter 0.3.6 → 0.4.0

package/src/model-catalog.mjs

@@ -0,0 +1,96 @@
+// Exact Claude API IDs only. A name containing "sonnet" or "opus" is not
+// evidence that a gateway alias implements that model's request contract.
+export const MODEL_CATALOG_REVIEWED_AT = '2026-10-05';
+export const MODEL_CAPABILITY_SOURCES = Object.freeze({
+  thinking: 'https://platform.claude.com/docs/en/build-with-claude/thinking-troubleshooting',
+  effort: 'https://platform.claude.com/docs/en/build-with-claude/effort',
+  sonnet55: 'https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide',
+  opus55: 'https://platform.claude.com/docs/en/models/opus-5-5/whats-new-opus-5-5',
+  auto: 'https://code.claude.com/docs/en/permission-modes',
+  subscriptionContext: 'https://code.claude.com/docs/en/model-config',
+});
+
+/**
+ * @typedef {object} ModelCapabilities
+ * @property {'haiku'|'sonnet'|'opus'} family
+ * @property {number} maxOutputTokens Standard Messages API limit, not Batch beta.
+ * @property {number|undefined} contextWindow Unambiguous window across supported auth modes.
+ * @property {boolean} capacityUpgradeSource Existing small/opt-in-window models.
+ * @property {boolean} toolReferences
+ * @property {boolean} autoMode Claude client Auto eligibility, not arbitrary request compatibility.
+ * @property {boolean} sharedAuto Verified modern Auto execution pair.
+ * @property {readonly string[]} thinkingTypes
+ * @property {readonly string[]} effortLevels
+ * @property {boolean} forcedToolChoice
+ * @property {boolean} assistantPrefill
+ * @property {boolean} defaultSamplingOnly
+ * @property {boolean} midConversationSystem
+ * @property {boolean} perMessageEffort
+ * @property {boolean} taskBudget
+ * @property {'adaptive'|'between_tools'|undefined} [disabledThinkingAdaptation]
+ * @property {string} reviewedAt
+ * @property {string} source
+ */
+
+const BASIC_EFFORT = Object.freeze(['low', 'medium', 'high']);
+const FOUR_EFFORT = Object.freeze([...BASIC_EFFORT, 'max']);
+const FIVE_EFFORT = Object.freeze([...BASIC_EFFORT, 'xhigh', 'max']);
+const EXTENDED = Object.freeze(['disabled', 'enabled']);
+const BOTH = Object.freeze(['disabled', 'enabled', 'adaptive']);
+const ADAPTIVE = Object.freeze(['disabled', 'adaptive']);
+const registry = {};
+
+function add(ids, facts) {
+  const canonical = ids[0].replace(/^claude-/, '');
+  const entry = Object.freeze({
+    contextWindow: 200000, maxOutputTokens: 64000, capacityUpgradeSource: true,
+    toolReferences: true, autoMode: false, sharedAuto: false,
+    thinkingTypes: EXTENDED, effortLevels: Object.freeze([]),
+    forcedToolChoice: true, assistantPrefill: true, defaultSamplingOnly: false,
+    midConversationSystem: false, perMessageEffort: false, taskBudget: false,
+    reviewedAt: MODEL_CATALOG_REVIEWED_AT,
+    source: `https://platform.claude.com/docs/en/models/${canonical}/overview`,
+    ...facts,
+  });
+  for (const id of ids) registry[id] = entry;
+}
+
+add(['claude-haiku-4-5', 'claude-haiku-4-5-20251001'], { family: 'haiku' });
+add(['claude-sonnet-4-5', 'claude-sonnet-4-5-20250929'], { family: 'sonnet' });
+add(['claude-opus-4-5', 'claude-opus-4-5-20251101'], { family: 'opus', effortLevels: BASIC_EFFORT });
+// 4.6 has a 1M API window, but subscription usage can need a client opt-in.
+// Retain the existing conservative capacity policy instead of promising 1M.
+for (const family of ['sonnet', 'opus']) add([`claude-${family}-4-6`], {
+  family, contextWindow: undefined, maxOutputTokens: 128000, autoMode: true,
+  thinkingTypes: BOTH, effortLevels: FOUR_EFFORT, assistantPrefill: false,
+});
+for (const version of ['4-7', '4-8']) add([`claude-opus-${version}`], {
+  family: 'opus', contextWindow: 1000000, maxOutputTokens: 128000,
+  capacityUpgradeSource: false, autoMode: true, thinkingTypes: ADAPTIVE,
+  effortLevels: FIVE_EFFORT, assistantPrefill: false, defaultSamplingOnly: true,
+});
+for (const family of ['sonnet', 'opus']) for (const version of ['5', '5-5']) {
+  const latest = version === '5-5';
+  add([`claude-${family}-${version}`], {
+    family, contextWindow: 1000000, maxOutputTokens: 128000,
+    capacityUpgradeSource: false, autoMode: true, sharedAuto: true,
+    thinkingTypes: latest ? Object.freeze(family === 'sonnet' ? ['adaptive', 'between_tools'] : ['adaptive']) : ADAPTIVE,
+    effortLevels: FIVE_EFFORT, forcedToolChoice: !latest,
+    assistantPrefill: false, defaultSamplingOnly: true,
+    midConversationSystem: family === 'opus' || latest,
+    perMessageEffort: family === 'opus' || latest,
+    taskBudget: family === 'opus' || latest,
+    // Preserve the existing explicit adaptation for Opus 5 as well as 5.5.
+    disabledThinkingAdaptation: family === 'opus' ? 'adaptive' : latest ? 'between_tools' : undefined,
+  });
+}
+
+export const MODEL_CATALOG = Object.freeze(registry);
+/** @returns {Readonly<ModelCapabilities>|undefined} */
+export const modelCapabilities = model => typeof model === 'string' && Object.hasOwn(MODEL_CATALOG, model)
+  ? MODEL_CATALOG[model] : undefined;
+export const modelContextWindow = model => modelCapabilities(model)?.contextWindow;
+export const hasNativeMillionContext = model => modelContextWindow(model) === 1000000;
+export const canUpgradeContext = model => modelCapabilities(model)?.capacityUpgradeSource === true;
+export const supportsToolReferences = model => modelCapabilities(model)?.toolReferences === true;
+export const supportsAutoMode = model => modelCapabilities(model)?.autoMode === true;

package/src/model-request.mjs

@@ -1,6 +1,4 @@
-// Keep adaptations explicit: models in the same family can have different
-// thinking contracts. Preserve the existing adaptive Opus upgrade behavior.
-const ADAPTIVE_TARGETS = new Set(['claude-opus-5', 'claude-opus-5-5']);
+import { modelCapabilities } from './model-catalog.mjs';
 
 function sonnetNeedsAdaptive(body) {
   const effort = body.output_config?.effort ?? 'high';
@@ -14,12 +12,18 @@ function sonnetNeedsAdaptive(body) {
 export function prepareRequest(body, model) {
   const request = { ...body, model };
   const adjustments = [];
-  if (model !== body.model && body.thinking?.type === 'disabled') {
-    if (model === 'claude-sonnet-5-5') {
+  const adaptation = modelCapabilities(model)?.disabledThinkingAdaptation;
+  if (model !== body.model && body.model === 'claude-sonnet-5-5' && body.thinking?.type === 'between_tools'
+    && Object.keys(body.thinking).length === 1 && adaptation === 'adaptive') {
+    request.thinking = { type: 'adaptive' };
+    adjustments.push('adaptive_thinking_required');
+  }
+  if (model !== body.model && body.thinking?.type === 'disabled' && Object.keys(body.thinking).length === 1) {
+    if (adaptation === 'between_tools') {
       const type = sonnetNeedsAdaptive(body) ? 'adaptive' : 'between_tools';
       request.thinking = { type };
       adjustments.push(type === 'adaptive' ? 'adaptive_thinking_required' : 'between_tools_thinking_required');
-    } else if (ADAPTIVE_TARGETS.has(model)) {
+    } else if (adaptation === 'adaptive') {
       request.thinking = { type: 'adaptive' };
       adjustments.push('adaptive_thinking_required');
     }

package/src/ollama-evaluator.mjs

@@ -1,5 +1,6 @@
 import { validateOllamaEndpoint, validateOllamaModel } from './ollama-models.mjs';
 import { buildState } from './prompt-state.mjs';
+import { cancelResponseBody, readBoundedJson, MODEL_METADATA_LIMIT } from './bounded-json.mjs';
 
 // Bound UTF-8 bytes as well as serialized characters to keep local decision
 // excerpts small, including when the prompt contains non-ASCII text.
@@ -51,44 +52,20 @@ export function buildOllamaRequest(state, config) {
   return { model: config.ollamaModel, state, questions: OLLAMA_QUESTIONS, keep_alive: config.ollamaKeepAlive };
 }
 
-async function readJson(response, signal, limit = 64 * 1024) {
-  const reader = response.body?.getReader();
-  if (!reader) throw new Error('classifier_invalid_response');
-  let total = 0;
-  const chunks = [];
-  const abort = () => { void reader.cancel(signal.reason).catch(() => {}); };
-  signal.addEventListener('abort', abort, { once: true });
-  try {
-    while (true) {
-      signal.throwIfAborted();
-      const { value, done } = await reader.read();
-      if (done) break;
-      total += value.byteLength;
-      if (total > limit) throw new Error('classifier_invalid_response');
-      chunks.push(Buffer.from(value));
-    }
-    signal.throwIfAborted();
-    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-  } finally {
-    signal.removeEventListener('abort', abort);
-    await reader.cancel().catch(() => {}); reader.releaseLock();
-  }
-}
-
 async function request(config, path, body, { fetchImpl, signal, responseLimit }) {
   const response = await fetchImpl(`${config.ollamaEndpoint}${path}`, {
     method: 'POST', redirect: 'error', signal,
     headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
   });
   if (!response.ok) {
-    await response.body?.cancel();
+    cancelResponseBody(response);
     const needsVersion = path === '/v1/systemone' && response.status === 404;
     const error = new Error(needsVersion ? OLLAMA_VERSION_MESSAGE : 'classifier_http_error');
     if (needsVersion) error.code = 'OLLAMA_VERSION';
     error.classifierStatus = response.status;
     throw error;
   }
-  return readJson(response, signal, responseLimit);
+  return readBoundedJson(response, { signal, limit: responseLimit });
 }
 
 const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -120,13 +97,18 @@ export async function checkLocalOllamaModel(config, options) {
   validateOllamaModel(config.ollamaModel);
   // /show includes tensor metadata and licenses that can exceed 64 KiB. Keep
   // its separate limit bounded while decision responses stay at 64 KiB.
-  const model = await request(config, '/api/show', { model: config.ollamaModel }, { ...options, responseLimit: 1024 * 1024 });
+  const model = await request(config, '/api/show', { model: config.ollamaModel }, { ...options, responseLimit: MODEL_METADATA_LIMIT });
   if (!model || typeof model !== 'object' || model.remote_host || model.remote_model
     || typeof model.details?.parameter_size !== 'string' || !model.details.parameter_size) {
     throw new Error('classifier_invalid_response');
   }
 }
 
+/**
+ * @param {any} state
+ * @param {any} config
+ * @param {{fetchImpl?:typeof fetch,signal?:AbortSignal}} [options]
+ */
 export async function evaluateOllama(state, config, { fetchImpl = fetch, signal } = {}) {
   let combined = signal;
   if (config.ollamaTimeoutMs !== 0) {

package/src/onboarding.mjs

@@ -1,11 +1,10 @@
 import { execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { Writable } from 'node:stream';
 import { promisify } from 'node:util';
 import { CLIENT_PROFILES, readConfig, requireKeys, parseStopHookBlockCap, parseSessionLogDir } from './config.mjs';
 import { buildClaudeEnv, conflictingProviders, LOCAL_AUTH_HEADER } from './auth.mjs';
-import { getConfigPath, loadUserConfig, saveUserConfig } from './user-config.mjs';
+import { CONFIG_KEYS, SECRET_CONFIG_KEYS, loadUserConfig, saveUserConfig } from './user-config.mjs';
 import { DEFAULT_OLLAMA_MODEL, validateOllamaModel } from './ollama-models.mjs';
 import { inspectOllama, setupOllama } from './ollama-setup.mjs';
 
@@ -40,19 +39,29 @@ export async function askSecret(label, { input = process.stdin, output = process
 export async function setup(args, {
   env = process.env, write = console.log, prompt = askSecret, fetchImpl = fetch, signal,
 } = {}) {
-  let authMode = env.AUTOROUTER_AUTH_MODE ?? 'subscription';
-  let clientProfile = env.AUTOROUTER_CLIENT_PROFILE ?? 'compatible';
-  let evaluator = env.AUTOROUTER_EVALUATOR ?? 'jev';
+  if (signal?.aborted) throw new Error('Setup cancelled');
+  const loaded = loadUserConfig(env, { allowMissing: true });
+  const replace = args.includes('--replace');
+  const mergeExisting = loaded.exists && !replace;
+  // Updating one preference must not turn unrelated runtime overrides into
+  // saved defaults. First setup/replacement still supports environment-only
+  // configuration; an explicitly selected backend can use its supplied key.
+  const effectiveEnv = mergeExisting ? loaded.values : env;
+  let explicitEvaluator = false, explicitAuthMode = false;
+  let authMode = effectiveEnv.AUTOROUTER_AUTH_MODE ?? 'subscription';
+  let clientProfile = effectiveEnv.AUTOROUTER_CLIENT_PROFILE ?? 'compatible';
+  let evaluator = effectiveEnv.AUTOROUTER_EVALUATOR ?? 'jev';
   let model;
   let ollamaTimeoutMs;
-  let stopHookBlockCap = env.CLAUDE_CODE_STOP_HOOK_BLOCK_CAP;
-  let sessionLogDir = env.AUTOROUTER_SESSION_LOG_DIR;
+  let stopHookBlockCap = effectiveEnv.CLAUDE_CODE_STOP_HOOK_BLOCK_CAP;
+  let sessionLogDir = effectiveEnv.AUTOROUTER_SESSION_LOG_DIR;
+  let sessionLogMode = effectiveEnv.AUTOROUTER_SESSION_LOG_MODE;
   let pull = false;
-  let overwrite = false;
+  let overwrite = replace;
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--auth-mode') authMode = args[++i];
+    if (args[i] === '--auth-mode') { authMode = args[++i]; explicitAuthMode = true; }
     else if (args[i] === '--client-profile') clientProfile = args[++i];
-    else if (args[i] === '--evaluator') evaluator = args[++i];
+    else if (args[i] === '--evaluator') { evaluator = args[++i]; explicitEvaluator = true; }
     else if (args[i] === '--ollama-model') { model = args[++i]; if (model === undefined) throw new Error('--ollama-model requires a model tag'); }
     else if (args[i] === '--ollama-timeout-ms') {
       const value = args[++i];
@@ -69,9 +78,14 @@ export async function setup(args, {
       if (sessionLogDir === undefined || sessionLogDir.startsWith('--')) throw new Error('--session-log-dir requires a directory path');
       parseSessionLogDir(sessionLogDir, '--session-log-dir');
     }
+    else if (args[i] === '--session-log-mode') {
+      sessionLogMode = args[++i];
+      if (!['metadata', 'prompts'].includes(sessionLogMode)) throw new Error('--session-log-mode must be metadata or prompts');
+    }
     else if (args[i] === '--pull') pull = true;
     else if (args[i] === '--force') overwrite = true;
-    else throw new Error('Usage: claude-autorouter setup [--auth-mode subscription|api-key] [--client-profile compatible|native|auto] [--evaluator jev|ollama] [--ollama-model TAG] [--ollama-timeout-ms N] [--stop-hook-block-cap N] [--session-log-dir DIR] [--pull] [--force]');
+    else if (args[i] === '--replace') continue;
+    else throw new Error('Usage: claude-autorouter setup [--auth-mode subscription|api-key] [--client-profile compatible|native|auto] [--evaluator jev|ollama] [--ollama-model TAG] [--ollama-timeout-ms N] [--stop-hook-block-cap N] [--session-log-dir DIR] [--session-log-mode metadata|prompts] [--pull] [--force|--replace]');
   }
   if (!['subscription', 'api-key'].includes(authMode)) throw new Error('--auth-mode must be subscription or api-key');
   if (!CLIENT_PROFILES.includes(clientProfile)) throw new Error('--client-profile must be compatible, native or auto');
@@ -79,32 +93,47 @@ export async function setup(args, {
   if (evaluator !== 'ollama' && (model !== undefined || ollamaTimeoutMs !== undefined || pull)) throw new Error('Ollama model, deadline and download options require --evaluator ollama');
   if (stopHookBlockCap !== undefined) stopHookBlockCap = parseStopHookBlockCap(stopHookBlockCap);
   if (sessionLogDir !== undefined) sessionLogDir = parseSessionLogDir(sessionLogDir) ?? '';
-  const path = getConfigPath(env);
-  if (!overwrite && existsSync(path)) throw new Error('AutoRouter configuration already exists. Use setup --force to replace it.');
+  const path = loaded.path;
+  if (!overwrite && loaded.exists) throw new Error('AutoRouter configuration already exists. Use setup --force to update it while preserving unrelated settings.');
   write(evaluator === 'ollama'
     ? 'AutoRouter evaluates bounded prompt excerpts locally with Ollama. Complete requests still go to Anthropic.'
     : 'AutoRouter sends bounded prompt excerpts to TypeSafe Jev and complete requests to Anthropic.');
-  const values = { AUTOROUTER_AUTH_MODE: authMode, AUTOROUTER_CLIENT_PROFILE: clientProfile, AUTOROUTER_EVALUATOR: evaluator };
+  const values = replace ? {} : { ...loaded.values };
+  const selectedBackendKeys = explicitEvaluator ? CONFIG_KEYS.filter(key => evaluator === 'ollama'
+    ? key.startsWith('AUTOROUTER_OLLAMA_') : key.startsWith('AUTOROUTER_JEV_') || key === 'AUTOROUTER_MIN_CONFIDENCE') : [];
+  for (const key of mergeExisting ? selectedBackendKeys : CONFIG_KEYS) {
+    if (!SECRET_CONFIG_KEYS.includes(key) && env[key] !== undefined) values[key] = env[key];
+  }
+  Object.assign(values, { AUTOROUTER_AUTH_MODE: authMode, AUTOROUTER_CLIENT_PROFILE: clientProfile, AUTOROUTER_EVALUATOR: evaluator });
   if (stopHookBlockCap !== undefined) values.CLAUDE_CODE_STOP_HOOK_BLOCK_CAP = String(stopHookBlockCap);
   if (sessionLogDir !== undefined) values.AUTOROUTER_SESSION_LOG_DIR = sessionLogDir;
+  if (sessionLogMode !== undefined) values.AUTOROUTER_SESSION_LOG_MODE = sessionLogMode;
   if (evaluator === 'ollama') {
-    values.AUTOROUTER_OLLAMA_MODEL = validateOllamaModel(model ?? env.AUTOROUTER_OLLAMA_MODEL ?? DEFAULT_OLLAMA_MODEL);
+    values.AUTOROUTER_OLLAMA_MODEL = validateOllamaModel(model
+      ?? (explicitEvaluator ? env.AUTOROUTER_OLLAMA_MODEL : undefined) ?? effectiveEnv.AUTOROUTER_OLLAMA_MODEL ?? DEFAULT_OLLAMA_MODEL);
     for (const key of ['AUTOROUTER_OLLAMA_URL', 'AUTOROUTER_OLLAMA_TIMEOUT_MS', 'AUTOROUTER_OLLAMA_KEEP_ALIVE']) {
-      if (env[key] !== undefined) values[key] = env[key];
+      if ((!mergeExisting || explicitEvaluator) && env[key] !== undefined) values[key] = env[key];
     }
     if (ollamaTimeoutMs !== undefined) values.AUTOROUTER_OLLAMA_TIMEOUT_MS = ollamaTimeoutMs;
   }
   const keys = [...(evaluator === 'jev' ? ['TYPESAFE_API_KEY'] : []), ...(authMode === 'api-key' ? ['ANTHROPIC_API_KEY'] : [])];
+  // Reject invalid settings before inviting secret input or making local calls.
+  readConfig(values);
   for (const key of keys) {
-    const value = (env[key]?.trim() || await prompt(key)).trim();
+    if (signal?.aborted) throw new Error('Setup cancelled');
+    const explicitlySelected = !mergeExisting || (key === 'TYPESAFE_API_KEY' ? explicitEvaluator : explicitAuthMode);
+    const value = ((explicitlySelected ? env[key]?.trim() : '') || effectiveEnv[key]?.trim() || env[key]?.trim() || await prompt(key)).trim();
+    if (signal?.aborted) throw new Error('Setup cancelled');
     if (!value || /[\r\n\0]/.test(value)) throw new Error(`${key} must be a nonempty, single-line key`);
     values[key] = value;
   }
   const config = readConfig(values);
   requireKeys(config);
+  if (signal?.aborted) throw new Error('Setup cancelled');
   if (config.clientProfile === 'auto') write('Auto-compatible profile: Sonnet/Opus task routing. Claude controls permission-mode availability and safety checks.');
   if (config.stopHookBlockCap !== undefined) write(stopHookCapText(config.stopHookBlockCap));
-  if (config.sessionLogDir) write('Session decision logs enabled; files include up to 500 characters of user prompt text per decision.');
+  if (config.sessionLogDir) write(config.sessionLogMode === 'metadata' ? 'Session logs enabled with metadata only; prompt excerpts are omitted.'
+    : 'Session decision logs enabled; files include up to 500 characters of user prompt text per decision.');
   if (evaluator === 'ollama') {
     write(`Local evaluator: ${config.ollamaModel}; ${ollamaDeadlineText(config.ollamaTimeoutMs)}.`);
     const controller = new AbortController();
@@ -114,13 +143,37 @@ export async function setup(args, {
     finally { if (!signal) for (const name of ['SIGINT', 'SIGTERM']) process.removeListener(name, cancel); }
   }
   if (signal?.aborted) throw new Error('Setup cancelled');
-  saveUserConfig(values, { env, overwrite });
+  saveUserConfig(values, { env, overwrite, expectedRevision: loaded.revision });
   write(`Saved ${authMode} configuration to ${path}`);
   write(`${keys.length ? 'Keys and settings are' : 'Settings are'} stored locally in this file with owner-only permissions. Environment variables take precedence.`);
   write('Next: claude-autorouter doctor, then claude-autorouter claude from your project.');
 }
 
-export async function doctor({ env = process.env, write = console.log, run = execute, fetchImpl = fetch, signal } = {}) {
+export async function doctor({ env = process.env, write = console.log, run = execute, fetchImpl = fetch, signal,
+  evaluateLocal = false, json = false, diagnosticRunner } = {}) {
+  if (evaluateLocal) {
+    try {
+      const config = readConfig(loadUserConfig(env).env);
+      if (config.evaluator !== 'ollama') throw new Error('Local evaluation requires AUTOROUTER_EVALUATOR=ollama. It does not call Jev or Anthropic.');
+      const diagnostic = await import('./local-diagnostic.mjs');
+      const onProgress = json ? () => {} : progress => {
+        if (progress.event === 'preflight') write('Checking the local evaluator; no Claude authentication or cloud requests are used.');
+        else if (progress.event === 'startup') write('Preparing the local model with a separate 60-second startup deadline…');
+        else if (progress.event === 'case_start') write('Checking a synthetic routing case…');
+        else if (progress.event === 'case_complete') write('Synthetic routing case finished.');
+      };
+      const result = await (diagnosticRunner ?? diagnostic.runLocalDiagnostic)(config, { fetchImpl, signal, onProgress });
+      if (json) write(JSON.stringify(result));
+      else for (const line of diagnostic.formatLocalDiagnostic(result)) write(line);
+      return result.passed;
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      if (json) write(JSON.stringify({ schema_version: 1, type: 'local_evaluator_diagnostic', passed: false,
+        error: { code: 'configuration_error', message: error.message } }));
+      else write(`FAIL  ${error.message}`);
+      return false;
+    }
+  }
   let healthy = true;
   const report = (ok, message) => { if (!ok) healthy = false; write(`${ok ? 'OK' : 'FAIL'}  ${message}`); };
   report(Number(process.versions.node.split('.')[0]) >= 22, `Node.js ${process.versions.node} (requires 22+)`);
@@ -134,14 +187,19 @@ export async function doctor({ env = process.env, write = console.log, run = exe
     requireKeys(config);
     report(true, `Configuration and required keys present (${config.authMode})`);
   } catch (error) {
-    report(false, `${error.message}. Run claude-autorouter setup.`);
+    report(false, `${error.message}. Use claude-autorouter config show --check-all to inspect settings, or setup for first-time configuration.`);
   }
   for (const key of conflictingProviders(effectiveEnv)) {
     report(false, `Unset ${key}; AutoRouter uses the Anthropic Messages API`);
   }
   if (config?.stopHookBlockCap !== undefined) write(stopHookCapText(config.stopHookBlockCap));
+  if (config) {
+    write(`Routing profile: ${config.clientProfile}; Haiku ${config.models.haiku}; Sonnet ${config.models.sonnet}; Opus ${config.models.opus}.`);
+    if (config.evaluator === 'jev') write(`Evaluator: Jev ${config.jevModel}; routing deadline ${config.jevTimeoutMs} ms; confidence floor ${config.minConfidence}.`);
+  }
   if (config?.clientProfile === 'auto') write('Auto-compatible profile: Sonnet/Opus task routing. Claude controls permission-mode availability and safety checks.');
-  if (config?.sessionLogDir) write('Session decision logs enabled; files include up to 500 characters of user prompt text per decision.');
+  if (config?.sessionLogDir) write(config.sessionLogMode === 'metadata' ? 'Session logs enabled with metadata only; prompt excerpts are omitted.'
+    : 'Session decision logs enabled; files include up to 500 characters of user prompt text per decision.');
   if (config?.evaluator === 'ollama') {
     write(`Local evaluator: ${config.ollamaModel}; ${ollamaDeadlineText(config.ollamaTimeoutMs)}.`);
     write('Model availability is checked below; classification speed and accuracy are not tested.');
@@ -149,7 +207,7 @@ export async function doctor({ env = process.env, write = console.log, run = exe
       const result = await inspectOllama(config, { fetchImpl, signal });
       report(result.installed, result.installed
         ? `Local Ollama model available (${result.model})`
-        : `Ollama model missing (${result.model}). Run ollama pull ${result.model}, or setup --evaluator ollama --pull --force.`);
+        : `Ollama model missing (${result.model}). Run claude-autorouter setup --evaluator ollama --ollama-model ${result.model} --pull --force.`);
     } catch (error) {
       report(false, error.message);
     }
@@ -168,6 +226,7 @@ export async function doctor({ env = process.env, write = console.log, run = exe
     const { stdout } = await run('claude', ['--version'], { env: childEnv, timeout: 10000, maxBuffer: 64 * 1024 });
     const version = /\b\d+\.\d+\.\d+\b/.exec(stdout)?.[0];
     report(Boolean(version), version ? `Claude Code ${version}` : 'Could not recognize Claude Code version');
+    if (version) write(`Historical integration observations cover Claude Code 2.1.284 and 2.1.285; finding an executable does not certify its full compatibility${['2.1.284', '2.1.285'].includes(version) ? '.' : ' (installed version differs).'}`);
     claudeAvailable = Boolean(version);
   } catch {
     report(false, 'Claude Code unavailable. Install claude and ensure it is on PATH.');

package/src/request-validation.mjs

@@ -0,0 +1,54 @@
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const text = value => typeof value === 'string' && value.length > 0;
+const valid = Object.freeze({ valid: true });
+const invalid = field => ({ valid: false, error: `Invalid Messages API request shape: ${field}` });
+
+// Validate containers and scalar fields read by routing/excerpt extraction.
+// This intentionally is not the provider's full schema: unknown fields and
+// block/tool types remain untouched, and opaque inputs/schemas are not walked.
+export function validateRequestShape(body) {
+  if (!object(body) || !text(body.model) || !body.model.trim()) return invalid('model');
+  if (!Array.isArray(body.messages)) return invalid('messages');
+  const pending = [];
+  const content = (value, field, depth = 0) => {
+    if (typeof value === 'string') return true;
+    if (!Array.isArray(value)) return false;
+    pending.push({ blocks: value, field, depth });
+    return true;
+  };
+  if (body.system !== undefined && !content(body.system, 'system')) return invalid('system');
+  for (const message of body.messages) {
+    if (!object(message) || !['user', 'assistant', 'system'].includes(message.role)) return invalid('messages');
+    if (!content(message.content, 'message content')) return invalid('message content');
+    if (message.output_config !== undefined && message.output_config !== null && !object(message.output_config)) return invalid('message output_config');
+  }
+  if (body.tools !== undefined && (!Array.isArray(body.tools) || body.tools.some(tool =>
+    !object(tool) || (tool.type !== undefined && tool.type !== null && !text(tool.type))
+    || (tool.name !== undefined && typeof tool.name !== 'string')))) return invalid('tools');
+  for (const field of ['thinking', 'tool_choice', 'output_config', 'context_management']) {
+    // Context management is explicitly nullable in the beta Messages schema.
+    if (field === 'context_management' && body[field] === null) continue;
+    if (body[field] !== undefined && !object(body[field])) return invalid(field);
+  }
+  for (const field of ['thinking', 'tool_choice']) {
+    if (body[field] !== undefined && !text(body[field].type)) return invalid(field);
+  }
+  // The Messages API permits zero for cache population without generation.
+  // Reviewed 2026-10-05: https://platform.claude.com/docs/en/api/beta/messages/create
+  if (body.max_tokens !== undefined && (!Number.isSafeInteger(body.max_tokens) || body.max_tokens < 0)) return invalid('max_tokens');
+  if (body.stream !== undefined && typeof body.stream !== 'boolean') return invalid('stream');
+  while (pending.length) {
+    const { blocks, field, depth } = pending.pop();
+    // Excerpt extraction recursively reads tool results. Bound this known
+    // content nesting before it can exhaust the stack; never echo field data.
+    if (depth > 32) return invalid('content nesting');
+    for (const block of blocks) {
+      if (!object(block) || !text(block.type)) return invalid(field);
+      if (block.type === 'text' && typeof block.text !== 'string') return invalid('text content');
+      if (block.type === 'tool_use' && block.name !== undefined && typeof block.name !== 'string') return invalid('tool name');
+      if (block.type === 'tool_result' && block.content !== undefined
+        && !content(block.content, 'tool result content', depth + 1)) return invalid('tool result content');
+    }
+  }
+  return valid;
+}