@opennodes/registry 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennodes/registry",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "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",
@@ -43,7 +43,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@opennodes/core": "0.1.1",
+    "@opennodes/core": "0.1.2",
     "pg": "^8.13.1"
   }
 }

package/src/mcp.js

@@ -1,78 +1,33 @@
 // DS-MCP-01: the registry as an MCP server (streamable HTTP, stateless).
 // Minimal JSON-RPC handler covering initialize / tools/list / tools/call so any
-// MCP host gets ONP discovery (search_offerings, get_offering, estimate) for free.
-import { readJson, sendJson, problem, estimateBounds, round6, extractFeatures, recommend } from '@opennodes/core';
-import { searchOfferings, collectOfferings } from './search.js';
+// MCP host gets ONP discovery (recommend, search_offerings, get_offering, get_node, estimate) for free.
+import { readFileSync } from 'node:fs';
+import { readJson, sendJson, problem, estimateBounds, round6, extractFeatures, recommend, MCP_TOOLS, MCP_INSTRUCTIONS, summarizeNode } from '@opennodes/core';
+import { searchOfferingsPaged, searchOfferings, collectOfferings } from './search.js';
 
 const PROTOCOL_VERSION = '2025-06-18';
+const { version: VERSION } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 
-const TOOLS = [
-  {
-    name: 'search_offerings',
-    description: 'Search AI inference offerings in the OpenNodes registry. Filters: modality (text|image|audio|video|embedding|multimodal|agent), family, min_context, supports (comma list: tool_calls,json_mode,vision,streaming), max_input_price (USD per MTok), scheme (free|prepaid|x402), tier (community|verified|attested), lang ("en:strong"), q (free text), sort (rank|price). Returns offerings with pricing, trust tier, and rank explanation.',
+// Same tools as the stdio server in @opennodes/cli (definitions live in core). Two differences
+// on a remote endpoint: a `task` passed to recommend is sent here, so the schema says so and
+// offers `features` (from a local extractFeatures) as the private alternative.
+const TOOLS = MCP_TOOLS.map((tool) => {
+  if (tool.name !== 'recommend') return tool;
+  const { task, ...rest } = tool.inputSchema.properties;
+  return {
+    ...tool,
+    description: "Recommend the best AI node + model for a task, with an enforceable cost estimate and human-readable reasons. Use this first when you know the task but not the model. Pass `task` (sent to this registry, which extracts features and discards the text) or `features` already extracted on your side with extractFeatures from @opennodes/core, which keeps the prompt private. Returns ranked candidates with score components, a cost estimate pinned to the node's card revision, an optional cheaper two-step scenario, and MCP tool categories the task likely needs. To browse instead, use search_offerings; to price a specific chain, use estimate.",
     inputSchema: {
-      type: 'object',
+      ...tool.inputSchema,
+      required: [],
       properties: {
-        modality: { type: 'string' }, family: { type: 'string' },
-        min_context: { type: 'number' }, supports: { type: 'string' },
-        max_input_price: { type: 'number' }, scheme: { type: 'string' },
-        tier: { type: 'string' }, lang: { type: 'string' },
-        q: { type: 'string' }, sort: { type: 'string' }, limit: { type: 'number' },
+        task: { ...task, description: 'The task description or the prompt itself. Sent to the registry for feature extraction; use `features` to keep it private. Give this or `features`.' },
+        features: { type: 'object', description: 'Features from extractFeatures(prompt) in @opennodes/core: task class, size, language and needs, no prompt text. Give this or `task`.' },
+        ...rest,
       },
     },
-  },
-  {
-    name: 'get_offering',
-    description: 'Get full detail for one offering by node_id and offering_id, including endpoints, pricing, serving capabilities, and observed probe results.',
-    inputSchema: {
-      type: 'object',
-      required: ['node_id', 'offering_id'],
-      properties: { node_id: { type: 'string' }, offering_id: { type: 'string' } },
-    },
-  },
-  {
-    name: 'estimate',
-    description: 'Estimate cost bounds for a planned invocation chain BEFORE spending money. Each step names a concrete offering ("node_id/offering_id") or a select query (same filters as search_offerings), plus est_input_tokens and est_output_tokens. Returns per-step cost, pinned card_revision (making the estimate enforceable at invocation), and totals.',
-    inputSchema: {
-      type: 'object',
-      required: ['steps'],
-      properties: {
-        steps: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              offering: { type: 'string' },
-              select: { type: 'object' },
-              est_input_tokens: { type: 'number' },
-              est_output_tokens: { type: 'number' },
-            },
-          },
-        },
-      },
-    },
-  },
-  {
-    name: 'recommend',
-    description: 'Recommend the best AI node + model for a task. Give the task (a description or the prompt itself) and an optional policy; returns the top offerings with score components, human-readable reasons, an enforceable cost estimate with pinned card_revision, an optional two-step scenario (cheap triage/draft → strong expert/refine) when it would save money, and MCP tool categories the task likely needs. Prefer passing `features` (from a local extractFeatures) instead of `task` when the prompt is private.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        task: { type: 'string', description: 'task description or prompt' },
-        features: { type: 'object', description: 'pre-extracted features (privacy-preserving alternative to task)' },
-        est_output_tokens: { type: 'number' },
-        policy: {
-          type: 'object',
-          properties: {
-            min_tier: { type: 'string' }, max_input_per_mtok: { type: 'number' }, max_total_usd: { type: 'number' },
-            region: { type: 'string' }, prefer_local: { type: 'boolean' },
-            preset: { type: 'string', description: 'cheap | fast | quality | private' }, limit: { type: 'number' },
-          },
-        },
-      },
-    },
-  },
-];
+  };
+});
 
 async function runTool(store, name, args = {}) {
   switch (name) {
@@ -85,7 +40,7 @@ async function runTool(store, name, args = {}) {
     case 'search_offerings': {
       const query = new URLSearchParams();
       for (const [k, v] of Object.entries(args)) if (v !== undefined && v !== null) query.set(k, String(v));
-      return { offerings: await searchOfferings(store, query) };
+      return searchOfferingsPaged(store, query);
     }
     case 'get_offering': {
       const found = (await collectOfferings(store)).find(
@@ -93,6 +48,16 @@ async function runTool(store, name, args = {}) {
       if (!found) throw new Error(`unknown offering: ${args.node_id}/${args.offering_id}`);
       return found;
     }
+    case 'get_node': {
+      const node = await store.getNode(args.node_id);
+      if (!node) throw new Error(`unknown node: ${args.node_id} (node ids come from search_offerings or recommend results)`);
+      return summarizeNode({
+        ...node,
+        card: await store.latestCard(node.id),
+        probes: (await store.probesFor(node.id)).slice(0, 20),
+        history: await store.transitionsFor(node.id),
+      }, args.offering_limit ?? 25);
+    }
     case 'estimate': {
       const all = await collectOfferings(store);
       const steps = [];
@@ -137,8 +102,8 @@ async function handleRpc(store, msg) {
       return reply({
         protocolVersion: params?.protocolVersion ?? PROTOCOL_VERSION,
         capabilities: { tools: { listChanged: false } },
-        serverInfo: { name: 'opennodes-registry', version: '0.1.0' },
-        instructions: 'OpenNodes registry: search AI inference offerings, inspect them, and pre-price invocation chains. Typical flow: search_offerings -> estimate -> invoke via the offering endpoints (invocation itself is not exposed here).',
+        serverInfo: { name: 'opennodes-registry', title: 'OpenNodes registry', version: VERSION },
+        instructions: MCP_INSTRUCTIONS,
       });
     case 'ping':
       return reply({});

package/src/stageb.js

@@ -62,41 +62,63 @@ async function probeIdentity(safeFetch, card, offering, refs) {
   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). */
-export function needleFound(text, needle) {
+/** The needle counts as retrieved if its number appears in the reply as a whole number. */
+export function needleFound(text, digits) {
   if (typeof text !== 'string') return false;
-  if (text.includes(needle)) return true;
-  const digits = needle.split(':')[1];
-  return new RegExp(`(^|[^0-9])${digits}([^0-9]|$)`).test(text);
+  const number = String(digits).split(':').pop();
+  return new RegExp(`(^|[^0-9])${number}([^0-9]|$)`).test(text);
 }
 
-/** DS-ADM-03: needle retrieval at 25/50/90% of the claimed window; returns the verified cap. */
+const FILLER = 'lorem ipsum context filler segment. ';
+const fill = (chars) => FILLER.repeat(Math.ceil(Math.max(0, chars) / FILLER.length)).slice(0, Math.max(0, chars));
+const QUESTION = '\n\nWhat is the magic number mentioned in the text above? Reply with the number only.';
+
+/** Characters per token for this model's tokenizer, measured from a short prompt's reported usage. */
+async function calibrate(safeFetch, card, offering) {
+  const chars = 4000;
+  try {
+    const { status, usage } = await chatOnce(safeFetch, card, offering, `${fill(chars)}\n\nReply with OK.`, 4);
+    const reported = usage?.prompt_tokens;
+    if (status === 200 && reported > 0) return { charsPerToken: chars / reported, measured: true };
+  } catch { /* fall through to the default */ }
+  return { charsPerToken: 4, measured: false };
+}
+
+/**
+ * DS-ADM-03: retrieval at 25/50/90% of the claimed window; returns the verified cap.
+ * - Prompts are sized in the model's own tokens (calibrated from reported usage), not a chars/4 guess.
+ * - The fact sits near the start: engines that silently drop the front of an over-long prompt lose it,
+ *   and a reported prompt_tokens well short of the target is failed as a cut prompt.
+ * - The question is plain ("the magic number"): small models refuse or mangle odd tokens like NEEDLE.
+ * - The cap is the largest size with every smaller size passing, so one lucky answer can't vouch for a window.
+ */
 async function probeContext(safeFetch, card, offering) {
   const claimed = offering.serving?.context_window ?? 4096;
+  const { charsPerToken, measured } = await calibrate(safeFetch, card, offering);
   const results = [];
-  let cap = 0;
+  let cap = 0, unbroken = true;
   for (const fraction of [0.25, 0.5, 0.9]) {
     const tokens = Math.floor(claimed * fraction);
-    const needle = `NEEDLE:${Math.floor(tokens * 7919)}`; // deterministic per size
-    const fillerUnit = 'lorem ipsum context filler segment. ';
-    const beforeNeedle = Math.floor(tokens * 0.9) * 4; // needle at ~90% depth of this size
-    const afterNeedle = Math.max(0, tokens * 4 - beforeNeedle - needle.length - 60);
-    const prompt = fillerUnit.repeat(Math.ceil(beforeNeedle / fillerUnit.length)).slice(0, beforeNeedle)
-      + ` ${needle} `
-      + fillerUnit.repeat(Math.ceil(afterNeedle / fillerUnit.length)).slice(0, afterNeedle)
-      + ' Return the NEEDLE token from this text.';
-    let found = false, why = null;
+    const digits = String(Math.floor(tokens * 7919)); // deterministic per size
+    const fact = ` The magic number is ${digits}. `;
+    const body = Math.floor(tokens * charsPerToken) - fact.length - QUESTION.length - 40; // 40: chat template slack
+    const before = Math.floor(body * 0.1);
+    const prompt = fill(before) + fact + fill(body - before) + QUESTION;
+    let found = false, why = null, promptTokens = null;
     try {
       // Prefill on modest hardware is slow: allow ~30 ms per claimed token on top of the base timeout.
-      const { status, text } = await chatOnce(safeFetch, card, offering, prompt, 64, 60_000 + tokens * 30);
-      found = status === 200 && needleFound(text, needle);
-      if (!found) why = status !== 200 ? `status ${status}` : 'needle not in reply';
-    } catch (err) { found = false; why = /abort|timeout/i.test(String(err?.message)) ? 'timeout' : String(err?.message ?? err).slice(0, 80); }
-    results.push({ fraction, tokens, found, ...(why ? { why } : {}) });
-    if (found) cap = Math.max(cap, tokens);
+      const { status, text, usage } = await chatOnce(safeFetch, card, offering, prompt, 64, 60_000 + tokens * 30);
+      promptTokens = usage?.prompt_tokens ?? null;
+      if (status !== 200) why = `status ${status}`;
+      else if (measured && promptTokens != null && promptTokens < tokens * 0.85) why = `prompt cut to ${promptTokens} tokens`;
+      else if (!needleFound(text, digits)) why = 'number not in reply';
+      else found = true;
+    } catch (err) { why = /abort|timeout/i.test(String(err?.message)) ? 'timeout' : String(err?.message ?? err).slice(0, 80); }
+    results.push({ fraction, tokens, found, ...(promptTokens != null ? { prompt_tokens: promptTokens } : {}), ...(why ? { why } : {}) });
+    if (found && unbroken) cap = tokens; else unbroken = false;
   }
   const allPassed = results.every((r) => r.found);
-  return { ok: allPassed, claimed, verified_cap: allPassed ? claimed : cap, results };
+  return { ok: allPassed, claimed, verified_cap: allPassed ? claimed : cap, chars_per_token: Math.round(charsPerToken * 100) / 100, results };
 }
 
 /** DS-ADM-04: stepped-concurrency ramp; measures TTFT p50/p95 and rough TPS. */