@aria-framework/ai 0.27.0 → 0.27.1

package/CHANGELOG.md

@@ -0,0 +1,103 @@
+# @aria-framework/ai changelog
+
+This file starts at 0.26.1. Earlier versions are described in the git history only.
+
+Each entry lists the **silent default changes** first: things that change what a caller's existing
+code sends, or what it is billed for, without the caller changing anything.
+
+## 0.27.1
+
+Fixes from an independent review of 0.26.1 and 0.27.0.
+
+### Silent default changes
+
+- **A failed call is recorded under the model that ran.** `budget.record(cfg, { usage, model, ms,
+  failed: true })` now receives the model the server named in its reply (`err.model`). It used to
+  receive `cfg.model`, which is empty on lmx, so every failed lmx call was ledgered with no model. The
+  configured model is used only when the reply named none. A usage table keyed on model will see
+  failed lmx calls move from `''` to the engine's model.
+- **Older Claude models: `'full'` never asks for more output than the model allows.** On the
+  pre-4.6 budget path, `max_tokens` was the caller's `maxTokens` plus a thinking budget of the same
+  size, about twice what was asked. That could pass the model's output limit (Haiku 4.5, Sonnet 4.5,
+  Opus 4.5, Sonnet 4 and 3.7 Sonnet allow 64000; Opus 4.1 and Opus 4 allow 32000), and the API
+  refused it. It is now capped at the limit. Near the limit the thinking budget shrinks first, down
+  to the API's minimum of 1024. For example, `maxTokens: 40000` on Haiku 4.5 sends
+  `max_tokens: 64000` with a 24000 budget. When `maxTokens` plus the budget is below the limit,
+  nothing changes.
+- **Claude 3 models without extended thinking get no thinking.** On `'full'`, Claude 3.5 Haiku,
+  3 Haiku, 3 Opus and 3.5 Sonnet were sent `thinking: enabled`, which they reject with a 400. They now
+  keep the pre-0.27 request, and `'full'` logs a warning instead of failing the call, as it does
+  for a model the table does not know. 3.7 Sonnet still thinks.
+- **Opus 4 and Sonnet 4 under their `-0` aliases and dated ids** (`claude-opus-4-0`,
+  `claude-opus-4-20250514`, `claude-sonnet-4-0`, `claude-sonnet-4-20250514`) are now recognised.
+  0.27.0 treated them as unknown: `'full'` sent no thinking and logged a warning. They now get the
+  budget like the other pre-4.6 models.
+
+### Fixes
+
+- If a budget's `record` throws `null` (or anything without a `message`), logging it no longer
+  throws a `TypeError` that replaces the caller's real error.
+- `AiError` takes an optional `model`, set by both adapters on every error that carries `usage`.
+  On lmx, when the reply names no model, it is the model the engine reports running; the same
+  fallback now applies to a successful result's `model`.
+- **Anthropic: a `maxTokens` that is not a positive number is refused** (`AiError` kind `refused`,
+  before any request) on every Anthropic call. A fraction is rounded down. Before this, a
+  string `"2048"` on the budget path became `max_tokens: 64000`, and a negative value sent a
+  `budget_tokens` above `max_tokens`. `0`, `NaN` and a missing value still take the 1024 default.
+
+### Tests
+
+- `test/anthropicRequests.js` (new) compares the request bodies with a fixture typed by hand from
+  the Messages API rules for 26 model ids, rather than with values read back from
+  `ANTHROPIC_FAMILIES`. It also checks the budget at 1024, 4096, 40000 and at each model's limit.
+- `test/usageOnFailure.js` adds an lmx failure with an empty `cfg.model`, an Anthropic failure whose
+  reply names a different model, an empty completion with zero usage on both adapters, and a budget
+  that throws `null`.
+
+## 0.27.0
+
+`complete({ reasoning: 'off' | 'full' })` is honoured by every provider. Before this, only lmx
+honoured it. Leaving it out means `'off'`.
+
+### Silent default changes
+
+These apply to callers that do not pass `reasoning`. To keep a model thinking, pass
+`reasoning: 'full'`.
+
+- **openai-compatible and lmstudio, qwen or gpt-oss models: a body flag is now sent on every call.**
+  qwen gets `chat_template_kwargs: { enable_thinking: false }` and gpt-oss gets
+  `reasoning_effort: 'low'`. Before this, these models used the server's default, which usually means
+  thinking on every call.
+- **LM Studio (`provider: 'lmstudio'`), qwen models: `/no_think` is appended to the system prompt**
+  (or sent as the system prompt when there is none), and `reasoning_effort: 'none'` is added to the
+  body. LM Studio ignores `chat_template_kwargs`. A caller that compares or caches system prompts will
+  see the extra line. An LM Studio server configured as `openai-compatible` gets neither, and keeps
+  thinking.
+- **Claude Opus 5.5 and Fable (and Mythos) get `output_config.effort: 'low'`.** These models cannot
+  turn thinking off, and Opus 5.5's own default effort is `medium`, so leaving `reasoning` out now
+  means less thinking than before.
+- **Other Claude generations:** Opus 5 gets effort `'low'` (its own default is adaptive thinking at
+  `high`). Sonnet 5.5 gets `thinking: { type: 'between_tools' }` and Sonnet 5 gets
+  `thinking: { type: 'disabled' }`; before this, both thought by default. 4.6 and older are
+  unchanged unless `'full'` is passed.
+- **`temperature` is no longer sent to Claude models that reject it** (Opus 4.7 and later, Sonnet 5
+  and later, Fable). Before this, those requests failed with a 400. It is also left out with `'full'`
+  on the pre-4.6 budget path, where extended thinking requires the default.
+- The client no longer strips `reasoning` with a warning saying only lmx honours it.
+
+## 0.26.1
+
+### Silent default changes
+
+- **A failed call that spent tokens is recorded through `budget.record`.** When the model answered
+  but the answer was unusable (it thought until the limit, or a structured reply was cut off),
+  `budget.record(cfg, { usage, model, ms, failed: true }, meta)` is called before the error is
+  thrown. A failure that spent nothing (refused, unreachable, timed out, or a zero usage total)
+  records nothing. **A caller that metered `err.usage` itself must stop, or the call is counted
+  twice.** A `record` that throws is logged and never replaces the original error.
+
+### Fixes
+
+- Both adapters put normalised usage (`{ prompt, completion, total }`) on every error raised after
+  the reply was read.
+- A 200 whose JSON body is `null` is an `AiError` of kind `bad_response`. It used to be a `TypeError`.

package/README.md

@@ -48,7 +48,10 @@ an admin screen and never includes a URL or key.
 was unusable (it thought until the limit, or a structured reply was cut off), the error carries
 `usage` (`{ prompt, completion, total }`) and `budget.record(cfg, { usage, model, ms, failed: true }, meta)`
 is called before the error is thrown. A failure that spent nothing (refused, unreachable, timeout)
-records nothing. If `record` throws, the original error still reaches the caller.
+records nothing. If `record` throws, the original error still reaches the caller. The error also
+carries `model`, the model the server says answered, and `record` receives that (0.27.1); it falls
+back to the configured model only when the reply named none. On lmx the configured model is empty.
+A caller that metered `err.usage` itself before 0.26.1 must stop, or the call is counted twice.
 
 `providerStore`, `usageStore`, `speedStore` and `lmxStore` are optional db-worker-backed
 stores. Each exports a `schemaFor(dialect)`, so the app's migration can be checked against it.
@@ -236,11 +239,21 @@ and Fable cannot turn thinking off (effort is the only lever), Sonnet 5.5 turns
 | claude-sonnet-5 | `{"thinking":{"type":"disabled"}}` | `{"thinking":{"type":"adaptive"},"output_config":{"effort":"high"}}` | not sent |
 | claude-opus-4-7 / 4-8 | nothing | `{"thinking":{"type":"adaptive"},"output_config":{"effort":"high"}}` | not sent |
 | claude-*-4-6 | nothing | `{"thinking":{"type":"adaptive"},"output_config":{"effort":"high"}}` | sent |
-| claude-*-4-5 and older | nothing | thinking enabled with a budget of `maxTokens` (at least 1024), added on top of `max_tokens` | sent; not sent with `'full'` |
+| claude-*-4-5 | nothing | thinking enabled with a budget of `maxTokens` (at least 1024), added on top of `max_tokens`, which never exceeds 64000 | sent; not sent with `'full'` |
+| claude-opus-4-1 / claude-opus-4 | nothing | thinking enabled with a budget of `maxTokens` (at least 1024), added on top of `max_tokens`, which never exceeds 32000 | sent; not sent with `'full'` |
+| claude-sonnet-4 | nothing | thinking enabled with a budget of `maxTokens` (at least 1024), added on top of `max_tokens`, which never exceeds 64000 | sent; not sent with `'full'` |
+| claude-3-7-sonnet | nothing | thinking enabled with a budget of `maxTokens` (at least 1024), added on top of `max_tokens`, which never exceeds 64000 | sent; not sent with `'full'` |
+| claude-3 without extended thinking | nothing | nothing (a warning that `'full'` could not be honoured) | sent |
 | anything else | nothing | nothing (a warning that `'full'` could not be honoured) | sent |
 
 `effort` is merged into any `output_config` the structured-output schema already put there.
 
+On the budget rows `max_tokens` counts the thinking as well as the answer, so it is capped at the
+model's output limit (0.27.1). Near the limit the thinking budget shrinks first, down to the API's
+minimum of 1024, and only then the answer's room: `maxTokens: 40000` on Haiku 4.5 sends
+`max_tokens: 64000` with a 24000 budget. Claude 3 models other than 3.7 Sonnet have no extended
+thinking, so `'full'` sends nothing to them and logs a warning; it does not fail the call.
+
 Rules:
 
 - The values are `'off'` and `'full'`. Leaving the option out (or `null`) means `'off'`. Any other

package/error.js

@@ -18,7 +18,7 @@ class AiError extends Error {
   /**
    * @param {AiErrorKind} kind
    * @param {string} message  written for the admin screen, not the log
-   * @param {{cause?: Error, status?: number, usage?: object}} [opts]
+   * @param {{cause?: Error, status?: number, usage?: object, model?: string}} [opts]
    */
   constructor(kind, message, opts = {}) {
     super(message);
@@ -30,6 +30,10 @@ class AiError extends Error {
     // measuring throughput should not have to treat that as zero work. Optional everywhere: most
     // failures happen before a single token is spent.
     if (opts.usage) this.usage = opts.usage;
+    // ...AND WHICH MODEL SPENT IT (0.27.1), as the server named it in its reply. The client meters a
+    // failed call under this, not cfg.model: on lmx cfg.model is empty (the engine decides what
+    // runs), and an alias on any provider resolves to an id other than the one configured.
+    if (opts.model) this.model = opts.model;
     if (opts.cause) this.cause = opts.cause;
   }
 

package/index.js

@@ -145,12 +145,16 @@ function createAiClient(deps = {}) {
       // connection test on such a model run outside the ceiling. Adapters put normalised usage on
       // the error; a failure that spent nothing (refused, unreachable) carries none and is not counted.
       // The ledger failing must never replace the error the caller needs to see.
+      // THE MODEL THAT RAN (0.27.1), as the adapter read it off the reply — cfg.model only when the
+      // reply named none. On lmx cfg.model is '' and every failed call was ledgered under no model.
       if (err && err.usage && err.usage.total > 0) {
         try {
-          await meter.record(cfg, { usage: err.usage, model: cfg.model, ms: Date.now() - started, failed: true },
+          await meter.record(cfg,
+            { usage: err.usage, model: err.model || cfg.model, ms: Date.now() - started, failed: true },
             { ticketId: opts.ticketId });
         } catch (recErr) {
-          log.warn(`AI: usage of a failed call not recorded (${recErr.message})`);
+          // A budget may throw anything, null included; logging it must not throw in its turn.
+          log.warn(`AI: usage of a failed call not recorded (${String(recErr?.message ?? recErr)})`);
         }
       }
       throw err;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aria-framework/ai",
   "description": "Aria App Framework — AI module. A dependency-injected model seam (createAiClient) over several providers (LM Studio / OpenAI-compatible / Anthropic), with a fact-preservation guard, generic Polish and Generate writing engines, and a browser polish widget. Prompts and config stay in the consuming app.",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "license": "UNLICENSED",
   "private": false,
   "publishConfig": {
@@ -9,6 +9,7 @@
   },
   "main": "index.js",
   "files": [
+    "CHANGELOG.md",
     "benchmark.js",
     "browser/ai-jobs.js",
     "browser/ai-panels.js",
@@ -48,7 +49,7 @@
     }
   },
   "scripts": {
-    "test": "node test/smoke.js && node test/usageStore.js && node test/providerStore.js && node test/speedStore.js && node test/health.js && node test/listModels.js && node test/benchmark.js && node test/lmxDiscovery.js && node test/lmx.js && node test/lmxVerify.js && node test/lmxStore.js && node test/lmxStatus.js && node test/jobCard.js && node test/untrusted.js && node test/packaging.js && node test/views.js && node test/fenced.js && node test/polish.js && node test/reasoning.js && node test/reasoningProviders.js && node test/usageOnFailure.js",
+    "test": "node test/smoke.js && node test/usageStore.js && node test/providerStore.js && node test/speedStore.js && node test/health.js && node test/listModels.js && node test/benchmark.js && node test/lmxDiscovery.js && node test/lmx.js && node test/lmxVerify.js && node test/lmxStore.js && node test/lmxStatus.js && node test/jobCard.js && node test/untrusted.js && node test/packaging.js && node test/views.js && node test/fenced.js && node test/polish.js && node test/reasoning.js && node test/reasoningProviders.js && node test/anthropicRequests.js && node test/usageOnFailure.js",
     "prepublishOnly": "node ../../test/packaging.js ai"
   },
   "devDependencies": {

package/providers/anthropic.js

@@ -72,6 +72,12 @@ async function complete(cfg, opts) {
     // requires the default. Sending it would be a 400, so it is left out.
     if (!r.sendTemperature) delete body.temperature;
     body.max_tokens = r.maxTokens;
+    // A MODEL WITH NO EXTENDED THINKING (0.27.1): nothing is sent, and 'full' is said to be
+    // unhonoured — a warning, as for an unknown model, never an error.
+    if (r.cannotThink && cfg.logger) {
+      cfg.logger.warn(`${label}: reasoning 'full' was asked for, but model "${cfg.model}" has no extended `
+        + 'thinking — sending no thinking setting; the model answers without it.');
+    }
   } else if (opts.reasoning === 'full' && cfg.logger) {
     cfg.logger.warn(`${label}: reasoning 'full' was asked for, but model "${cfg.model}" is not in the `
       + 'known Claude generations — sending no thinking setting; the model runs on its own default.');
@@ -133,7 +139,7 @@ async function complete(cfg, opts) {
     const thought = (payload.content || []).some((b) => b && b.type === 'thinking');
     throw new AiError('bad_response', thought
       ? `${label} returned only its internal reasoning. Raise the reply limit and try again.`
-      : `${label} returned no text (stop reason: ${payload.stop_reason || 'none given'}).`, { usage });
+      : `${label} returned no text (stop reason: ${payload.stop_reason || 'none given'}).`, { usage, model: payload.model });
   }
 
   let json = null;
@@ -145,10 +151,10 @@ async function complete(cfg, opts) {
       if (payload.stop_reason === 'max_tokens') {
         throw new AiError('bad_response',
           `${label} ran out of room mid-answer — the structured reply was cut off before it was ` +
-          'finished. A Regenerate usually succeeds.', { cause: err, usage });
+          'finished. A Regenerate usually succeeds.', { cause: err, usage, model: payload.model });
       }
       throw new AiError('bad_response',
-        `${label} was asked for structured output and returned text that will not parse.`, { cause: err, usage });
+        `${label} was asked for structured output and returned text that will not parse.`, { cause: err, usage, model: payload.model });
     }
   }
 

package/providers/openai-compatible.js

@@ -164,6 +164,10 @@ async function complete(cfg, opts) {
     throw new AiError('bad_response', `${label} answered with an empty body.`);
   }
 
+  // THE MODEL THAT RAN (0.27.1): what the reply names, else — on lmx — the model the engine reports
+  // running (`reasoningModel`). Carried on errors for metering and on the result.
+  const ranModel = payload.model || cfg.reasoningModel;
+
   if (payload.error && !payload.choices) {
     const said = typeof payload.error === 'string'
       ? payload.error
@@ -198,7 +202,8 @@ async function complete(cfg, opts) {
   }
 
   if (!text) {
-    throw emptyCompletion({ label, finishReason, reasoning, maxTokens: body.max_tokens, usage: payload.usage });
+    throw emptyCompletion({ label, finishReason, reasoning, maxTokens: body.max_tokens, usage: payload.usage,
+      model: ranModel });
   }
 
   // TOKENS WERE SPENT EVEN WHEN THE ANSWER IS UNUSABLE (0.26.1). Carried on every error raised after
@@ -223,17 +228,17 @@ async function complete(cfg, opts) {
         throw new AiError('bad_response',
           `${label} ran out of room mid-answer (${body.max_tokens} tokens) — the structured reply ` +
           'was cut off before it was finished. If this repeats, the schema may be letting the ' +
-          'model ramble; a Regenerate usually succeeds.', { cause: err, usage });
+          'model ramble; a Regenerate usually succeeds.', { cause: err, usage, model: ranModel });
       }
       throw new AiError('bad_response',
-        `${label} was asked for structured output and returned text that will not parse.`, { cause: err, usage });
+        `${label} was asked for structured output and returned text that will not parse.`, { cause: err, usage, model: ranModel });
     }
   }
 
   return {
     text,
     json,
-    model: payload.model || cfg.model,
+    model: ranModel || cfg.model,
     usage,
     ms: Date.now() - started,
     finishReason,
@@ -271,7 +276,7 @@ function unclosedThinking(text) {
  * payload, so they are distinguished: the budget ran out, the budget went on thinking, or the server
  * genuinely said nothing.
  */
-function emptyCompletion({ label, finishReason, reasoning, maxTokens, usage: raw }) {
+function emptyCompletion({ label, finishReason, reasoning, maxTokens, usage: raw, model }) {
   const spent = (raw && raw.completion_tokens) || 0;
   const usage = normaliseUsage(raw);
   if (finishReason === 'length' || (reasoning && !spentLeftRoom(spent, maxTokens))) {
@@ -280,16 +285,16 @@ function emptyCompletion({ label, finishReason, reasoning, maxTokens, usage: raw
       (reasoning ? ' on internal reasoning' : '') +
       '. This model thinks before it replies, so raise the reply limit (1024 is a sensible floor; ' +
       "4096 or more with reasoning: 'full').",
-    { usage });
+    { usage, model });
   }
   if (reasoning) {
     return new AiError('bad_response',
       `${label} returned only its internal reasoning and no answer. Raise the reply limit and try again.`,
-    { usage });
+    { usage, model });
   }
   return new AiError('bad_response',
     `${label} returned an empty completion (finish reason: ${finishReason || 'none given'}). ` +
-    'Check the model is fully loaded on the server.', { usage });
+    'Check the model is fully loaded on the server.', { usage, model });
 }
 
 /** Did the completion stop well short of the ceiling? Then the ceiling was not the problem. */

package/reasoning.js

@@ -108,6 +108,9 @@ function reasoningFor(model, mode, provider) {
  *   effort      → output_config.effort
  *   thinking    → the `thinking` object
  *   budget      → `{ type: 'enabled', budget_tokens }` sized from maxTokens (pre-4.6 models)
+ *   maxOutput   → the model's output limit; a budget row never sends max_tokens above it (0.27.1)
+ *   cannotThink → the model has no extended thinking: 'full' sends nothing and is warned about,
+ *                 exactly as for an unknown model (0.27.1)
  *   sampling    → false: the model rejects temperature, so none is sent
  *
  * `examples` are real model ids that must land on their own row — the test checks each one, which is
@@ -135,22 +138,61 @@ const ANTHROPIC_FAMILIES = Object.freeze([
   { family: 'claude-*-4-6', match: /(opus|sonnet)-4-6/,
     examples: ['claude-opus-4-6', 'claude-sonnet-4-6'],
     off: {}, full: { thinking: { type: 'adaptive' }, effort: 'high' }, sampling: true },
-  { family: 'claude-*-4-5 and older', match: /-4-5|-4-1|(opus|sonnet|haiku)-4(?![-.]?\d)|claude-3/,
-    examples: ['claude-haiku-4-5', 'claude-sonnet-4-5', 'claude-opus-4-5', 'claude-opus-4-1', 'claude-3-7-sonnet-latest'],
-    off: {}, full: { budget: true }, sampling: true }
+  // PRE-4.6, ONE ROW PER OUTPUT LIMIT (0.27.1). 0.27.0 had a single row and doubled max_tokens on
+  // 'full' with no ceiling — 80000 asked of Haiku 4.5, which allows 64000, is a 400. Limits from the
+  // model tables (cached 2026-09-25). Dated ids (claude-opus-4-20250514) and the -0 aliases land here
+  // too; 0.27.0 matched neither, so 'full' on them sent no thinking and warned "unknown model".
+  { family: 'claude-*-4-5', match: /-4-5/,
+    examples: ['claude-haiku-4-5', 'claude-sonnet-4-5', 'claude-opus-4-5', 'claude-sonnet-4-5-20250929'],
+    off: {}, full: { budget: true }, maxOutput: 64000, sampling: true },
+  { family: 'claude-opus-4-1 / claude-opus-4', match: /opus-4-1|opus-4(?:-0|-\d{8})?(?![-.]?\d)/,
+    examples: ['claude-opus-4-1', 'claude-opus-4-1-20250805', 'claude-opus-4-0', 'claude-opus-4-20250514'],
+    off: {}, full: { budget: true }, maxOutput: 32000, sampling: true },
+  { family: 'claude-sonnet-4', match: /sonnet-4(?:-0|-\d{8})?(?![-.]?\d)/,
+    examples: ['claude-sonnet-4-0', 'claude-sonnet-4-20250514'],
+    off: {}, full: { budget: true }, maxOutput: 64000, sampling: true },
+  { family: 'claude-3-7-sonnet', match: /claude-3-7/,
+    examples: ['claude-3-7-sonnet-latest', 'claude-3-7-sonnet-20250219'],
+    off: {}, full: { budget: true }, maxOutput: 64000, sampling: true },
+  // EVERY OTHER CLAUDE 3 HAS NO EXTENDED THINKING (0.27.1). 0.27.0's /claude-3/ sent them
+  // `thinking: enabled` on 'full', which the API refuses. Now they keep the pre-0.27 request and
+  // 'full' is a warning — the same as a model this table does not know — never an error: the caller
+  // asked for more thought, not for the call to fail.
+  { family: 'claude-3 without extended thinking', match: /claude-3/,
+    examples: ['claude-3-5-haiku-20241022', 'claude-3-5-haiku-latest', 'claude-3-haiku-20240307',
+      'claude-3-opus-20240229', 'claude-3-5-sonnet-20241022'],
+    off: {}, full: {}, cannotThink: true, sampling: true }
 ]);
 
 /** Thinking room added on top of the answer's own maxTokens when a pre-4.6 model is asked to think. */
 const MIN_THINKING_BUDGET = 1024;
 
+/**
+ * maxTokens as a positive integer, or refused (0.27.1). A fraction is floored; anything that is not
+ * a finite number of at least 1 is the caller's bug. A string "2048" used to turn the budget sum into
+ * a string concatenation that Math.min read as the model's whole limit, and a negative value left
+ * budget_tokens above max_tokens — both sent without complaint.
+ */
+function positiveTokens(value) {
+  const n = typeof value === 'number' && Number.isFinite(value) ? Math.floor(value) : NaN;
+  if (!(n >= 1)) {
+    const shown = typeof value === 'string' ? JSON.stringify(value) : String(value);
+    throw new AiError('refused', `maxTokens must be a positive number of tokens; got ${shown}.`);
+  }
+  return n;
+}
+
 /**
  * What to change on an Anthropic request body for this model and mode, or null for an unknown model
- * (which keeps the pre-0.27 request: no thinking field, temperature as given).
+ * (which keeps the pre-0.27 request: no thinking field, temperature as given). `cannotThink` is set
+ * when 'full' was asked of a model with no extended thinking, so the adapter can say so.
  *
- * @returns {{family:string, thinking?:object, effort?:string, sendTemperature:boolean, maxTokens:number}|null}
+ * @returns {{family:string, thinking?:object, effort?:string, sendTemperature:boolean, maxTokens:number,
+ *            cannotThink?:boolean}|null}
  */
-function anthropicReasoning(model, mode, maxTokens) {
+function anthropicReasoning(model, mode, maxTokensIn) {
   assertReasoning(mode);
+  const maxTokens = positiveTokens(maxTokensIn);
   const m = String(model || '').toLowerCase();
   const f = ANTHROPIC_FAMILIES.find((x) => x.match.test(m));
   if (!f) return null;
@@ -158,12 +200,17 @@ function anthropicReasoning(model, mode, maxTokens) {
   const out = { family: f.family, sendTemperature: f.sampling, maxTokens };
   if (want.thinking) out.thinking = want.thinking;
   if (want.effort) out.effort = want.effort;
+  if (isFull(mode) && f.cannotThink) out.cannotThink = true;
   if (want.budget) {
     // The caller's maxTokens stays the ANSWER's room; the thinking budget is added on top, because
     // budget_tokens must be below max_tokens and a budget carved out of the answer would starve it.
-    const budget = Math.max(MIN_THINKING_BUDGET, maxTokens);
+    // CAPPED AT THE MODEL'S OUTPUT LIMIT (0.27.1): max_tokens counts the thinking too, and a request
+    // past the limit is refused. Near the limit the thinking room shrinks first, down to the API's
+    // minimum of 1024; only then does the answer's room give way.
+    const total = Math.min(maxTokens + Math.max(MIN_THINKING_BUDGET, maxTokens), f.maxOutput);
+    const budget = Math.max(MIN_THINKING_BUDGET, total - maxTokens);
     out.thinking = { type: 'enabled', budget_tokens: budget };
-    out.maxTokens = maxTokens + budget;
+    out.maxTokens = total;
     // Extended thinking requires the default temperature on these models.
     out.sendTemperature = false;
   }