openzoo 0.50.75 → 0.50.77

package/bin/openzoo.js

@@ -284,6 +284,9 @@ async function main() {
         ? process.argv[ei + 1].split(',').map((e) => (e.startsWith('.') ? e : `.${e}`))
         : undefined;
       const mb = (n) => (n / 1048576).toFixed(1);
+      // Delta uploads are routinely a few KB against a multi-MB corpus; "0.0MB
+      // of 3.2MB" reads as a bug. Pick the unit per number.
+      const hb = (n) => (n >= 1048576 ? `${(n / 1048576).toFixed(1)}MB` : n >= 1024 ? `${(n / 1024).toFixed(0)}KB` : `${n}B`);
       const out = await bindPath(target, {
         exts,
         force: process.argv.includes('--force'),
@@ -291,9 +294,23 @@ async function main() {
           if (p.stage === 'reused') console.log(`already bound — ${mb(p.bytes)}MB across ${p.files} file(s) reused, nothing uploaded`);
           if (p.stage === 'start') console.log(`binding ${mb(p.bytes)}MB from ${p.files} file(s) in ${p.parts} part(s)...`);
           if (p.stage === 'part') console.log(`  part ${p.index}/${p.of} bound (${mb(p.bytes)}MB)`);
+          // DELTA: the server already holds most of a re-bound repo, so say
+          // how much is actually crossing the wire — that number is the reason
+          // re-binding after an edit is cheap, and hiding it makes the feature
+          // look like a no-op.
+          if (p.stage === 'delta') {
+            console.log(p.missing === 0
+              ? `delta: server already holds all ${p.chunks} chunk(s) of ${hb(p.bytes)} — nothing to upload`
+              : `delta: ${p.missing} of ${p.chunks} chunk(s) missing on the server, uploading only those...`);
+          }
+          if (p.stage === 'delta-fill') console.log(`  shipped ${hb(p.shipped)} of ${hb(p.of)}${p.remaining ? ` (${p.remaining} still missing)` : ''}`);
         },
       });
       console.log('');
+      if (out.delta) {
+        const pct = out.bytes ? ((100 * out.shipped) / out.bytes).toFixed(1) : '0.0';
+        console.log(`bound via delta — uploaded ${hb(out.shipped)} of ${hb(out.bytes)} (${pct}%)`);
+      }
       console.log(`context: ${out.contextId}`);
       console.log(`ask it:  npx openzoo ask "your question" --context ${out.contextId}`);
       console.log('or send X-HRR-Context: <id> with a small body to /v1/chat/completions');

package/lib/bindpath.js

@@ -22,6 +22,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { config } from './config.js';
+import { createHash } from 'node:crypto';
 import { corpusHash, rememberContext, lookupContext } from './contexts.js';
 import { withNamespace } from './namespace.js';
 
@@ -122,6 +123,77 @@ export function splitIntoParts(text, maxBytes = MAX_PART_BYTES) {
   return parts;
 }
 
+
+/**
+ * DELTA BIND — ship only the chunks the server does not already hold.
+ *
+ * The whole-bind path below hashes the CONCATENATED corpus and re-uploads
+ * every part on a miss, so editing one file in a repo re-ships the tree.
+ * MEASURED here: a 23MB Rust tree in 4MB parts ran 25s -> 30s -> 65s, and a
+ * deploy mid-bind threw five good parts away.
+ *
+ * Here the unit is one file (split further only when a file alone exceeds a
+ * part). Probe with sha256 per chunk, get back {missing, known}, ship the
+ * missing in batches under MAX_PART_BYTES, and when every hash resolves the
+ * corpus binds under an ordinary context_id — through the same chunked path
+ * as a whole bind, so recall cannot tell the difference. MEASURED on the
+ * sidecar: 6 files / 124,350 chars, editing one file re-ships 22,525 (18%).
+ *
+ * Any non-200 anywhere returns null and the caller falls back to the whole
+ * bind. Delta is an optimisation; it must never be the reason a bind fails.
+ */
+const sha256 = (t) => createHash('sha256').update(t, 'utf8').digest('hex');
+
+const ddbg = (...a) => { if (process.env.OPENZOO_BIND_DEBUG) console.error('[delta]', ...a); };
+
+async function postDelta(payload) {
+  const r = await fetch(`${config.apiBase}/v1/hrr/delta`, {
+    method: 'POST',
+    headers: withNamespace({ 'content-type': 'application/json' }),
+    body: JSON.stringify(payload),
+  });
+  if (r.status !== 200) { ddbg('HTTP', r.status, (await r.text().catch(() => '')).slice(0, 200)); return null; }
+  const j = await r.json().catch(() => null);
+  if (!(j && Array.isArray(j.missing))) ddbg('bad shape', JSON.stringify(j).slice(0, 200));
+  return j && Array.isArray(j.missing) ? j : null;
+}
+
+async function bindDelta(fileTexts, shardKey, onProgress) {
+  const chunks = [];
+  for (const t of fileTexts) for (const part of splitIntoParts(t)) chunks.push(part);
+  const hashes = chunks.map(sha256);
+  const byHash = new Map(hashes.map((h, i) => [h, chunks[i]]));
+
+  const probe = await postDelta({ chunk_hashes: hashes, shard_key: shardKey });
+  if (!probe) return null;
+  let missing = probe.missing;
+  const total = chunks.reduce((n, c) => n + Buffer.byteLength(c), 0);
+  onProgress?.({ stage: 'delta', chunks: chunks.length, missing: missing.length, bytes: total });
+
+  let last = probe;
+  let shipped = 0;
+  while (missing.length) {
+    // one fill per batch under the part ceiling; the last fill assembles
+    const batch = {};
+    let size = 0;
+    for (const h of missing) {
+      const t = byHash.get(h);
+      if (t === undefined) { ddbg('missing hash not in byHash', h); return null; }
+      if (size && size + Buffer.byteLength(t) > MAX_PART_BYTES) break;
+      batch[h] = t; size += Buffer.byteLength(t);
+    }
+    if (!Object.keys(batch).length) { ddbg('empty batch'); return null; }
+    last = await postDelta({ chunk_hashes: hashes, chunks: batch, shard_key: shardKey });
+    if (!last) return null;
+    shipped += size;
+    onProgress?.({ stage: 'delta-fill', shipped, of: total, remaining: last.missing.length });
+    if (last.missing.length >= missing.length) { ddbg('no progress', last.missing.length, missing.length, JSON.stringify(last.refused)); return null; }   // no progress: refused chunks
+    missing = last.missing;
+  }
+  if (!last.complete || !last.context_id) { ddbg('incomplete', JSON.stringify(last).slice(0, 200)); return null; }
+  return { contextId: last.context_id, chunks: chunks.length, shipped, bytes: total };
+}
+
 async function postBind(payload) {
   const r = await fetch(`${config.apiBase}/v1/hrr/bind`, {
     method: 'POST',
@@ -167,9 +239,9 @@ export async function bindPath(target, { exts, onProgress, force = false } = {})
   // Each file is prefixed with its path so retrieval can cite where a passage
   // came from — a corpus of concatenated files with no provenance is much
   // less useful to answer from. HTML is reduced to its text (see readAsText).
-  const text = files
-    .map((f) => `===== ${path.relative(path.dirname(resolved), f) || path.basename(f)} =====\n${readAsText(f)}`)
-    .join('\n\n');
+  const fileTexts = files
+    .map((f) => `===== ${path.relative(path.dirname(resolved), f) || path.basename(f)} =====\n${readAsText(f)}`);
+  const text = fileTexts.join('\n\n');
 
   const bytes = Buffer.byteLength(text);
   const hash = corpusHash(text);
@@ -181,6 +253,18 @@ export async function bindPath(target, { exts, onProgress, force = false } = {})
     }
   }
 
+  // Delta first: on a re-bind after an edit this ships one file, not the tree.
+  // OPENZOO_BIND_DELTA=0 forces the whole-bind path.
+  if (process.env.OPENZOO_BIND_DELTA !== '0') {
+    try {
+      const d = await bindDelta(fileTexts, resolved, onProgress);
+      if (d) {
+        rememberContext(config.apiBase, hash, d.contextId);
+        return { contextId: d.contextId, files, parts: d.chunks, bytes, reused: false, delta: true, shipped: d.shipped };
+      }
+    } catch (e) { ddbg('threw', e?.message); /* fall through to the whole bind */ }
+  }
+
   const parts = splitIntoParts(text);
   onProgress?.({ stage: 'start', files: files.length, parts: parts.length, bytes });
 

package/lib/cursorbackend.js

@@ -1872,9 +1872,15 @@ const MODEL_ALIASES = {
   flash: 'zai-org/glm-5.3-flash',
   // NEVER OPENROUTER for Grok Bot: `auto` is the gateway router over
   // OpenRouter's catalog, so it lands on the door-only id instead.
-  auto: 'grok-4.6',
-  'openrouter/auto': 'grok-4.6',
-  'openzoo/auto': 'grok-4.6',
+  // openzoo/auto is the gateway router; the gateway keeps Auto on door-served
+  // models only, so it never lands on OpenRouter.
+  auto: 'openzoo/auto',
+  'openrouter/auto': 'openzoo/auto',
+  'openzoo/auto': 'openzoo/auto',
+  'fable-5.1': 'anthropic/claude-fable-5.1',
+  'claude-fable-5.1': 'anthropic/claude-fable-5.1',
+  'anthropic/fable-5.1': 'anthropic/claude-fable-5.1',
+  'anthropic/fable-5': 'anthropic/claude-fable-5',
   deepseek: 'deepseek/deepseek-v4-pro',
   'deepseek-pro': 'deepseek/deepseek-v4-pro',
   'deepseek-flash': 'deepseek/deepseek-v4-flash',
@@ -1888,7 +1894,7 @@ const MODEL_ALIASES = {
  *  — the bazaar (x402 upstream) row, not OpenRouter's `x-ai/grok-4.6`. The
  *  gateway serves the bare id off an x402 door with an on-chain cogs receipt,
  *  so an OpenRouter credit outage cannot take it down. */
-export const DEFAULT_ZOO_MODEL = 'grok-4.6';
+export const DEFAULT_ZOO_MODEL = 'openzoo/auto';
 async function resolveModelId(raw) {
   const s = String(raw || '').trim();
   if (!s) return null;

package/lib/mcp.js

@@ -413,6 +413,10 @@ export function buildMcpServer() {
         files: out.files.length,
         parts: out.parts,
         reused: out.reused,
+        // A delta bind uploaded only the chunks the server lacked. `uploaded_bytes`
+        // against `bound_bytes` is the saving; an agent re-binding a repo after
+        // one edit should see a small number here, not the whole tree.
+        ...(out.delta ? { delta: true, uploaded_bytes: out.shipped } : {}),
         next: `zoo_ask with context_id="${out.contextId}" and a question answers from this corpus; it is already bound, so pasting it into the prompt would send it twice.`,
       });
     } catch (e) {

package/package.json

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