openzoo 0.48.26 → 0.48.27

package/lib/proxy.js

@@ -245,6 +245,91 @@ function replayPut(key, data, settle) {
  * to sending the original body untouched — caching must never break a call.
  * Returns null (send as-is) or { body, contextId, hash, corpus, reused, savedBytes }.
  */
+/** Flatten one Anthropic content block to text leCore can index. */
+function blockText(b) {
+  if (typeof b === 'string') return b;
+  if (!b || typeof b !== 'object') return '';
+  if (b.type === 'text') return b.text || '';
+  if (b.type === 'tool_use') return `[tool_use ${b.name}] ${JSON.stringify(b.input ?? {})}`;
+  if (b.type === 'tool_result') {
+    const c = b.content;
+    return `[tool_result] ${typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).join('\n') : JSON.stringify(c ?? ''))}`;
+  }
+  if (b.type === 'thinking') return '';        // never bind reasoning traces
+  return '';
+}
+
+function msgText(m) {
+  const c = m?.content;
+  const body = typeof c === 'string' ? c : (Array.isArray(c) ? c.map(blockText).filter(Boolean).join('\n') : '');
+  return body ? `${(m.role || '?').toUpperCase()}: ${body}` : '';
+}
+
+/**
+ * Spill the OLD prefix of a long TRANSCRIPT into leCore.
+ *
+ * WHY THIS EXISTS. The only spill was the corpus+question shape below, which
+ * requires the last message to be one big string ending in `\n\n<question>` —
+ * true for zoo_ask, never true for an agent. `npx openzoo claude` therefore
+ * spilled NOTHING, hit Claude Code's own context ceiling, and auto-compacted,
+ * on a product whose pitch is that it does not have to. Compaction was honest
+ * given nothing was offloaded; this is what makes the claim true.
+ *
+ * Runs on the OpenAI shape ON PURPOSE. /v1/messages is translated by
+ * anthropicToOpenAI and rewritten to /v1/chat/completions BEFORE this is
+ * reached, so operating here covers Claude Code, Cursor and the raw API with
+ * one implementation instead of three that can drift.
+ *
+ * THE CUT POINT IS NOT NEGOTIABLE. An assistant `tool_calls` must be answered
+ * by role:"tool" messages or the upstream 400s, so the transcript may only be
+ * severed at a plain `user` message — everything before one is self-contained.
+ * A system message is never spilled: it is the operating contract, not history.
+ */
+async function spillTranscript(body, log) {
+  const msgs = Array.isArray(body?.messages) ? body.messages : null;
+  if (!msgs || msgs.length < 6) return null;
+
+  // Keep the recent tail, but never more than half the transcript: a fixed 8 on
+  // a 10-message body left only index 2 to search, which is rarely a user turn,
+  // so a SHORT-but-huge transcript (one giant tool_result) silently never
+  // spilled — the exact case an agent hits first.
+  const keepTail = Math.min(
+    Number(process.env.OPENZOO_KEEP_TAIL_MSGS || 8),
+    Math.max(2, Math.floor(msgs.length / 2)),
+  );
+  const firstSpillable = msgs.findIndex((m) => m?.role !== 'system');
+  if (firstSpillable < 0) return null;
+
+  let cut = -1;
+  for (let i = msgs.length - keepTail; i > firstSpillable; i--) {
+    if (msgs[i]?.role === 'user') { cut = i; break; }
+  }
+  if (cut <= firstSpillable) return null;         // nothing safely severable
+
+  const head = msgs.slice(0, firstSpillable);     // system block, always kept
+  const corpus = msgs.slice(firstSpillable, cut).map(msgText).filter(Boolean).join('\n\n');
+  if (corpus.length <= BIND_MIN_CHARS) return null;
+
+  const bind = await bindCorpus(corpus, {
+    onStage: (stage, info) => {
+      if (stage === 'binding') log(`binding ${mb(info.bytes)}MB of transcript to holographic memory...`);
+    },
+  });
+  const sent = msgs.length - cut;
+  log(bind.reused
+    ? `transcript prefix already bound (${bind.contextId}) — sending ${sent}/${msgs.length} turns`
+    : `transcript prefix bound (${mb(bind.bytes)}MB → ${bind.contextId}) — sending ${sent}/${msgs.length} turns`);
+
+  return {
+    body: Buffer.from(JSON.stringify({ ...body, messages: [...head, ...msgs.slice(cut)] })),
+    contextId: bind.contextId,
+    hash: bind.hash,
+    corpus,
+    reused: bind.reused,
+    savedBytes: bind.bytes,
+  };
+}
+
 async function maybeCacheCorpus(req, bodyBuf, log) {
   if (contextCacheDisabled()) return null;
   if (req.method !== 'POST' || !(req.url || '').includes('/chat/completions')) return null;
@@ -254,13 +339,19 @@ async function maybeCacheCorpus(req, bodyBuf, log) {
   try { body = JSON.parse(bodyBuf.toString('utf8')); } catch { return null; }
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs?.length) return null;
+  // CORPUS+QUESTION first — one huge final message ending in \n\n<ask>. That is
+  // what zoo_ask and the chat surface send, and binding exactly that body keeps
+  // the ask verbatim. Anything else (an agent transcript) falls through to the
+  // transcript spill, which used to be a silent no-op.
   const last = msgs[msgs.length - 1];
-  if (typeof last?.content !== 'string' || last.content.length <= BIND_MIN_CHARS) return null;
+  const oneShot = typeof last?.content === 'string'
+    && last.content.length > BIND_MIN_CHARS
+    && last.content.lastIndexOf('\n\n') >= BIND_MIN_CHARS;
+  if (!oneShot) return spillTranscript(body, log);
   const cut = last.content.lastIndexOf('\n\n');
-  if (cut < BIND_MIN_CHARS) return null;
   const corpus = last.content.slice(0, cut);
   const ask = last.content.slice(cut + 2).trim();
-  if (!ask || ask.length > 8000) return null;
+  if (!ask || ask.length > 8000) return spillTranscript(body, log);
 
   const bind = await bindCorpus(corpus, {
     onStage: (stage, info) => {

package/package.json

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