@aria-framework/ai 0.26.0 → 0.26.1

package/README.md

@@ -44,6 +44,12 @@ Every failure is thrown as an `AiError` with a `kind`: `disabled`, `unconfigured
 `timeout`, `auth`, `rate_limit`, `bad_response` or `refused`. The `message` is written for
 an admin screen and never includes a URL or key.
 
+**A failed call that spent tokens is still metered** (0.26.1). When the model answered but the answer
+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.
+
 `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.
 

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/index.js

@@ -148,7 +148,26 @@ function createAiClient(deps = {}) {
       callOpts = rest;
     }
 
-    const result = await withOneRetry(() => adapter.complete(cfg, callOpts), opts);
+    const started = Date.now();
+    let result;
+    try {
+      result = await withOneRetry(() => adapter.complete(cfg, callOpts), opts);
+    } catch (err) {
+      // A FAILED CALL CAN STILL HAVE SPENT TOKENS (0.26.1) — a model that thought until it ran out of
+      // room, a structured reply cut off mid-bracket. Recording only successes let a benchmark or a
+      // 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.
+      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 },
+            { ticketId: opts.ticketId });
+        } catch (recErr) {
+          log.warn(`AI: usage of a failed call not recorded (${recErr.message})`);
+        }
+      }
+      throw err;
+    }
 
     // ...and the counter after it, AWAITED: two calls in quick succession must both be counted
     // before the second's ceiling check reads the total, or the limit is enforced against a stale one.