openzoo 0.34.11 → 0.35.1

package/lib/mcp.js

@@ -7,6 +7,7 @@ import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
 import { tokenBalance } from './x402.js';
 import { askWithContext, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import { listContexts } from './contexts.js';
+import { withNamespace } from './namespace.js';
 
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 // The model zoo_ask uses when the caller does not name one. Opus 5 by default:
@@ -291,6 +292,47 @@ export function buildMcpServer() {
     }
   });
 
+  // leCore's own catalog — leCore docs/ZOO.md §1. Rule-0 for the model: ask the
+  // engine whether a faculty exists BEFORE writing the algorithm yourself.
+  // 3,214 capabilities; a curated tools/list would hide almost all of them, so
+  // discovery is a search and execution is one generic tool, exactly as leCore
+  // ships it over its own MCP.
+  server.registerTool('zoo_lecore_find', {
+    description:
+      'BEFORE implementing any algorithm, search leCore for it — 3,214 verified capabilities '
+      + '(nearest-neighbour search, float compression, mesh ops, certified image operators, physics '
+      + 'stepping, forecasting, corpus QA, bootstrap CIs, void/discovery, program-to-weights). '
+      + 'Hand-rolling what this returns is wasted tokens and worse code. Free, no payment.',
+    inputSchema: {
+      query: z.string().describe('What you are trying to do, in plain words: "nearest neighbour search", "compress floats".'),
+      top: z.number().int().positive().optional().describe('How many hits. Default 8.'),
+    },
+  }, async ({ query, top }) => {
+    const r = await fetch(`${config.apiBase}/v1/lecore/find`, {
+      method: 'POST', headers: withNamespace({ 'content-type': 'application/json' }),
+      body: JSON.stringify({ query, top: top ?? 8 }),
+    });
+    return text(await r.json());
+  });
+
+  server.registerTool('zoo_lecore_invoke', {
+    description:
+      'Run any leCore capability by name (find it first with zoo_lecore_find). Returns the result plus '
+      + 'measured cost {elapsed_ms, payload_bytes} and a determinism receipt {input_sha256, output_sha256} — '
+      + 'the same call with the same args always produces the same output hash, so results are verifiable '
+      + 'and cacheable. Free, no payment.',
+    inputSchema: {
+      name: z.string().describe('Capability name exactly as zoo_lecore_find returned it.'),
+      args: z.record(z.any()).optional().describe('Arguments object for the capability.'),
+    },
+  }, async ({ name, args }) => {
+    const r = await fetch(`${config.apiBase}/v1/lecore/invoke`, {
+      method: 'POST', headers: withNamespace({ 'content-type': 'application/json' }),
+      body: JSON.stringify({ name, args: args || {} }),
+    });
+    return text(await r.json());
+  });
+
   server.registerTool('zoo_contexts', {
     description: 'List corpora already bound to the zoo\'s holographic memory (local manifest). A listed corpus is never re-uploaded — asks against it are near-free.',
     inputSchema: {},
@@ -301,6 +343,50 @@ export function buildMcpServer() {
     })),
   }));
 
+  // OUROBOROS — the model's durable external memory, managed server-side by
+  // leCore (docs/ZOO.md §7-8). memory_write stores a fact into a per-wallet
+  // partition; memory_search recalls ranked, best first, across sessions. The
+  // namespace header keys the partition to THIS wallet. Free (infrastructure),
+  // and every response carries a deterministic lecore.receipt.
+  const memHeaders = () => withNamespace({ 'content-type': 'application/json' });
+
+  server.registerTool('zoo_remember', {
+    description: 'OUROBOROS: store a fact/decision into your durable external memory (leCore, server-side). Findable later by zoo_recall across sessions — you HAVE persistent memory; write to it instead of losing context.',
+    inputSchema: {
+      text: z.string().describe('the fact, decision, or note to remember'),
+      tags: z.array(z.string()).optional().describe('optional tags to group/filter later'),
+    },
+  }, async ({ text: t, tags }) => {
+    try {
+      const r = await fetch(`${config.apiBase}/v1/memory/write`, {
+        method: 'POST', headers: memHeaders(),
+        body: JSON.stringify({ text: t, tags: tags || [] }),
+      });
+      const d = await r.json();
+      if (!r.ok) return text({ error: d?.error || `memory_write HTTP ${r.status}` });
+      return text({ stored: d.stored, id: d.id, total_memories: d.entries, receipt: d._meta?.['lecore.receipt']?.output_sha256?.slice(0, 16) });
+    } catch (e) { return text({ error: `zoo_remember failed: ${e.message}` }); }
+  });
+
+  server.registerTool('zoo_recall', {
+    description: 'OUROBOROS: recall from your durable external memory — ranked results, best first, across all past sessions. Check here BEFORE claiming you do not remember something.',
+    inputSchema: {
+      query: z.string().describe('what to recall'),
+      top: z.number().int().min(1).max(50).optional().describe('how many results (default 4)'),
+      tags: z.array(z.string()).optional().describe('restrict to these tags'),
+    },
+  }, async ({ query, top, tags }) => {
+    try {
+      const r = await fetch(`${config.apiBase}/v1/memory/search`, {
+        method: 'POST', headers: memHeaders(),
+        body: JSON.stringify({ query, top: top || 4, ...(tags ? { tags } : {}) }),
+      });
+      const d = await r.json();
+      if (!r.ok) return text({ error: d?.error || `memory_search HTTP ${r.status}` });
+      return text({ hits: (d.hits || []).map((h) => ({ id: h.id, text: h.text, tags: h.tags, score: h.score })), searched: d.searched });
+    } catch (e) { return text({ error: `zoo_recall failed: ${e.message}` }); }
+  });
+
   return { server, client };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.34.11",
+  "version": "0.35.1",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",