@aria-framework/ai 0.26.1 → 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

@@ -35,7 +35,7 @@ const ai = createAiClient({
 const r = await ai.complete({
   system, messages, maxTokens: 400,
   schema,                 // optional: constrained JSON
-  // reasoning: 'full',   // optional, lmx only: let the model think fully (see Reasoning below)
+  // reasoning: 'full',   // optional, every provider: 'off' (default) or 'full' (see Reasoning below)
 });
 // r.text, r.json (when schema), r.model, r.usage.total, r.ms
 ```
@@ -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.
@@ -69,7 +72,7 @@ to write yourself:
 | Engine URLs come from the document | Resolved on every call, and never stored |
 | A status outage is not an inference outage | Keeps routing on the last good document for 3 minutes (`staleMs`), logging loudly |
 | Pin the certificate; never disable verification | Uses an undici `Agent({ connect: { ca } })` per stack. Never `NODE_EXTRA_CA_CERTS`, never `rejectUnauthorized:false` |
-| Choose the reasoning flag from the model | By default thinking is kept to a minimum: `qwen` → `chat_template_kwargs.enable_thinking=false`, `gpt-oss` → `reasoning_effort:'low'`, anything else gets neither (with a warning). `reasoning: 'full'` on the call (since 0.26.0) sends `enable_thinking=true` / `reasoning_effort:'high'` instead. The flag always overrides a raw `extra`; only the named option changes it. See [Reasoning](#reasoning-reasoning-full) |
+| Choose the reasoning flag from the model | By default thinking is kept to a minimum: `qwen` → `chat_template_kwargs.enable_thinking=false`, `gpt-oss` → `reasoning_effort:'low'`, anything else gets neither (with a warning). `reasoning: 'full'` on the call (since 0.26.0) sends `enable_thinking=true` / `reasoning_effort:'high'` instead. The flag always overrides a raw `extra`; only the named option changes it. Since 0.27.0 the same rule applies to every provider. See [Reasoning](#reasoning-reasoning-off--full) |
 | Size requests against `maxInputTokens` (per slot) | `contextTokens` is taken from the engine, not from config |
 | Identity is `(instance, id)`, falling back to `name` | `lmx.engineId` is matched first; `rekeyPlan()` migrates rows when ids are minted or engines renamed |
 | A `429` is about the key, not the engine | Fails fast (since 0.25.0): throws `rate_limit` with `lmxSkip: 'lmx_throttled'` and `retryAfterMs`. The client never waits; whether to wait or move on is the caller's decision |
@@ -176,10 +179,11 @@ instead:
 Failover across several engines for one job is the app's job; lmx provides none. List
 endpoints in preference order and take the first one that serves.
 
-### Reasoning (`reasoning: 'full'`)
+### Reasoning (`reasoning: 'off' | 'full'`)
 
-By default the adapter makes the model think as little as its family allows, so a quick answer
-stays quick. Pass `reasoning: 'full'` on a `complete()` call to let the model think fully:
+How much a model may think is decided by the **app, per call**, and every provider honours it (since
+0.27.0; before that only lmx did). Leave it out, or pass `reasoning: 'off'`, and the model thinks as
+little as its family allows, so a quick answer stays quick. Pass `reasoning: 'full'` to let it think:
 
 ```js
 const r = await ai.complete({
@@ -204,23 +208,60 @@ a `bad_response` AiError saying it ran out of room (and, when the server says so
 tokens went on internal reasoning), but the work is lost either way. Use **`maxTokens` ≥ 4096** and a
 **`timeoutMs` ≥ 120 s** (120000) on the endpoint, or the deadline cuts the answer off first.
 
-**What is sent, per model family** (read from the model the engine is running on each call):
+**lmx, openai-compatible and lmstudio: what is added to the request body, per model family.** The
+family is read from the model the engine is running (lmx) or the endpoint's model name (others):
 
-| Family | Default (no `reasoning`) | `reasoning: 'full'` |
+| Family | `'off'` (the default) | `reasoning: 'full'` |
 |---|---|---|
 | qwen | `{"chat_template_kwargs":{"enable_thinking":false}}` | `{"chat_template_kwargs":{"enable_thinking":true}}` |
 | gpt-oss | `{"reasoning_effort":"low"}` | `{"reasoning_effort":"high"}` |
-| anything else | nothing (warning logged) | nothing (warning logged that `'full'` could not be honoured) |
+| anything else | nothing (lmx logs a warning) | nothing (a warning that `'full'` could not be honoured) |
+
+**LM Studio ignores `chat_template_kwargs`** (measured live: Qwen3 thought just as long with
+`enable_thinking: false`). So on **`provider: 'lmstudio'`** a qwen model gets two more switches. One is
+`{"reasoning_effort":"none"}` for `'off'` and `{"reasoning_effort":"high"}` for `'full'`: verified live, but
+LM Studio documents `reasoning_effort` only for gpt-oss. The other is Qwen's own documented prompt switch,
+`/no_think` for `'off'` and `/think` for `'full'`, appended to the system prompt (or sent as one when there
+is none): documented on LM Studio's Qwen3 model pages, but only hybrid Qwen3 reads it. Both are sent, so
+if a future LM Studio drops one the other still holds. Configure an LM Studio server as `lmstudio`, not
+`openai-compatible`; as `openai-compatible` it keeps thinking on every call. Plain `openai-compatible`
+gets neither, because vLLM validates `reasoning_effort` and may refuse `'none'`.
+
+**anthropic: what is sent, per Claude generation.** The Messages API differs by generation: Opus 5.5
+and Fable cannot turn thinking off (effort is the only lever), Sonnet 5.5 turns it off with
+`between_tools`, and several current models refuse `temperature`, so none is sent to them.
+
+| Models | `'off'` (the default) | `reasoning: 'full'` | temperature |
+|---|---|---|---|
+| claude-fable / claude-opus-5-5 | `{"output_config":{"effort":"low"}}` | `{"output_config":{"effort":"high"}}` | not sent |
+| claude-opus-5 | `{"output_config":{"effort":"low"}}` | `{"thinking":{"type":"adaptive"},"output_config":{"effort":"high"}}` | not sent |
+| claude-sonnet-5-5 | `{"thinking":{"type":"between_tools"}}` | `{"thinking":{"type":"adaptive"},"output_config":{"effort":"high"}}` | not sent |
+| 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 | 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:
 
-- `'full'` is the only value. Leaving the option out (or `null`) means the default. Any other value,
-  for example `'high'`, `true` or `''`, is refused with `AiError` kind `refused` before any
+- The values are `'off'` and `'full'`. Leaving the option out (or `null`) means `'off'`. Any other
+  value, for example `'high'`, `true` or `''`, is refused with `AiError` kind `refused` before any
   request is made, whichever provider the endpoint uses.
 - The flag is merged **after** `extra`, so a raw `extra: { chat_template_kwargs: … }` or
-  `extra: { reasoning_effort: … }` cannot change it. Only `reasoning` can.
-- Only `lmx` honours it. On `openai-compatible`, `lmstudio` or `anthropic` the client logs a
-  warning, removes the option, and nothing reaches that provider's request body.
+  `extra: { reasoning_effort: … }` cannot change it. Only `reasoning` can. The option itself is never
+  copied into a request body.
 - `REASONING_MODES` (package root) lists the accepted values for an app that validates its own
   settings.
 

package/browser/ai-panels.js

@@ -1,138 +1,138 @@
-/**
- * The fold on the Inference list, and prefilling the supervisor form from a panel.
- *
- * WHY ANYTHING FOLDS. A stable stack is four engines, three credentials, a certificate fingerprint
- * and a verification report — worth having, not worth reading every time you open this page to do
- * something else. Folded, a panel is one line that still carries the whole verdict: status, the
- * count of what depends on it, all three credentials and when it was last checked. Folding hides
- * detail; it must never hide the reason you would have opened it.
- *
- * A PANEL WITH A PROBLEM IGNORES WHAT YOU REMEMBERED. `data-panel-attention` is stamped by the
- * server on anything with a missing engine, an expiring certificate, a failed check or a nearly
- * spent cap. Those open and stay open. Attention beats tidiness — the alternative is a page that
- * quietly honours a fold you chose last week and hides the thing that broke yesterday.
- *
- * THE PREFERENCE IS PER BROWSER AND DISPOSABLE. It is a convenience about how a page looks to one
- * person, so localStorage is the right home and losing it costs nothing. Every access is guarded:
- * a browser set to block site data throws on read, and a settings page must not break because
- * somebody tightened their privacy settings.
- */
-(function () {
-  'use strict';
-
-  var KEY = 's101.ai.panels';
-
-  function readPrefs() {
-    try {
-      return JSON.parse(window.localStorage.getItem(KEY) || '{}') || {};
-    } catch (e) {
-      return {};
-    }
-  }
-
-  function writePref(id, open) {
-    try {
-      var prefs = readPrefs();
-      prefs[id] = !!open;
-      window.localStorage.setItem(KEY, JSON.stringify(prefs));
-    } catch (e) { /* private window, or site data blocked — the fold still works for this visit */ }
-  }
-
-  function bodyOf(panel) {
-    var btn = panel.querySelector('[data-panel-toggle]');
-    if (!btn) return null;
-    return document.getElementById(btn.getAttribute('aria-controls'));
-  }
-
-  function setOpen(panel, open, remember) {
-    var btn = panel.querySelector('[data-panel-toggle]');
-    var body = bodyOf(panel);
-    if (!btn || !body) return;
-    // `hidden`, not a style: the server renders the closed state the same way, so a panel does not
-    // flicker open on load before this script runs.
-    body.hidden = !open;
-    btn.setAttribute('aria-expanded', open ? 'true' : 'false');
-    panel.classList.toggle('panel-open', open);
-    if (remember) writePref(panel.getAttribute('data-panel'), open);
-  }
-
-  function restore() {
-    var prefs = readPrefs();
-    var panels = document.querySelectorAll('[data-panel]');
-    for (var i = 0; i < panels.length; i += 1) {
-      var panel = panels[i];
-      var id = panel.getAttribute('data-panel');
-      // The server already opened this one and means it. Do not consult the preference at all —
-      // reading it and then ignoring it is the same thing, but invites somebody to "fix" it later.
-      if (panel.hasAttribute('data-panel-attention')) {
-        setOpen(panel, true, false);
-        continue;
-      }
-      if (Object.prototype.hasOwnProperty.call(prefs, id)) setOpen(panel, !!prefs[id], false);
-    }
-  }
-
-  document.addEventListener('click', function (ev) {
-    var toggle = ev.target.closest('[data-panel-toggle]');
-    if (toggle) {
-      var panel = toggle.closest('[data-panel]');
-      if (!panel) return;
-      var body = bodyOf(panel);
-      setOpen(panel, !!(body && body.hidden), true);
-      return;
-    }
-
-    // ── EDITING A STACK HAPPENS IN THE PANEL ────────────────────────────────────────────────────
-    //
-    // It used to happen in a form at the foot of the page, and Edit scrolled you down to it — away
-    // from the stack you were reading, into a form that also served as "Add a supervisor" and said
-    // nothing about which stack it had been filled with. Nothing needs prefilling now: every panel
-    // renders its own form, from the server, with its own values already in it.
-    var open = ev.target.closest('[data-stack-edit-open]');
-    if (open) { stackMode(open.closest('[data-stack]'), true); return; }
-
-    var cancel = ev.target.closest('[data-stack-cancel]');
-    if (cancel) {
-      var panel2 = cancel.closest('[data-stack]');
-      // A NEW stack has no reading half to go back to, so cancelling it puts the blank panel away.
-      if (panel2 && panel2.hasAttribute('data-stack-new')) { panel2.hidden = true; return; }
-      // Otherwise reload rather than restore: a Cancel that left half-typed values behind, ready to
-      // be posted by the next Save, would be worse than the extra request.
-      window.location.reload();
-      return;
-    }
-
-    // "Add LMX" reveals the blank panel that is already on the page, at the top of the list.
-    var add = ev.target.closest('[data-stack-add]');
-    if (add) {
-      var blank = document.querySelector('[data-stack-new]');
-      if (!blank) return;
-      blank.hidden = false;
-      blank.scrollIntoView({ block: 'nearest' });
-      var id = blank.querySelector('[name="id"]');
-      if (id) id.focus();
-    }
-  });
-
-  /** Swap one stack panel between reading and editing. */
-  function stackMode(panel, editing) {
-    if (!panel) return;
-    var view = panel.querySelector('[data-stack-view]');
-    var form = panel.querySelector('[data-stack-edit]');
-    if (!view || !form) return;
-    view.hidden = editing;
-    form.hidden = !editing;
-    if (editing) {
-      // The id is readonly on an existing stack, so focus the first field somebody can actually
-      // change rather than one that will not accept a keystroke.
-      var first = form.querySelector('[name="label"]') || form.querySelector('[name="status_url"]');
-      if (first) first.focus();
-    }
-  }
-
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', restore);
-  } else {
-    restore();
-  }
-})();
+/**
+ * The fold on the Inference list, and prefilling the supervisor form from a panel.
+ *
+ * WHY ANYTHING FOLDS. A stable stack is four engines, three credentials, a certificate fingerprint
+ * and a verification report — worth having, not worth reading every time you open this page to do
+ * something else. Folded, a panel is one line that still carries the whole verdict: status, the
+ * count of what depends on it, all three credentials and when it was last checked. Folding hides
+ * detail; it must never hide the reason you would have opened it.
+ *
+ * A PANEL WITH A PROBLEM IGNORES WHAT YOU REMEMBERED. `data-panel-attention` is stamped by the
+ * server on anything with a missing engine, an expiring certificate, a failed check or a nearly
+ * spent cap. Those open and stay open. Attention beats tidiness — the alternative is a page that
+ * quietly honours a fold you chose last week and hides the thing that broke yesterday.
+ *
+ * THE PREFERENCE IS PER BROWSER AND DISPOSABLE. It is a convenience about how a page looks to one
+ * person, so localStorage is the right home and losing it costs nothing. Every access is guarded:
+ * a browser set to block site data throws on read, and a settings page must not break because
+ * somebody tightened their privacy settings.
+ */
+(function () {
+  'use strict';
+
+  var KEY = 's101.ai.panels';
+
+  function readPrefs() {
+    try {
+      return JSON.parse(window.localStorage.getItem(KEY) || '{}') || {};
+    } catch (e) {
+      return {};
+    }
+  }
+
+  function writePref(id, open) {
+    try {
+      var prefs = readPrefs();
+      prefs[id] = !!open;
+      window.localStorage.setItem(KEY, JSON.stringify(prefs));
+    } catch (e) { /* private window, or site data blocked — the fold still works for this visit */ }
+  }
+
+  function bodyOf(panel) {
+    var btn = panel.querySelector('[data-panel-toggle]');
+    if (!btn) return null;
+    return document.getElementById(btn.getAttribute('aria-controls'));
+  }
+
+  function setOpen(panel, open, remember) {
+    var btn = panel.querySelector('[data-panel-toggle]');
+    var body = bodyOf(panel);
+    if (!btn || !body) return;
+    // `hidden`, not a style: the server renders the closed state the same way, so a panel does not
+    // flicker open on load before this script runs.
+    body.hidden = !open;
+    btn.setAttribute('aria-expanded', open ? 'true' : 'false');
+    panel.classList.toggle('panel-open', open);
+    if (remember) writePref(panel.getAttribute('data-panel'), open);
+  }
+
+  function restore() {
+    var prefs = readPrefs();
+    var panels = document.querySelectorAll('[data-panel]');
+    for (var i = 0; i < panels.length; i += 1) {
+      var panel = panels[i];
+      var id = panel.getAttribute('data-panel');
+      // The server already opened this one and means it. Do not consult the preference at all —
+      // reading it and then ignoring it is the same thing, but invites somebody to "fix" it later.
+      if (panel.hasAttribute('data-panel-attention')) {
+        setOpen(panel, true, false);
+        continue;
+      }
+      if (Object.prototype.hasOwnProperty.call(prefs, id)) setOpen(panel, !!prefs[id], false);
+    }
+  }
+
+  document.addEventListener('click', function (ev) {
+    var toggle = ev.target.closest('[data-panel-toggle]');
+    if (toggle) {
+      var panel = toggle.closest('[data-panel]');
+      if (!panel) return;
+      var body = bodyOf(panel);
+      setOpen(panel, !!(body && body.hidden), true);
+      return;
+    }
+
+    // ── EDITING A STACK HAPPENS IN THE PANEL ────────────────────────────────────────────────────
+    //
+    // It used to happen in a form at the foot of the page, and Edit scrolled you down to it — away
+    // from the stack you were reading, into a form that also served as "Add a supervisor" and said
+    // nothing about which stack it had been filled with. Nothing needs prefilling now: every panel
+    // renders its own form, from the server, with its own values already in it.
+    var open = ev.target.closest('[data-stack-edit-open]');
+    if (open) { stackMode(open.closest('[data-stack]'), true); return; }
+
+    var cancel = ev.target.closest('[data-stack-cancel]');
+    if (cancel) {
+      var panel2 = cancel.closest('[data-stack]');
+      // A NEW stack has no reading half to go back to, so cancelling it puts the blank panel away.
+      if (panel2 && panel2.hasAttribute('data-stack-new')) { panel2.hidden = true; return; }
+      // Otherwise reload rather than restore: a Cancel that left half-typed values behind, ready to
+      // be posted by the next Save, would be worse than the extra request.
+      window.location.reload();
+      return;
+    }
+
+    // "Add LMX" reveals the blank panel that is already on the page, at the top of the list.
+    var add = ev.target.closest('[data-stack-add]');
+    if (add) {
+      var blank = document.querySelector('[data-stack-new]');
+      if (!blank) return;
+      blank.hidden = false;
+      blank.scrollIntoView({ block: 'nearest' });
+      var id = blank.querySelector('[name="id"]');
+      if (id) id.focus();
+    }
+  });
+
+  /** Swap one stack panel between reading and editing. */
+  function stackMode(panel, editing) {
+    if (!panel) return;
+    var view = panel.querySelector('[data-stack-view]');
+    var form = panel.querySelector('[data-stack-edit]');
+    if (!view || !form) return;
+    view.hidden = editing;
+    form.hidden = !editing;
+    if (editing) {
+      // The id is readonly on an existing stack, so focus the first field somebody can actually
+      // change rather than one that will not accept a keystroke.
+      var first = form.querySelector('[name="label"]') || form.querySelector('[name="status_url"]');
+      if (first) first.focus();
+    }
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', restore);
+  } else {
+    restore();
+  }
+})();

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

@@ -26,7 +26,7 @@ const facts = require('./facts');
 const { AiError, fromFetchFailure, redact } = require('./error');
 const { polish } = require('./polish');
 const { generate } = require('./generate');
-const { assertReasoning, REASONING_MODES } = require('./providers/lmx');
+const { assertReasoning, REASONING_MODES } = require('./reasoning');
 
 const PROVIDERS = {
   // 'lmstudio' and 'openai-compatible' are the SAME adapter with different defaults — a kindness to
@@ -52,9 +52,6 @@ const DEFAULTS = {
 const RETRY_AFTER_MS = 400;
 const RETRY_ONLY_IF_FAILED_WITHIN_MS = 5000;
 
-/** Providers already warned that they ignore `reasoning` — once per provider per process. */
-const warnedReasoning = new Set();
-
 const NOOP_LOGGER = { info() {}, warn() {}, error() {} };
 const NOOP_BUDGET = { async assertWithinBudget() {}, async record() {} };
 
@@ -106,7 +103,7 @@ function createAiClient(deps = {}) {
    * Ask the configured model for something.
    * @param {{system?:string, messages:Array, maxTokens?:number, temperature?:number,
    *          schema?:object, signal?:AbortSignal, ticketId?:*, skipBudget?:boolean,
-   *          reasoning?:'full'}} opts
+   *          reasoning?:'off'|'full'}} opts
    * @param {object} [cfgOverride] the resolved config, when the caller already has it
    */
   async function complete(opts, cfgOverride) {
@@ -134,19 +131,9 @@ function createAiClient(deps = {}) {
     // by whichever caller forgets. `skipBudget` is for the admin's Test connection; it still records.
     if (!opts.skipBudget) await meter.assertWithinBudget(cfg, { ticketId: opts.ticketId });
 
-    // ONLY lmx HONOURS `reasoning`. Elsewhere it is warned about and removed, so no other adapter's
-    // request body can ever carry it.
-    let callOpts = opts;
-    if (opts.reasoning != null && cfg.provider !== 'lmx') {
-      if (!warnedReasoning.has(cfg.provider)) {
-        warnedReasoning.add(cfg.provider);
-        log.warn(`AI: reasoning '${opts.reasoning}' is honoured only by lmx engines — `
-          + `${cfg.label || cfg.provider} sends no reasoning flag and runs on its own default `
-          + '(warned once per provider).');
-      }
-      const { reasoning: _ignored, ...rest } = opts;
-      callOpts = rest;
-    }
+    // EVERY PROVIDER HONOURS `reasoning` (0.27.0): each adapter translates it for its model family
+    // (see reasoning.js). It used to be lmx-only, warned about and stripped everywhere else.
+    const callOpts = opts;
 
     const started = Date.now();
     let result;
@@ -158,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;