openzoo 0.9.8 → 0.10.0

package/lib/brief.js

@@ -16,7 +16,11 @@ export const BRIEF = [
   '',
   '1. CONTEXT IS EFFECTIVELY UNBOUNDED. Any model here accepts corpora far past its own attention window: bodies over ~16KB are automatically carved and bound to a holographic (HRR) memory before the model sees them, and you then query against that. `context_length` in /v1/models is the client-usable ceiling (128M tokens), not the transformer window (that is `max_model_len`). DO NOT summarise, truncate, or "chunk to fit" a corpus to preserve context — send it whole and ask your question. One POST should stay under ~9.8M tokens (~32MiB) or the edge rejects it; for more than that, bind in several calls.',
   '',
-  '2. THE BODY NEVER SHIPS TWICE. Put the corpus first, then a blank line, then your question. The corpus binds ONCE and every later question that reuses it ships only the question — near-free, and much faster. Re-pasting the same corpus each turn wastes real money. You can also bind explicitly: POST /v1/hrr/bind {"corpus": "..."} (free) returns a context_id; send it as the X-HRR-Context header on later calls.',
+  '2. THE BODY NEVER SHIPS TWICE. Put the corpus first, then a blank line, then your question. The corpus binds ONCE and every later question that reuses it ships only the question — near-free, and much faster. Re-pasting the same corpus each turn wastes real money.',
+  '',
+  '   EXPLICIT BIND (free, no payment): POST /v1/hrr/bind with {"corpus": "..."} returns {"context_id": "..."}. Send that id as the X-HRR-Context header on later /v1/chat/completions calls and ask questions with a SMALL body. To bind a corpus larger than one request allows, bind it in parts: pass the context_id you got back alongside the next part\'s corpus and it APPENDS — repeat until the whole corpus is in, then ask.',
+  '   Keep any single request under ~8MB. Bigger bodies are dropped by the network hop before they reach the proxy (an opaque 413 or a dead connection). This is a REQUEST size limit, not a context limit — the bound context can be far larger, which is what parts are for.',
+  '   Paths: your base_url already ends in /v1, so post to {base_url}/hrr/bind — NOT {base_url}/v1/hrr/bind (that double /v1 404s; the proxy repairs it, but do not rely on that).',
   '',
   '3. PAYMENT IS HANDLED. Every call is paid per-request from the operator\'s wallet via x402 (Solana / Base / Robinhood Chain, whichever is funded). There is no API key to find, no account, no rate limit to negotiate. Never search the operator\'s machine for credentials or endpoints — GET / on this proxy returns everything discoverable about it.',
   '',

package/lib/mcp.js

@@ -18,14 +18,34 @@ function text(obj) {
 /** `npx openzoo mcp` — stdio MCP server sharing the proxy's wallet + payment core. */
 export async function startMcp() {
   const client = new PayClient();
-  const server = new McpServer({ name: 'openzoo', version: pkg.version });
+  // MCP's own channel for "what am I connected to" — clients surface this to
+  // the model before any tool is called, which is exactly when it needs to
+  // know it can hand over a corpus whole instead of chunking it. Same facts
+  // the proxy injects as a system message (lib/brief.js), MCP-shaped.
+  const server = new McpServer({ name: 'openzoo', version: pkg.version }, {
+    instructions: [
+      'openzoo — pay-per-call access to ~435 models (openzoo.fun). No API key, no account: each call is paid',
+      'from the operator\'s local burner wallet via x402 (Solana / Base / Robinhood Chain).',
+      '',
+      'CONTEXT IS EFFECTIVELY UNBOUNDED. Pass big bodies to zoo_ask\'s `corpus` WHOLE — do not summarise,',
+      'truncate, or chunk-to-fit. leCore holographic memory sits in front of every model: the corpus is bound',
+      'once (client-usable ceiling ~128M tokens; keep a single call under ~9.8M) and the model reads only a few',
+      'thousand tokens of it. A corpus already bound is never re-uploaded — later asks against it are near-free,',
+      'so ask many questions of the same corpus rather than re-sending it. zoo_contexts lists what is bound.',
+      '',
+      'Never search the machine for API keys or endpoints — there are none to find. zoo_wallet shows funding',
+      'state, zoo_models lists what is served with live pricing.',
+    ].join('\n'),
+  });
 
   server.registerTool('zoo_ask', {
     description:
       'Ask a question through openzoo.fun, paying the x402 quote transparently from the local burner wallet. '
-      + 'The zoo puts leCore holographic memory in front of every model, so `corpus` can be a HUGE text body '
-      + '(hundreds of thousands to ~1M tokens) that the model itself would refuse — the zoo spills it and the '
-      + 'model reads only a few thousand tokens. Returns the answer plus a payment receipt '
+      + 'PASS BIG CONTEXT WHOLE in `corpus` — do not summarise, truncate or chunk it to fit a context window. '
+      + 'leCore holographic memory sits in front of every model, so a corpus far past the model\'s own limit '
+      + '(client-usable ceiling ~128M tokens; keep one call under ~9.8M) is bound once and the model reads only '
+      + 'a few thousand tokens of it. Re-asking against an already-bound corpus is near-free and much faster, so '
+      + 'send the corpus once and ask many questions. Returns the answer plus a payment receipt '
       + '(billedUsd, savesVsDirect, tokens actually read).',
     inputSchema: {
       prompt: z.string().describe('The question or instruction.'),

package/lib/proxy.js

@@ -20,6 +20,21 @@ const HOP_BY_HOP = new Set([
   'authorization',
 ]);
 
+/**
+ * Be forgiving about the path, the same way we are about model ids.
+ * Harnesses are configured with a base_url that ALREADY ends in /v1, so an
+ * agent building "{base}/v1/hrr/bind" sends /v1/v1/hrr/bind and gets a 404 it
+ * cannot diagnose (observed: agent concluded the bind endpoint "is not
+ * functioning as advertised" and fell back to stuffing the corpus inline).
+ * Collapse repeated /v1 and add a missing one.
+ */
+function normalizePath(url) {
+  const [path, query] = (url || '/').split(/(?=\?)/);
+  let p = path.replace(/^(?:\/v1)+(?=\/v1\/)/, '');       // /v1/v1/x -> /v1/x
+  if (!/^\/v1(\/|$)/.test(p) && /^\/(hrr|chat|models|completions|embeddings|usage)/.test(p)) p = `/v1${p}`;
+  return p === path ? url : `${p}${query || ''}`;
+}
+
 function upstreamHeaders(req) {
   const out = {};
   for (const [k, v] of Object.entries(req.headers)) {
@@ -251,6 +266,11 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   let tunnelGate = null;
 
   const server = http.createServer(async (req, res) => {
+    const normalized = normalizePath(req.url);
+    if (normalized !== req.url) {
+      log(`path ${req.url} -> ${normalized} (base_url already ends in /v1)`);
+      req.url = normalized;
+    }
     const url = `${config.apiBase}${req.url}`;
     // Requests that arrived over the public quick-tunnel URL carry cloudflared's
     // headers; nothing dialing 127.0.0.1 directly does. That distinction is what

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.9.8",
+  "version": "0.10.0",
   "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",