@aria-framework/ai 0.7.0 → 0.8.1

package/health.js

@@ -172,23 +172,42 @@ function createHealthChecker(opts = {}) {
   const cooldownMs = Number(opts.cooldownMs) || 60000;
   const threshold = Math.max(1, Number(opts.failureThreshold) || 3);
 
-  /** id -> { failures, downUntil, lastGoodAt, lastError, lastMs, lastCheckedAt, modelPresent } */
   const state = new Map();
   const entry = (id) => {
     if (!state.has(id)) {
       state.set(id, {
         failures: 0, downUntil: 0, lastGoodAt: null,
-        lastError: null, lastMs: null, lastCheckedAt: null, modelPresent: null
+        lastError: null, lastMs: null, lastCheckedAt: null, modelPresent: null,
+        // The last few completions, for throughput. A window rather than a single value because
+        // one reload spike would otherwise define the number an operator plans capacity from.
+        samples: []
       });
     }
     return state.get(id);
   };
 
+  /** How many completions to average throughput over. Small enough to still track a real change. */
+  const WINDOW = 10;
+
   /** Fold one outcome into the breaker. Exposed because a real CALL is better evidence than a probe. */
   function report(id, ok, info = {}) {
     const e = entry(id);
     e.lastCheckedAt = now();
     if (info.ms != null) e.lastMs = info.ms;
+
+    // THROUGHPUT, and what it honestly measures: completion tokens divided by the WHOLE call, so
+    // it includes prompt processing, queueing and the network. That is not the model's raw
+    // generation speed — separating those would need time-to-first-token, which no adapter
+    // reports — but it is what the caller actually experienced, which is the number worth planning
+    // against. Only completions count; a health probe generates no tokens and would drag it to 0.
+    // Guarded on TOKENS, not on duration. Requiring ms > 0 here silently dropped any call that
+    // completed inside a millisecond — which a fast local model or a stub genuinely does, so the
+    // sample count became timing-dependent. The division is where zero actually matters, so that
+    // is where it is handled.
+    if (ok && info.tokens > 0) {
+      e.samples.push({ tokens: info.tokens, ms: Math.max(0, Number(info.ms) || 0) });
+      if (e.samples.length > WINDOW) e.samples.shift();
+    }
     if (ok) {
       e.failures = 0;
       e.downUntil = 0;
@@ -267,7 +286,15 @@ function createHealthChecker(opts = {}) {
     /** Everything the UI needs for one provider, without probing. */
     status(id) {
       const e = state.get(id);
-      if (!e) return { id, status: 'unknown', failures: 0 };
+      // The same SHAPE for an unseen provider, so a caller never has to tell `undefined` (this key
+      // does not exist here) from `null` (we do not know yet) — they mean the same thing to a view.
+      if (!e) {
+        return {
+          id, status: 'unknown', failures: 0, lastGoodAt: null, lastError: null, lastMs: null,
+          lastCheckedAt: null, modelPresent: null, tokensPerSec: null, samples: 0,
+          cooldownRemainingMs: 0
+        };
+      }
       const down = !!(e.downUntil && now() < e.downUntil);
       return {
         id,
@@ -278,6 +305,17 @@ function createHealthChecker(opts = {}) {
         lastMs: e.lastMs,
         lastCheckedAt: e.lastCheckedAt,
         modelPresent: e.modelPresent,
+        // NULL until something has actually generated tokens. Reporting 0 tok/s for a provider
+        // nobody has used yet reads as "it is slow" rather than "we do not know".
+        // Null rather than Infinity when every sample was too fast to measure: "we cannot tell"
+        // is the honest answer, and a card showing Infinity tok/s is worse than showing nothing.
+        tokensPerSec: (() => {
+          if (!e.samples.length) return null;
+          const ms = e.samples.reduce((n, x) => n + x.ms, 0);
+          if (ms <= 0) return null;
+          return Math.round(e.samples.reduce((n, x) => n + x.tokens, 0) / (ms / 1000));
+        })(),
+        samples: e.samples.length,
         cooldownRemainingMs: down ? e.downUntil - now() : 0
       };
     },

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.7.0",
+  "version": "0.8.1",
   "license": "UNLICENSED",
   "private": false,
   "publishConfig": {

package/views/ai/provider-card.ejs

@@ -64,6 +64,14 @@
           <div><div class="text-body-secondary text-uppercase" style="font-size:.68rem;letter-spacing:.06em">Latency</div>
             <span class="font-monospace"><%= h.lastMs %> ms</span></div>
         <% } %>
+        <% if (h.tokensPerSec != null) { %>
+          <%# Completion tokens over the WHOLE call, so it includes prompt processing and the
+              network — what the caller experienced, not the model's raw generation speed. The
+              title says so, because an unqualified "tok/s" invites comparing it to a benchmark. %>
+          <div><div class="text-body-secondary text-uppercase" style="font-size:.68rem;letter-spacing:.06em">Throughput</div>
+            <span class="font-monospace"
+                  title="Completion tokens per second of total call time, averaged over the last <%= h.samples %> call<%= h.samples === 1 ? '' : 's' %>. Includes prompt processing and network."><%= h.tokensPerSec %> tok/s</span></div>
+        <% } %>
         <% if (typeof usage !== 'undefined' && usage) { %>
           <div><div class="text-body-secondary text-uppercase" style="font-size:.68rem;letter-spacing:.06em">Calls</div>
             <span class="font-monospace"><%= Number(usage.calls || 0).toLocaleString() %></span></div>