openzoo 0.34.10 → 0.35.0

package/lib/cursorbackend.js

@@ -27,6 +27,7 @@
  * + trailers for grpc-web. Both are handled below.
  */
 import http2 from 'node:http2';
+import https from 'node:https';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -236,17 +237,36 @@ const HOP_BY_HOP = new Set([
  * over UDP (which ignores /etc/hosts entirely), cache it, and dial the address
  * with the Host/SNI still set to the real hostname so TLS and routing succeed.
  */
-let realIpCache = null;
+// KEYED BY HOST. A single shared slot meant whichever of api/api-staging
+// resolved first pinned its address for the other one too.
+const realIpCache = new Map();
 async function resolveRealAnthropic(host) {
-  if (realIpCache) return realIpCache;
+  const hit = realIpCache.get(host);
+  if (hit) return hit;
   const { Resolver } = await import('node:dns/promises');
   const r = new Resolver();
   r.setServers(['1.1.1.1', '8.8.8.8']);
   const [ip] = await r.resolve4(host);
-  realIpCache = ip;
+  realIpCache.set(host, ip);
   return ip;
 }
 
+/**
+ * Headers we must NOT copy back from the upstream response.
+ *
+ * DELIBERATELY NARROWER THAN HOP_BY_HOP: `content-encoding` is absent here on
+ * purpose. Unlike fetch(), node:https hands us the body EXACTLY as it arrived —
+ * still gzip/brotli compressed. Stripping the encoding header while forwarding
+ * compressed bytes tells the app "this is plain JSON" over binary garbage, and
+ * it fails to parse the bootstrap payload. Forward body and label together.
+ * `content-length` still goes, because we set it from the buffer we actually
+ * have, and the h2 layer rejects the connection-specific ones outright.
+ */
+const RESP_DROP = new Set([
+  'connection', 'keep-alive', 'upgrade', 'proxy-connection',
+  'transfer-encoding', 'te', 'trailer', 'content-length',
+]);
+
 async function passthroughToRealAnthropic(req, res, body, host, full, log) {
   try {
     const ip = await resolveRealAnthropic(host);
@@ -256,18 +276,42 @@ async function passthroughToRealAnthropic(req, res, body, host, full, log) {
       headers[k] = Array.isArray(v) ? v.join(', ') : String(v);
     }
     headers.host = host;
-    const up = await fetch(`https://${ip}${full}`, {
-      method: req.method,
-      headers,
-      body: (req.method === 'GET' || req.method === 'HEAD') ? undefined : body,
-      redirect: 'manual',
+
+    // DIAL THE ADDRESS, BUT SPEAK THE NAME. fetch(`https://${ip}/...`) cannot do
+    // this: undici derives SNI from the URL, so the server saw a bare IP, had no
+    // certificate to offer for it, and killed the handshake
+    // (ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE). node:https lets the two be set
+    // independently — a custom `lookup` pins the connection to the public-DNS
+    // address (bypassing our own /etc/hosts entry, which would otherwise loop
+    // this request straight back into this very server), while `servername` and
+    // the Host header keep presenting the real hostname so the cert validates.
+    const lookup = (h, o, cb) => (o && o.all ? cb(null, [{ address: ip, family: 4 }]) : cb(null, ip, 4));
+    const { status, respHeaders, buf } = await new Promise((resolve, reject) => {
+      const up = https.request({
+        hostname: host, servername: host, port: 443, path: full,
+        method: req.method, headers, lookup,
+      }, (r) => {
+        const chunks = [];
+        r.on('data', (d) => chunks.push(d));
+        r.on('end', () => resolve({
+          status: r.statusCode, respHeaders: r.headers, buf: Buffer.concat(chunks),
+        }));
+        r.on('error', reject);
+      });
+      up.on('error', reject);
+      up.setTimeout(20000, () => up.destroy(new Error('upstream timeout')));
+      if (req.method !== 'GET' && req.method !== 'HEAD' && body && body.length) up.write(body);
+      up.end();
     });
-    const buf = Buffer.from(await up.arrayBuffer());
+
     const h = {};
-    up.headers.forEach((v, k) => { if (!HOP_BY_HOP.has(k.toLowerCase())) h[k] = v; });
-    res.writeHead(up.status, h);
+    for (const [k, v] of Object.entries(respHeaders)) {
+      if (RESP_DROP.has(k.toLowerCase())) continue;
+      h[k] = v;
+    }
+    res.writeHead(status, h);
     res.end(buf);
-    log(`cursor-backend:      ${req.method} ${full} -> REAL anthropic (${up.status}, ${buf.length}b)`);
+    log(`cursor-backend:      ${req.method} ${full} -> REAL anthropic (${status}, ${buf.length}b)`);
   } catch (e) {
     res.writeHead(502, { 'content-type': 'application/json' });
     res.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message: `passthrough failed: ${e.message}` } }));
@@ -360,8 +404,15 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
       // verbatim to the local paying proxy and relay the response — reusing the
       // whole translate+x402 path. (SNI is checked because the Host header may be
       // absent on h2.)
-      const host = String(req.headers[':authority'] || req.headers.host || req.socket?.servername || '');
-      const isAnthropic = /anthropic\.com$/.test(host);
+      // STRIP THE PORT BEFORE MATCHING. :authority / Host carry `host:port`
+      // whenever the client dials a non-default port, so an anchored
+      // /anthropic\.com$/ silently failed to match and the request fell through
+      // to the gRPC branch, which answered empty-OK. The desktop app then saw a
+      // 200 with no body for its session bootstrap — indistinguishable from the
+      // 404 it used to get, and it wedged the same way.
+      const rawHost = String(req.headers[':authority'] || req.headers.host || req.socket?.servername || '');
+      const host = rawHost.replace(/:\d+$/, '');
+      const isAnthropic = /(^|\.)anthropic\.com$/.test(host);
       // INTERCEPT INFERENCE ONLY. Matching the whole HOST sent every request the
       // desktop app makes to the local proxy — including the session bootstrap
       // (/api/organizations, /api/bootstrap, /api/account), which the proxy does

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:
@@ -301,6 +302,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.10",
+  "version": "0.35.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",