claude-autorouter 0.3.2 → 0.3.4

package/docs/reference.md

@@ -166,12 +166,15 @@ The following policy applies after classification:
 
 - Jev's 1,500 ms deadline covers the response body and has no retry. Successful calls return immediately. Timeouts, HTTP errors, and invalid responses fall back to Sonnet or retain an existing stronger model.
 - Jev confidence below 0.75 prevents a downgrade below Sonnet or the requested tier. Ollama returns a tier without calibrated confidence; its failure handling and compatibility guards still apply.
-- Tool continuations retain the model chosen at the start of the human turn. Session, agent, and prompt headers identify turns; normalized conversation content provides a fallback. Moving prompt-cache markers does not create a new turn.
+- Tool continuations retain the model chosen at the start of the human turn. Session, agent, and prompt headers identify turns; normalized conversation content provides a fallback. Text feedback from a Stop hook also retains the model when it serves the same gateway prompt ID and the client has not changed its requested model, subject to capability and context checks. Moving prompt-cache markers does not create a new turn.
+- Claude's local `/goal` command can omit the prompt-ID header. For that path, an exact feedback label matching a preceding expanded `/goal` command keeps the original task and conversation anchor. This narrow text fallback also recognizes Claude's repeated-goal truncation format; arbitrary hook text is not treated as a goal. Feedback remains in the evaluator's recent conversation and the full API request. A new human message becomes the current task normally. The status line shows `prompt pinned` or `goal pinned` when either text-continuation rule applies.
 - Thinking history, fixed-budget thinking, server tools, context management, and other recognized model-specific features preserve the current model. Adaptive thinking, effort, and output above 64K prevent a Haiku choice. Fields are never stripped to force a downgrade.
 - Mid-conversation `system` messages preserve the requested model and pass through unchanged. They do not count as a tool continuation by themselves.
 - Recognized compaction and auxiliary requests otherwise preserve their requested model. Token counting and model discovery pass through without classification.
 
-The default `compatible` profile starts Claude with Haiku-compatible requests and client-requested thinking disabled. When an upgrade to Opus 5/5.5 requires adaptive thinking, AutoRouter enables it. `AUTOROUTER_CLIENT_PROFILE=native` preserves normal client settings, which can constrain routing. An explicit Claude `--model` argument overrides the starting model, but `/model` and `--model` are requested models, not locks on the routed result.
+The default `compatible` profile starts Claude with Haiku-compatible requests and client-requested thinking disabled. AutoRouter uses adaptive thinking when upgrading these requests to Opus 5/5.5. Starting with 0.3.3, routing to exact `claude-sonnet-5-5` translates disabled thinking to `between_tools`, which skips up-front thinking but permits progress updates between tool calls. At `xhigh`/`max` effort, or when per-message effort differs from the top-level setting (default `high`), it uses adaptive thinking while preserving the effort settings. Token counting uses the same adaptation. Sonnet 5 still accepts disabled thinking and is unchanged. See [Sonnet 5.5 thinking requirements](https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide).
+
+Explicit native `between_tools` and unknown thinking modes retain the incoming model on new human turns. Signed thinking blocks pass through unchanged and existing tool turns retain their model pin. `AUTOROUTER_CLIENT_PROFILE=native` preserves normal client settings, which can constrain routing. An explicit Claude `--model` argument overrides the starting model, but `/model` and `--model` are requested models, not locks on the routed result. Native same-model requests and unknown model aliases are not rewritten; clients must use settings supported by that model.
 
 The launcher enables `ENABLE_TOOL_SEARCH=true` when unset. Claude can otherwise disable on-demand MCP discovery when using a custom API address, loading connected-tool schemas into even a fresh conversation. Explicit values, including `false` or `auto:5`, are preserved. Managed settings and always-loaded tools can still affect deferral. See [Claude Code tool search](https://code.claude.com/docs/en/mcp#configure-tool-search).
 
@@ -231,6 +234,10 @@ The launcher is quiet by default. Standalone `serve` logs to stderr by default.
 
 **Claude says Haiku while AutoRouter says Opus:** the built-in model label is Claude's starting/requested model. The AutoRouter confirmed-model label comes from Anthropic. Claude's own token-cost estimate can likewise be attributed to the requested model.
 
+**`/goal` repeats a question or says it is blocked:** Claude Code runs its own completion checker after each turn, separately from AutoRouter's Jev/Ollama classifier. AutoRouter preserves the requested model for that auxiliary check and forwards its verdict unchanged. The check cannot authorize GitHub SAML, approve a tool, or resolve an external dependency. A tool's authentication error is also different from a Claude API authentication failure.
+
+If the worker reports a blocker but the checker keeps returning “not yet met,” Claude can repeat its answer until its no-progress guard pauses the goal. Repeated tool calls can keep the loop running longer. Use `/goal clear` to end the loop, resolve the external blocker, and set the goal again. For tasks that may require human action, explicitly allow reporting a blocker as an alternative end condition, for example: `/goal Verify the discrepancy against upstream main and run the relevant tests, or report an external authorization blocker and stop.` This changes what counts as completion; AutoRouter does not declare blocked work successful or rewrite goal instructions. See [Claude Code goal evaluation](https://code.claude.com/docs/en/goal#how-evaluation-works).
+
 **After restarting mid-conversation:** turn state is in memory and expires after 30 minutes. Unknown continuations preserve the incoming model. Start a fresh conversation when restarting around signed thinking; AutoRouter cannot reconstruct the prior actual model from lost turn state.
 
 Switching models can lose prompt-cache reuse. A cheaper price per token does not guarantee a cheaper or faster task. Only requests using Claude's configured base URL are visible to this proxy. Alternate provider modes such as Bedrock, Vertex, Foundry, Mantle, and `ANTHROPIC_AWS` are unsupported; unset their enable flags before launching. Use ordinary `claude` to bypass routing.

package/docs/releasing.md

@@ -6,6 +6,10 @@ Version `0.3.1` replaces the old Ollama chat evaluator and Qwen presets with the
 
 Version `0.3.2` fixes local timeout fallbacks with model-specific deadlines, removes Claude executor instructions from local evaluator excerpts, and keeps fallback causes visible in compact status lines. It also adds `AUTOROUTER_OLLAMA_TIMEOUT_MS=0` and `setup --ollama-timeout-ms 0` to disable the runtime evaluation deadline while preserving caller cancellation and the separate startup warmup limit. Existing explicit timeout settings still override the defaults; Jev is unchanged.
 
+Version `0.3.3` fixes HTTP 400 errors when a compatible request with disabled thinking is routed to Sonnet 5.5. Inference and token counting translate that setting to `between_tools`, or adaptive thinking when effort settings require it. Model defaults are unchanged; select Sonnet 5.5 with `AUTOROUTER_SONNET_MODEL=claude-sonnet-5-5`.
+
+Version `0.3.4` preserves the selected model across Stop-hook feedback for the same prompt, including `/goal` commands that omit the gateway prompt-ID header. Recognized goal feedback remains conversation context rather than replacing the human task in evaluator excerpts. Goal-checker verdicts remain unchanged; external authorization blockers can still cause Claude's own goal loop to repeat. See [goal troubleshooting](reference.md#troubleshooting).
+
 The GitHub repository is private. Publishing to npm makes the tarball's runtime source, README, configuration example, license, and shipped documentation public. Model weights, user configuration, credentials, transcripts, local artifacts, and test fixtures are excluded. Review the archive before the first publication and whenever the package allowlist changes.
 
 ## What runs automatically

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-autorouter",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "license": "Apache-2.0",
   "type": "module",
   "description": "A Claude Code model router with Jev and local Ollama System One evaluators",

package/src/model-request.mjs

@@ -1,13 +1,28 @@
-// These model IDs require adaptive thinking even when the client's source
-// model supports disabling it. Keep the adaptation explicit and narrow.
-const ALWAYS_ADAPTIVE = new Set(['claude-opus-5', 'claude-opus-5-5']);
+// 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']);
+
+function sonnetNeedsAdaptive(body) {
+  const effort = body.output_config?.effort ?? 'high';
+  // Sonnet 5.5's between_tools mode accepts high effort or below, and cannot
+  // change effort through per-message overrides. Preserve those overrides by
+  // selecting adaptive thinking instead of dropping or lowering the effort.
+  return ['xhigh', 'max'].includes(effort) || body.messages?.some(message =>
+    message.output_config?.effort !== undefined && message.output_config.effort !== effort);
+}
 
 export function prepareRequest(body, model) {
   const request = { ...body, model };
   const adjustments = [];
-  if (model !== body.model && ALWAYS_ADAPTIVE.has(model) && body.thinking?.type === 'disabled') {
-    request.thinking = { type: 'adaptive' };
-    adjustments.push('adaptive_thinking_required');
+  if (model !== body.model && body.thinking?.type === 'disabled') {
+    if (model === 'claude-sonnet-5-5') {
+      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)) {
+      request.thinking = { type: 'adaptive' };
+      adjustments.push('adaptive_thinking_required');
+    }
   }
   return { request, adjustments };
 }

package/src/prompt-state.mjs

@@ -76,12 +76,60 @@ function humanTask(message) {
   return contentText(message.content, true);
 }
 
+// Claude Code emits /goal Stop-hook feedback as user text. Recognize only its
+// observed wrapper and a condition established by an earlier expanded command;
+// ordinary messages mentioning hooks remain human tasks. This does not alter
+// message content, and the feedback remains available as classifier history.
+export function goalFeedbackIndexes(messages) {
+  const indexes = new Set();
+  if (!Array.isArray(messages)) return indexes;
+  let condition;
+  let shortCondition;
+  let sawFullFeedback = false;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message?.role !== 'user') continue;
+    const command = /^\s*<command-name>\/goal<\/command-name>\s*<command-message>goal<\/command-message>\s*<command-args>([\s\S]*?)<\/command-args>(?:\s|$)/.exec(humanTask(message));
+    if (command) {
+      const value = command[1].trim();
+      // /goal with no arguments is a status query, not a replacement goal.
+      if (!value) continue;
+      condition = value.length <= 4000 && !/^(?:clear|stop|off|reset|none|cancel)$/i.test(value) ? value : undefined;
+      shortCondition = undefined;
+      sawFullFeedback = false;
+      if (condition?.length > 500) {
+        let prefix = condition.slice(0, 500);
+        const last = prefix.charCodeAt(prefix.length - 1);
+        if (last >= 0xd800 && last <= 0xdbff) prefix = prefix.slice(0, -1);
+        shortCondition = `${prefix}… [+${condition.length - prefix.length} chars]`;
+      }
+      continue;
+    }
+    if (!condition || messages[index - 1]?.role !== 'assistant') continue;
+    const text = typeof message.content === 'string' ? message.content
+      : Array.isArray(message.content) && message.content.length === 1 && message.content[0]?.type === 'text'
+        && typeof message.content[0].text === 'string' ? message.content[0].text : undefined;
+    if (text === undefined) continue;
+    const matches = label => {
+      const prefix = `Stop hook feedback:\n[${label}]: `;
+      return text.startsWith(prefix) && Boolean(text.slice(prefix.length).trim());
+    };
+    if (matches(condition)) {
+      indexes.add(index);
+      sawFullFeedback = true;
+    } else if (sawFullFeedback && shortCondition && matches(shortCondition)) indexes.add(index);
+  }
+  return indexes;
+}
+
 export function buildState(body, limit = 12000) {
   const messages = body.messages ?? [];
+  const feedbackIndexes = goalFeedbackIndexes(messages);
   let firstTask = '';
   let currentTask = '';
   let currentIndex = -1;
   for (let index = 0; index < messages.length; index++) {
+    if (feedbackIndexes.has(index)) continue;
     const task = humanTask(messages[index]);
     if (!task.trim()) continue;
     if (!firstTask) firstTask = task;

package/src/router.mjs

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { TIERS } from './config.mjs';
-import { buildState } from './prompt-state.mjs';
+import { buildState, goalFeedbackIndexes } from './prompt-state.mjs';
 import { buildOllamaState, evaluateOllama } from './ollama-evaluator.mjs';
 export { buildState } from './prompt-state.mjs';
 
@@ -134,10 +134,11 @@ function turnContent(content) {
 
 function turnInfo(body, scope, promptId = '') {
   const messages = body.messages ?? [];
+  const feedback = goalFeedbackIndexes(messages);
   let index = -1;
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i];
-    if (message.role === 'user' && !(Array.isArray(message.content) && message.content.some(b => b.type === 'tool_result'))) {
+    if (message.role === 'user' && !feedback.has(i) && !(Array.isArray(message.content) && message.content.some(b => b.type === 'tool_result'))) {
       index = i; break;
     }
   }
@@ -147,6 +148,7 @@ function turnInfo(body, scope, promptId = '') {
     index,
     key: promptId ? hash(['prompt', scope, promptId]) : contentKey,
     contentKey,
+    goalFeedback: feedback.has(messages.length - 1),
     // Claude Code can append turn-scoped system instructions after the human
     // prompt. These do not start an assistant/tool continuation.
     continuation: index < 0 || messages.slice(index + 1).some(m => m.role !== 'system'),
@@ -226,7 +228,8 @@ export class Router {
     const c = this.config;
     const hasSystemMessage = body.messages.some(m => m.role === 'system');
     const unknownModel = rank(body.model) < 0 && !Object.values(c.models).includes(body.model);
-    const modelSpecificFeatures = body.thinking?.type === 'enabled' || body.context_management || body.speed || body.container || body.mcp_servers || body.tools?.some(t => t.type && t.type !== 'custom');
+    const modelSpecificThinking = body.thinking && !['disabled', 'adaptive'].includes(body.thinking.type);
+    const modelSpecificFeatures = modelSpecificThinking || body.context_management || body.speed || body.container || body.mcp_servers || body.tools?.some(t => t.type && t.type !== 'custom');
     const thinkingHistory = hasContentBlock(body, ['thinking', 'redacted_thinking']);
     const knownSourceModel = LARGE_CONTEXT_MODELS.has(body.model) || CAPACITY_UPGRADE_MODELS.has(body.model);
     const capacityLocked = hasSystemMessage || unknownModel || !knownSourceModel || modelSpecificFeatures || thinkingHistory;
@@ -247,11 +250,15 @@ export class Router {
     let model = c.models[decision.tier];
     let reason = decision.reason;
     const turn = turnInfo(body, scope, promptId);
-    let previous = this.turns.get(turn.key) ?? this.turns.get(turn.contentKey);
+    const promptPin = promptId ? this.turns.get(turn.key) : undefined;
+    const turnPin = promptPin ?? this.turns.get(turn.contentKey);
+    let previous = turnPin?.model;
+    const textTurn = !turn.continuation || turn.goalFeedback;
+    const textPin = promptPin ?? (!promptId && turn.goalFeedback ? turnPin : undefined);
     // A new human prompt can still carry signed thinking from the preceding
     // turn. Recover that turn's actual routed model when it is known.
     if (!turn.continuation && body.messages.length > 1 && !previous) {
-      previous = this.turns.get(turnInfo({ ...body, messages: body.messages.slice(0, turn.index) }, scope).key);
+      previous = this.turns.get(turnInfo({ ...body, messages: body.messages.slice(0, turn.index) }, scope).key)?.model;
     }
     let preserved = false;
     const preserve = (chosen, why) => { model = chosen; reason = why; preserved = true; };
@@ -268,7 +275,24 @@ export class Router {
     // clear_at, tool changes, and output_config) instead of down-routing.
     else if (hasSystemMessage) preserve(body.model, 'mid_conversation_system');
     else if (unknownModel) preserve(body.model, 'unknown_model');
-    else if (turn.continuation) keep(previous ? 'tool_turn_pinned' : 'unknown_continuation');
+    // A new native request can explicitly select a model-specific thinking
+    // mode, including between_tools. An earlier turn's model is not evidence
+    // that it accepts that mode. Existing tool turns retain their pin below.
+    else if (modelSpecificThinking && body.thinking.type !== 'enabled' && textTurn) preserve(body.model, 'model_specific_features');
+    // Stop hooks (including /goal) return feedback as user-role text, even
+    // though it still serves the same human prompt. Trust the scoped gateway
+    // identity instead of treating that text as a new task. A client model
+    // change can be an explicit fallback after a failure; do not undo it.
+    // Local /goal commands can omit the gateway prompt ID. Exact feedback for
+    // a known goal then uses the original conversation anchor as a fallback.
+    else if (textTurn && textPin?.requestedModel === body.model && !modelSpecificFeatures) {
+      const needsSonnet = body.thinking?.type === 'adaptive' || body.output_config?.effort || body.max_tokens > 64000;
+      if (needsSonnet && (textPin.model === c.models.haiku || rank(textPin.model) === 0)) {
+        preserve(c.models.sonnet, 'requires_sonnet_capabilities');
+      } else preserve(textPin.model, promptPin ? 'prompt_turn_pinned' : 'goal_turn_pinned');
+    }
+    else if (turn.goalFeedback && !turnPin) preserve(body.model, 'unknown_continuation');
+    else if (turn.continuation && !turn.goalFeedback) keep(previous ? 'tool_turn_pinned' : 'unknown_continuation');
     // Unknown or model-specific features are preserved, never silently removed.
     else if (decision.source === 'fallback' && rank(body.model) >= 1) keep('classifier_unavailable');
     else if (modelSpecificFeatures) keep('model_specific_features');
@@ -313,12 +337,13 @@ export class Router {
     }
     const identifiableUpgrade = capacityUpgraded && (turn.index >= 0 || promptId);
     if ((!turn.continuation || previous || identifiableUpgrade || reason === 'mid_conversation_system') && !['compaction', 'auxiliary'].includes(requestClass)) {
-      this.turns.set(turn.key, model);
+      const pin = { model, requestedModel: body.model };
+      this.turns.set(turn.key, pin);
       // Keep the content key too: later human turns carry signed thinking but
       // have a new prompt ID, so they must recover the preceding routed model.
       // Refresh this alias during known continuations too, since tool discovery
       // can change the content key without changing the gateway prompt ID.
-      if (turn.contentKey !== turn.key) this.turns.set(turn.contentKey, model);
+      if (turn.contentKey !== turn.key) this.turns.set(turn.contentKey, pin);
     }
     return { ...decision, ...contextCheck, model, reason, latency_ms: Math.round((performance.now() - start) * 100) / 100 };
   }

package/src/statusline.mjs

@@ -1,6 +1,7 @@
 const PHASES = new Set(['routing', 'connecting', 'streaming', 'ready', 'error', 'cancelled']);
 const REASONS = {
-  tool_turn_pinned: 'turn pinned', thinking_history: 'thinking pinned', unknown_continuation: 'continuation pinned',
+  tool_turn_pinned: 'turn pinned', prompt_turn_pinned: 'prompt pinned', goal_turn_pinned: 'goal pinned',
+  thinking_history: 'thinking pinned', unknown_continuation: 'continuation pinned',
   mid_conversation_system: 'system features', requires_sonnet_capabilities: 'capability guard',
   model_specific_features: 'model features', large_or_multimodal_request: 'large request',
   context_capacity: 'large context',

package/src/token-counter.mjs

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { prepareRequest } from './model-request.mjs';
 
 // Count-token API fields, including the beta fields used by Claude Code.
 // Keep unknown extensions out of the count path: dropping new input context
@@ -80,7 +81,10 @@ export function createTokenCounter(config, { fetchImpl = fetch } = {}) {
     let onAbort;
     const controller = new AbortController();
     try {
-      const payload = { ...Object.fromEntries(Object.entries(body).filter(([key]) => COUNT_FIELDS.has(key))), model };
+      // Apply the same target-model compatibility changes as inference before
+      // projecting count fields. Keep the source model available to the adapter.
+      const prepared = prepareRequest(body, model).request;
+      const payload = Object.fromEntries(Object.entries(prepared).filter(([key]) => COUNT_FIELDS.has(key)));
       const serialized = JSON.stringify(payload);
       const requestHeaders = new Headers(headers);
       requestHeaders.delete('content-length');