@opennodes/registry 0.1.0

package/src/probes.js

@@ -0,0 +1,71 @@
+// Stage A admission probes (DS-ADM-01): health, blind invocation, /models agreement.
+// All outbound traffic goes through the SSRF-guarded fetcher (safefetch.js).
+import { fetchJsonCapped } from './safefetch.js';
+
+/** Run Stage A against a card. Records results via store; returns { ok, results }. */
+export async function runStageA(store, nodeId, card, { safeFetch } = {}) {
+  if (!safeFetch) safeFetch = (url, opts = {}, t = 10_000) => fetch(url, { ...opts, signal: AbortSignal.timeout(t) });
+  const fetchJson = (url, opts, timeoutMs = 10_000) => fetchJsonCapped(safeFetch, url, opts, timeoutMs);
+  const results = [];
+  const record = async (offeringId, kind, ok, detail, measured) => {
+    await store.recordProbe(nodeId, offeringId, 'A', kind, ok, detail, measured);
+    results.push({ offeringId, kind, ok, detail });
+  };
+
+  // 1. Health endpoint
+  try {
+    const t0 = performance.now();
+    const { status, body } = await fetchJson(card.endpoints.health);
+    const ok = status === 200 && body?.status === 'ok';
+    await record(null, 'health', ok, ok ? null : `status ${status}`, { latency_ms: Math.round(performance.now() - t0) });
+  } catch (err) {
+    await record(null, 'health', false, String(err.message ?? err));
+  }
+
+  // 2. /models agreement
+  let modelIds = new Set();
+  try {
+    const { status, body } = await fetchJson(`${card.endpoints.openai}/models`);
+    modelIds = new Set((body?.data ?? []).map((m) => m.id));
+    const cardIds = card.offerings.filter((o) => o.binding.profile.startsWith('onp.openai.')).map((o) => o.binding.model_id);
+    const missing = cardIds.filter((id) => !modelIds.has(id));
+    await record(null, 'models-agreement', status === 200 && missing.length === 0,
+      missing.length ? `card offerings absent from /models: ${missing.join(', ')}` : null);
+  } catch (err) {
+    await record(null, 'models-agreement', false, String(err.message ?? err));
+  }
+
+  // 3. Blind invocation per chat offering
+  for (const offering of card.offerings) {
+    if (offering.binding.profile !== 'onp.openai.chat/v1') continue;
+    try {
+      const t0 = performance.now();
+      // Generous timeout: CPU-backed nodes legitimately take tens of seconds per completion.
+      const { status, headers, body } = await fetchJson(`${card.endpoints.openai}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          'onp-offering': `${card.node.id}/${offering.offering_id}`,
+          'onp-card-revision': card.revision,
+        },
+        body: JSON.stringify({
+          model: offering.binding.model_id,
+          messages: [{ role: 'user', content: 'ONP Stage A conformance probe. Reply briefly.' }],
+          max_tokens: 32,
+        }),
+      }, 90_000);
+      const usage = body?.usage;
+      const ok = status === 200
+        && typeof body?.choices?.[0]?.message?.content === 'string'
+        && Number.isFinite(usage?.prompt_tokens) && Number.isFinite(usage?.completion_tokens);
+      const hasReceipt = Boolean(headers.get('onp-receipt'));
+      await record(offering.offering_id, 'blind-invocation', ok,
+        ok ? (hasReceipt ? null : 'no ONP-Receipt header') : `status ${status} or missing usage`,
+        { latency_ms: Math.round(performance.now() - t0), usage: usage ?? null, receipt: hasReceipt });
+    } catch (err) {
+      await record(offering.offering_id, 'blind-invocation', false, String(err.message ?? err));
+    }
+  }
+
+  return { ok: results.every((r) => r.ok), results };
+}

package/src/reimport.js

@@ -0,0 +1,55 @@
+// Periodic catalog re-import: keeps imported prices/offerings fresh (imports are
+// upserts keyed by node id + revision, so each cycle replaces the previous snapshot).
+import {
+  importModelsDev, importHuggingFace, importOpenRouter,
+  importOllamaLibrary, parseOllamaLibrary,
+  HF_ROUTER_URL, HF_HUB_URL, OPENROUTER_URL, OLLAMA_LIBRARY_URL,
+} from './importers.js';
+
+export const MODELS_DEV_URL = 'https://models.dev/api.json';
+
+export function startReimport(store, {
+  safeFetch,
+  intervalMs = 6 * 3600 * 1000,          // the HF re-test cadence
+  sources = ['openrouter', 'huggingface'],
+  onCycle = null,
+} = {}) {
+  let stopped = false;
+  const json = async (url, t = 120_000) => (await safeFetch(url, {}, t)).json();
+
+  async function cycle() {
+    const results = {};
+    for (const source of sources) {
+      try {
+        if (source === 'openrouter') {
+          results[source] = await importOpenRouter(store, await json(OPENROUTER_URL));
+        } else if (source === 'huggingface') {
+          const router = await json(HF_ROUTER_URL);
+          let hub = [];
+          try { hub = await json(HF_HUB_URL); } catch { /* enrichment optional */ }
+          results[source] = await importHuggingFace(store, router, hub);
+        } else if (source === 'models-dev') {
+          results[source] = await importModelsDev(store, await json(MODELS_DEV_URL));
+        } else if (source === 'ollama') {
+          const html = await (await safeFetch(OLLAMA_LIBRARY_URL, {}, 120_000)).text();
+          results[source] = await importOllamaLibrary(store, parseOllamaLibrary(html));
+        } else {
+          results[source] = { error: `unknown source: ${source}` };
+        }
+      } catch (err) {
+        results[source] = { error: String(err.message ?? err) };
+      }
+    }
+    onCycle?.(results);
+    return results;
+  }
+
+  const loop = async () => {
+    if (stopped) return;
+    await cycle().catch(() => {});
+    if (!stopped) setTimeout(loop, intervalMs).unref?.();
+  };
+  setTimeout(loop, 2000).unref?.(); // first cycle shortly after boot
+
+  return { stop: () => { stopped = true; }, cycle };
+}

package/src/safefetch.js

@@ -0,0 +1,47 @@
+// SSRF-guarded fetch for probe/card traffic (DS-NFR-03): the registry fetches
+// operator-supplied URLs, so private/reserved targets are denied unless explicitly
+// allowed (dev/e2e). Also caps response size and time.
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+
+const MAX_BODY = 5_000_000;
+
+function ipIsPrivate(ip) {
+  if (ip.includes(':')) { // IPv6
+    const low = ip.toLowerCase();
+    return low === '::1' || low === '::' || low.startsWith('fc') || low.startsWith('fd')
+      || low.startsWith('fe80') || low.startsWith('::ffff:127.') || low.startsWith('::ffff:10.')
+      || low.startsWith('::ffff:192.168.');
+  }
+  const [a, b] = ip.split('.').map(Number);
+  return a === 127 || a === 10 || a === 0
+    || (a === 172 && b >= 16 && b <= 31)
+    || (a === 192 && b === 168)
+    || (a === 169 && b === 254);
+}
+
+export function makeSafeFetch({ allowPrivate = false } = {}) {
+  return async function safeFetch(url, opts = {}, timeoutMs = 15_000) {
+    const parsed = new URL(url);
+    if (!['http:', 'https:'].includes(parsed.protocol)) throw new Error(`ssrf-blocked: scheme ${parsed.protocol}`);
+    if (!allowPrivate) {
+      const host = parsed.hostname;
+      const ips = isIP(host) ? [host] : (await lookup(host, { all: true })).map((r) => r.address);
+      const blocked = ips.find(ipIsPrivate);
+      if (blocked || host === 'localhost') throw new Error(`ssrf-blocked: ${host} resolves to private range`);
+    }
+    const res = await fetch(url, { ...opts, signal: AbortSignal.timeout(timeoutMs), redirect: 'error' });
+    const len = Number(res.headers.get('content-length') ?? 0);
+    if (len > MAX_BODY) throw new Error('response too large');
+    return res;
+  };
+}
+
+export async function fetchJsonCapped(safeFetch, url, opts = {}, timeoutMs) {
+  const res = await safeFetch(url, opts, timeoutMs);
+  const text = await res.text();
+  if (text.length > MAX_BODY) throw new Error('response too large');
+  let body = null;
+  try { body = JSON.parse(text); } catch { /* leave null */ }
+  return { status: res.status, headers: res.headers, body };
+}

package/src/search.js

@@ -0,0 +1,118 @@
+// Offering search + transparent ranking (ONP-3 §5–6).
+
+export const RANK_COMPONENTS = { price: 0.35, tier: 0.35, probe_success: 0.30 };
+const TIER_SCORE = { unverified: 0, community: 0.4, verified: 0.8, attested: 1.0 };
+
+/** Flatten indexed nodes into searchable offering summaries. */
+export async function collectOfferings(store) {
+  const out = [];
+  for (const node of await store.allNodes()) {
+    if (['delisted', 'suspended', 'submitted', 'challenged', 'disputed'].includes(node.state)) continue;
+    const card = await store.latestCard(node.id);
+    if (!card) continue;
+    const probes = await store.probesFor(node.id);
+    const stageA = probes.filter((p) => p.stage === 'A');
+    const probeSuccess = stageA.length ? stageA.filter((p) => p.ok).length / stageA.length : 0;
+    const tier = node.state === 'indexed' ? 'unverified' : node.state;
+    const availability = (await store.getObservations(node.id, '_node')).availability ?? null;
+    for (const offering of card.offerings) {
+      const obs = await store.getObservations(node.id, offering.offering_id);
+      // Measured values override claims (DS-ADM-03/04): cap the advertised context to
+      // the verified size, and surface registry-measured latency/throughput.
+      const serving = { ...offering.serving };
+      if (obs.context_cap && obs.context_cap < (serving.context_window ?? Infinity)) {
+        serving.context_window = obs.context_cap;
+        serving.context_capped_from = offering.serving.context_window;
+      }
+      out.push({
+        node_id: node.id,
+        offering_id: offering.offering_id,
+        tier,
+        source: node.source ?? 'registration',
+        institutional: Boolean(node.institutional),
+        card_revision: card.revision,
+        modality: offering.modality,
+        modalities: offering.modalities ?? null,
+        local: offering.local ?? null,
+        model: offering.model,
+        serving,
+        binding: offering.binding,
+        pricing: offering.pricing,
+        data_policy: offering.data_policy ?? null,
+        // Allocated hardware for THIS offering (offering-level override wins over the
+        // node-level description) — same artifact on different vendors runs on different
+        // silicon, and clients deserve to see which. Always basis-labeled, never measured.
+        hardware: offering.hardware ?? card.hardware ?? null,
+        benchmarks: offering.benchmarks ?? null,
+        observed: {
+          probe_success: round2(probeSuccess),
+          probes: stageA.length,
+          ttft_ms: obs.ttft_ms ?? null,
+          tps: obs.tps ?? null,
+          availability,
+        },
+        endpoints: card.endpoints,
+      });
+    }
+  }
+  return out;
+}
+
+export async function searchOfferings(store, query) {
+  let items = await collectOfferings(store);
+
+  const q = (k) => query.get(k);
+  if (q('modality')) items = items.filter((o) => o.modality === q('modality'));
+  if (q('family')) items = items.filter((o) => o.model.family === q('family') || o.model.artifact === q('family'));
+  if (q('min_context')) items = items.filter((o) => (o.serving?.context_window ?? 0) >= Number(q('min_context')));
+  if (q('supports')) {
+    const wanted = q('supports').split(',');
+    items = items.filter((o) => wanted.every((s) => o.serving?.supports?.includes(s)));
+  }
+  if (q('max_input_price')) items = items.filter((o) => (o.pricing.input_per_mtok ?? Infinity) <= Number(q('max_input_price')));
+  if (q('scheme')) items = items.filter((o) => o.pricing.schemes.includes(q('scheme')));
+  if (q('tier')) {
+    const order = ['unverified', 'community', 'verified', 'attested'];
+    const min = order.indexOf(q('tier'));
+    items = items.filter((o) => order.indexOf(o.tier) >= min);
+  }
+  if (q('lang')) {
+    const [lang, minGrade = 'basic'] = q('lang').split(':');
+    const grades = ['basic', 'strong', 'native'];
+    items = items.filter((o) => (o.serving?.languages ?? []).some(
+      (l) => l.lang === lang && grades.indexOf(l.grade) >= grades.indexOf(minGrade)));
+  }
+  if (q('q')) {
+    const needle = q('q').toLowerCase();
+    items = items.filter((o) => JSON.stringify(o.model).toLowerCase().includes(needle)
+      || o.offering_id.includes(needle) || o.node_id.includes(needle));
+  }
+
+  const maxPrice = Math.max(...items.map((o) => o.pricing.input_per_mtok ?? 0), 0.000001);
+  for (const o of items) {
+    const components = {
+      price: 1 - (o.pricing.input_per_mtok ?? maxPrice) / maxPrice,
+      tier: TIER_SCORE[o.tier] ?? 0,
+      probe_success: o.observed.probe_success,
+    };
+    o.rank = round2(Object.entries(RANK_COMPONENTS).reduce((sum, [k, w]) => sum + w * components[k], 0));
+    o.rank_explanation = { weights: RANK_COMPONENTS, components };
+  }
+
+  // Performance sorts prefer registry-measured values; claimed expected_* is the
+  // fallback, and offerings with neither sink to the bottom (ONP-3 §4).
+  const ttftOf = (o) => o.observed.ttft_ms?.p50 ?? o.serving?.expected_ttft_ms?.p50 ?? Infinity;
+  const tpsOf = (o) => (o.observed.tps > 0 ? o.observed.tps : null) ?? o.serving?.expected_tps?.p50 ?? -Infinity;
+  const sort = q('sort') ?? 'rank';
+  items.sort((a, b) => {
+    if (sort === 'price') return (a.pricing.input_per_mtok ?? Infinity) - (b.pricing.input_per_mtok ?? Infinity);
+    if (sort === 'ttft') return ttftOf(a) - ttftOf(b);
+    if (sort === 'tps') return tpsOf(b) - tpsOf(a);
+    return b.rank - a.rank;
+  });
+
+  const limit = Math.min(Number(q('limit') ?? 50), 200);
+  return items.slice(0, limit);
+}
+
+const round2 = (n) => Math.round(n * 100) / 100;