@opennodes/registry 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennodes/registry",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OpenNodes (ONP) reference registry: node registration with proof-of-resource qualification (Stage A/B/C), transparent ranking, enforceable estimates, catalog importers (OpenRouter, Hugging Face, models.dev, Ollama), MCP surface, and the web app (catalog, chat, advisor, Node Builder)",
   "license": "Apache-2.0",
   "type": "module",

package/src/server.js

@@ -100,6 +100,22 @@ export async function startRegistry({
     return { card, sigOk };
   }
 
+  /**
+   * Re-index a registered node's card when its origin serves a newer revision (restart,
+   * reprice, config change). Probes pin the revision they hold; without this a restarted
+   * node answers 409 to every probe and would look like an identity mismatch.
+   */
+  async function refreshCard(nodeId) {
+    try {
+      const node = await store.getNode(nodeId);
+      if (!node?.card_url || node.source === 'import') return;
+      const current = await store.latestCard(nodeId);
+      const fresh = await fetchCard(node.card_url);
+      if (current && fresh.revision === current.revision) return;
+      await indexCard(nodeId, node.card_url);
+    } catch { /* unreachable or invalid: probes will record the failure themselves */ }
+  }
+
   const app = createApp([
     ['POST', '/v0/nodes', async (req, res) => {
       const { card_url } = await readJson(req);
@@ -172,8 +188,12 @@ export async function startRegistry({
       if (node.state !== 'community' && node.state !== 'verified') {
         return problem(res, 409, 'wrong-state', `Stage B requires community tier, node is ${node.state}`);
       }
+      await refreshCard(params.id);
       const card = await store.latestCard(params.id);
       const stageB = await runStageB(store, params.id, card, { safeFetch, capacity: stageBCapacity });
+      if (stageB.stale) {
+        return problem(res, 409, 'stale-card', 'the node changed its card revision during the battery; retry');
+      }
       if (stageB.identityFailed) {
         await store.setState(params.id, 'disputed', 'Stage B identity fingerprint mismatch');
       } else if (stageB.ok) {
@@ -372,7 +392,7 @@ export async function startRegistry({
     ...exportRoutes(store, registryKeys),
   ], { cors: true }); // public read API: third-party web clients may call it directly
 
-  const stageCHandle = stageC ? startStageC(store, { safeFetch, ...stageC }) : null;
+  const stageCHandle = stageC ? startStageC(store, { safeFetch, refreshCard, ...stageC }) : null;
   const reimportHandle = reimport ? startReimport(store, { safeFetch, ...reimport }) : null;
   const actualPort = await listen(app, port, host);
   return {

package/src/stageb.js

@@ -52,13 +52,14 @@ export async function captureFingerprints(safeFetch, card, offering) {
 
 /** DS-ADM-02: identity check against stored references. */
 async function probeIdentity(safeFetch, card, offering, refs) {
-  let matches = 0;
+  let matches = 0, stale = false;
   for (const ref of refs) {
     const { status, text } = await chatOnce(safeFetch, card, offering, ref.prompt);
+    if (status === 409) stale = true;   // pinned revision is no longer current: not evidence about identity
     if (status === 200 && text !== null && sha256(text) === ref.expected_hash) matches++;
   }
   // Deterministic battery: require all prompts to match the reference distribution.
-  return { ok: matches === refs.length, matches, total: refs.length };
+  return { ok: matches === refs.length, matches, total: refs.length, ...(stale ? { stale: true } : {}) };
 }
 
 /** A needle counts as retrieved if the reply carries the full token or just its digits (small models drop the prefix). */
@@ -145,6 +146,10 @@ export async function runStageB(store, nodeId, card, { safeFetch, capacity = {}
     const refs = await store.getFingerprints(offering.model.artifact);
     if (refs.length) {
       verdict.identity = await probeIdentity(safeFetch, card, offering, refs);
+      if (verdict.identity.stale) {
+        // The node rejected our pinned revision (409). Abort without judging: the caller re-indexes and retries.
+        return { ok: false, identityFailed: false, stale: true, verdicts: [...verdicts, verdict] };
+      }
       await store.recordProbe(nodeId, offering.offering_id, 'B', 'identity', verdict.identity.ok,
         `${verdict.identity.matches}/${verdict.identity.total} reference matches`);
     } else {

package/src/stagec.js

@@ -9,6 +9,7 @@ const OBSERVED_STATES = ['community', 'verified', 'attested'];
 
 export function startStageC(store, {
   safeFetch,
+  refreshCard = null,             // re-index a node's card when its revision moved (restart / reprice)
   livenessIntervalMs = 300_000,   // spec: <=5 min; tests shorten this
   blindIntervalMs = 3_600_000,
   failThreshold = 3,
@@ -47,6 +48,7 @@ export function startStageC(store, {
   async function blindSweep() {
     for (const node of await store.allNodes()) {
       if (!OBSERVED_STATES.includes(node.state)) continue;
+      await refreshCard?.(node.id);
       const card = await store.latestCard(node.id);
       if (!card) continue;
       const chatOfferings = card.offerings.filter((o) => o.binding.profile === 'onp.openai.chat/v1');
@@ -66,6 +68,7 @@ export function startStageC(store, {
             max_tokens: 32,
           }),
         }, 30_000);
+        if (status === 409) { await refreshCard?.(node.id); continue; }   // stale pin, not a failure of the node
         const usage = body?.usage;
         const ok = status === 200 && Number.isFinite(usage?.prompt_tokens) && Number.isFinite(usage?.completion_tokens);
         await store.recordProbe(node.id, offering.offering_id, 'C', 'blind', ok,

package/src/web/index.html

@@ -983,11 +983,31 @@ async function loadChatTargets() {
   $('#ch-modenote').textContent = MODE_NOTES[$('#ch-mode').value] ?? '';
   if (!chat.offerings.length) {
     try {
-      const { offerings } = await api('/v0/offerings?limit=60&modality=text');
-      chat.offerings = offerings;
+      // Registered nodes answer straight from the browser with no key; imported catalog listings
+      // (OpenRouter, HF providers, models.dev) need the visitor's own key for that provider.
+      const [reg, all] = await Promise.all([
+        api('/v0/offerings?limit=60&modality=text&tier=community'),
+        api('/v0/offerings?limit=60&modality=text'),
+      ]);
+      const key = (o) => o.node_id + '/' + o.offering_id;
+      const ready = reg.offerings.filter((o) => o.source !== 'import');
+      const seen = new Set(ready.map(key));
+      const rest = all.offerings.filter((o) => !seen.has(key(o)));
+      const local = rest.filter((o) => o.local);            // Ollama library: runs on the visitor's own machine
+      const imports = rest.filter((o) => !o.local);
+      chat.offerings = [...ready, ...local, ...imports];
+      const opt = (o, i) => `<option value="${i}">${esc(o.model.name)} — ${esc(o.node_id)} — ${priceStr(o.pricing)}</option>`;
       $('#ch-add').innerHTML = '<option value="">+ Add a model…</option>'
-        + offerings.map((o, i) => `<option value="${i}">${esc(o.model.name)} — ${esc(o.node_id)} — ${priceStr(o.pricing)}</option>`).join('')
+        + (ready.length ? `<optgroup label="Ready to use — no key needed (${ready.length})">${ready.map((o, i) => opt(o, i)).join('')}</optgroup>` : '')
+        + (local.length ? `<optgroup label="On your machine — needs a local Ollama with this model pulled">${local.map((o, i) => opt(o, ready.length + i)).join('')}</optgroup>` : '')
+        + (imports.length ? `<optgroup label="Imported catalogs — your own API key required">${imports.map((o, i) => opt(o, ready.length + local.length + i)).join('')}</optgroup>` : '')
         + '<option value="custom">custom endpoint (local Ollama / any OpenAI server)</option>';
+      if (!chat.roster.length && ready.length && !sessionStorage.getItem('onp-advisor-handoff')) {
+        chat.roster.push({ offering: ready[0] });   // a newcomer can just type
+        renderRoster();
+        const log = $('#ch-log');
+        if (log && !chat.history.length) log.innerHTML = `<p class="sub" style="margin:0">Ready: <b>${esc(ready[0].model.name)}</b> on ${esc(ready[0].node_id)} (${esc(ready[0].tier)}, no key needed) is preselected — say something, or add more models on the right to compare.</p>`;
+      }
     } catch { $('#ch-add').innerHTML = '<option value="custom">custom endpoint</option>'; }
   }
   await applyAdvisorHandoff();
@@ -1099,6 +1119,7 @@ $('#ch-judge').addEventListener('change', refreshEstimate);
 function importKeyHint(offering, base, key) {
   if (!offering || offering.source !== 'import' || key) return null;
   const host = new URL(base).host;
+  if (offering.local || /^(localhost|127\.0\.0\.1|\[::1\])(:|$)/.test(host)) return null;   // your own machine: no key
   const where = host.includes('huggingface') ? 'a Hugging Face token (huggingface.co/settings/tokens)'
     : host.includes('openrouter') ? 'an OpenRouter API key (openrouter.ai/keys)' : `an API key for ${host}`;
   return `This is an imported catalog listing served by ${host}: your browser calls it directly, which needs ${where} — paste it in the API key field (stored only in this browser). Or run it locally with BYOK: npx @opennodes/cli gateway --key ${host}=<key>. Registered OpenNodes nodes need no key.`;
@@ -1189,7 +1210,8 @@ async function callTargetStream(t, messages, onDelta, maxTokens = 1024) {
 }
 
 const metaLine = (r) => [r.ttft != null ? `ttft ${r.ttft}ms · ` + r.ms + 'ms total' : r.ms + 'ms', r.usage ? `${r.usage.prompt_tokens}+${r.usage.completion_tokens} tok` : null, r.receipt ? 'receipt ✓' : null].filter(Boolean).join(' · ');
-const corsHint = ' — if this is a CORS/network error, the node must allow browser origins (local Ollama: set OLLAMA_ORIGINS)';
+const corsHint = (err) => /failed to fetch|networkerror|load failed/i.test(String(err?.message))
+  ? ' — network/CORS error: the node must allow browser origins (local Ollama: set OLLAMA_ORIGINS)' : '';
 
 function logEl(html) {
   if ($('#ch-log').querySelector('p.sub')) $('#ch-log').innerHTML = '';
@@ -1239,7 +1261,7 @@ async function runSingle(text) {
   } catch (err) {
     chat.history.pop();
     el.firstChild.textContent = '';
-    el.querySelector('.mm').innerHTML = '<span class="err">' + esc(err.message) + '</span>' + corsHint;
+    el.querySelector('.mm').innerHTML = '<span class="err">' + esc(err.message) + '</span>' + corsHint(err);
   }
 }
 
@@ -1259,7 +1281,7 @@ async function fanoutRound(labelPrefix, buildMessages, { remember = false } = {}
       }
       return { label: String.fromCharCode(65 + i), text: r.text, ok: true };
     } catch (err) {
-      cards[i].querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint + '</span>';
+      cards[i].querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint(err) + '</span>';
       return { label: String.fromCharCode(65 + i), ok: false };
     }
   }));
@@ -1346,7 +1368,7 @@ async function runPipeline(text) {
       el.querySelector('.ctext').textContent = r.text || '(empty)';
       el.querySelector('.mm').textContent = metaLine(r);
     } catch (err) {
-      el.querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint + ' — pipeline stopped</span>';
+      el.querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint(err) + ' — pipeline stopped</span>';
       return;
     }
   }