@aria-framework/ai 0.8.0 → 0.9.0

package/health.js

@@ -200,8 +200,12 @@ function createHealthChecker(opts = {}) {
     // 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.
-    if (ok && info.tokens > 0 && info.ms > 0) {
-      e.samples.push({ tokens: info.tokens, ms: info.ms });
+    // 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) {
@@ -303,11 +307,14 @@ function createHealthChecker(opts = {}) {
         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".
-        tokensPerSec: e.samples.length
-          ? Math.round(
-            e.samples.reduce((n, x) => n + x.tokens, 0)
-            / (e.samples.reduce((n, x) => n + x.ms, 0) / 1000))
-          : null,
+        // 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/index.js

@@ -148,12 +148,31 @@ function createAiClient(deps = {}) {
 
   /** What the server has loaded, for an admin model picker. Empty when it cannot say. */
   async function listModels(cfgOverride) {
+    return (await listModelsResult(cfgOverride)).models;
+  }
+
+  /**
+   * The model list and WHY it is the length it is.
+   *
+   * Callers that only want names should use listModels(). An admin screen wants this one: an empty
+   * array on its own cannot tell "the server has nothing loaded" from "that address is not an
+   * OpenAI-compatible API root", and those need different fixes.
+   */
+  async function listModelsResult(cfgOverride) {
     const cfg = cfgOverride || await resolveConfig();
-    if (!cfg.enabled) return [];
+    if (!cfg.enabled) {
+      return { ok: false, models: [], url: null, status: 0, error: 'No provider is selected.' };
+    }
+    const adapter = PROVIDERS[cfg.provider];
+    if (!adapter) {
+      return { ok: false, models: [], url: null, status: 0, error: `Unknown provider “${cfg.provider}”.` };
+    }
     try {
-      return await PROVIDERS[cfg.provider].listModels(cfg);
+      if (adapter.listModelsResult) return await adapter.listModelsResult(cfg);
+      // An adapter that predates this contract still works; it simply cannot explain itself.
+      return { ok: true, models: await adapter.listModels(cfg), url: null, status: 0, error: null };
     } catch (err) {
-      return [];
+      return { ok: false, models: [], url: null, status: 0, error: err.message };
     }
   }
 
@@ -163,7 +182,7 @@ function createAiClient(deps = {}) {
   const boundGenerate = (opts) => generate(complete, opts);
 
   return {
-    complete, isEnabled, test, listModels, withOneRetry,
+    complete, isEnabled, test, listModels, listModelsResult, withOneRetry,
     polish: boundPolish, generate: boundGenerate,
     facts, AiError, PROVIDERS, DEFAULTS
   };

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.8.0",
+  "version": "0.9.0",
   "license": "UNLICENSED",
   "private": false,
   "publishConfig": {
@@ -25,6 +25,6 @@
     "@aria-framework/db-worker": { "optional": true }
   },
   "scripts": {
-    "test": "node test/smoke.js && node test/usageStore.js && node test/providerStore.js && node test/health.js && node test/views.js"
+    "test": "node test/smoke.js && node test/usageStore.js && node test/providerStore.js && node test/health.js && node test/listModels.js && node test/views.js"
   }
 }

package/providers/anthropic.js

@@ -173,6 +173,16 @@ function normaliseUsage(u) {
 /** No listing endpoint is used here — the model name is typed, and a wrong one fails loudly. */
 async function listModels() { return []; }
 
+/**
+ * Anthropic has no models endpoint on this surface. `unsupported` lets the admin screen say that
+ * plainly instead of reporting an empty list, which reads as a broken server.
+ */
+async function listModelsResult() {
+  return {
+    ok: true, models: [], url: null, status: 0, error: null, unsupported: true
+  };
+}
+
 /**
  * Anthropic does not offer an embeddings API. This is not a gap in the adapter.
  *
@@ -189,4 +199,4 @@ async function embed() {
     'with this provider. Everything else works; results are ordered by text search alone.');
 }
 
-module.exports = { complete, listModels, embed, API_VERSION, DEFAULT_BASE };
+module.exports = { complete, listModels, listModelsResult, embed, API_VERSION, DEFAULT_BASE };

package/providers/openai-compatible.js

@@ -284,29 +284,49 @@ function normaliseUsage(u) {
   return { prompt, completion, total: u.total_tokens || prompt + completion };
 }
 
-/** What the server has loaded — used by the admin screen so nobody has to type a model name blind. */
-async function listModels(cfg) {
+/**
+ * What the server has loaded, WITH the diagnosis attached.
+ *
+ * The previous version returned a bare array and threw the rest away, so three quite different
+ * situations all arrived as `[]`: a server with nothing loaded, a base URL pointing at the wrong
+ * API surface, and a host that never answered. The admin screen could then only recite the
+ * possibilities and let the operator guess — which cost a real afternoon when an Ollama base URL
+ * was set to `/api` (its NATIVE surface) instead of `/v1` (its OpenAI-compatible one). The server
+ * answered `404 page not found` and the screen said "nothing loaded, or the address may be wrong".
+ *
+ * The URL and the status are what separate those cases, and both are free right here. THIS IS NOT
+ * URL CORRECTION: a wrong address still fails, it just says which address it tried.
+ *
+ * @returns {{ok: boolean, models: string[], url: string, status: number, error: string|null}}
+ */
+async function listModelsResult(cfg) {
   const url = apiRoot(cfg.baseUrl) + '/models';
   try {
     const res = await fetch(url, {
       headers: cfg.apiKey ? { Authorization: `Bearer ${cfg.apiKey}` } : {},
       signal: AbortSignal.timeout(cfg.timeoutMs || 10000)
     });
-    if (!res.ok) return [];
+    if (!res.ok) {
+      return { ok: false, models: [], url, status: res.status, error: `GET ${url} answered HTTP ${res.status}` };
+    }
     const payload = await res.json();
-    // The 200-with-an-error-body case needs nothing special here: an error body has no `data`, so
-    // it already yields no models. A guard for it was written and then deleted — a control proved
-    // it could not fail, which is the definition of code that is not doing anything.
-    //
-    // The admin screen says both possibilities out loud ("nothing loaded, or the address may be
-    // wrong") because from here the two are genuinely indistinguishable.
-    return (payload.data || []).map((m) => m.id).filter(Boolean);
+    // A 200 WITH AN ERROR BODY still yields no models, because an error body has no `data` — but
+    // unlike the old code this reports it as an empty LIST rather than a failure, which is what it
+    // is. LM Studio does exactly this when the base URL is missing its `/v1`.
+    const models = (payload.data || []).map((m) => m.id).filter(Boolean);
+    return { ok: true, models, url, status: res.status, error: null };
   } catch (err) {
-    // A provider that cannot list models can still complete; this is a convenience, not a check.
-    return [];
+    // Never throws: a provider that cannot list models can still complete. This is a convenience,
+    // not a health check — but a convenience that says why it came back empty.
+    return { ok: false, models: [], url, status: 0, error: `GET ${url} failed: ${err.message}` };
   }
 }
 
+/** The bare list, for callers that only want names. Kept so existing callers are unaffected. */
+async function listModels(cfg) {
+  return (await listModelsResult(cfg)).models;
+}
+
 /**
  * Embed one or more strings.
  *
@@ -385,4 +405,4 @@ async function embed(cfg, texts) {
   });
 }
 
-module.exports = { complete, listModels, embed, apiRoot };
+module.exports = { complete, listModels, listModelsResult, embed, apiRoot };