openzoo 0.50.76 → 0.50.78

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

@@ -144,14 +144,17 @@ export function splitIntoParts(text, maxBytes = MAX_PART_BYTES) {
  */
 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) return null;
+  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;
 }
 
@@ -175,19 +178,19 @@ async function bindDelta(fileTexts, shardKey, onProgress) {
     let size = 0;
     for (const h of missing) {
       const t = byHash.get(h);
-      if (t === undefined) return null;
+      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) return null;
+    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) return null;   // no progress: refused chunks
+    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) return null;
+  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 };
 }
 
@@ -259,7 +262,7 @@ export async function bindPath(target, { exts, onProgress, force = false } = {})
         rememberContext(config.apiBase, hash, d.contextId);
         return { contextId: d.contextId, files, parts: d.chunks, bytes, reused: false, delta: true, shipped: d.shipped };
       }
-    } catch { /* fall through to the whole bind */ }
+    } catch (e) { ddbg('threw', e?.message); /* fall through to the whole bind */ }
   }
 
   const parts = splitIntoParts(text);

package/lib/botlog.js

@@ -42,7 +42,7 @@ const MILESTONE = [
   /ERROR|FAIL|uncaught|rejection|timed out/,
   /wakeups restored|wakeup fire/,
   /ozRevive|ship_|ship:/,
-  /sendPrompt done/,
+  /sendPrompt done|>> sendPrompt/,
   /create_agent tool|deleteAgents n=/,
   /x_compose|chrome reattach/,
 ];
@@ -57,7 +57,7 @@ export function isBotMilestone(line) {
 /**
  * Terminal gets milestones (or everything with verbose); the FULL stream is
  * always appended to `file` so quiet mode never destroys evidence.
- * Default file: ~/.openzoo/bot.log (truncated at start of each run).
+ * Default file: ~/.openzoo/bot.log (appended; one header line per run).
  */
 export function makeBotLogger({ verbose = false, write = (m) => console.error(m), file = defaultBotLogPath(), fsMod = null } = {}) {
   let fd = null;
@@ -65,8 +65,10 @@ export function makeBotLogger({ verbose = false, write = (m) => console.error(m)
     try {
       const fsx = fsMod || fsSync;
       fsx.mkdirSync(pathMod.dirname(file), { recursive: true });
-      fd = fsx.openSync(file, 'w');
-      fsx.writeSync(fd, `# openzoo bot full log ${new Date().toISOString()}\n`);
+      // APPEND, never truncate: the minutely revive cron restarts a dead
+      // hijack, and a truncating open erased the very turn being debugged.
+      fd = fsx.openSync(file, 'a');
+      fsx.writeSync(fd, `# openzoo bot run ${new Date().toISOString()} pid=${process.pid}\n`);
     } catch { fd = null; }
   }
   return (m) => {

package/lib/cursorbackend.js

@@ -45,7 +45,7 @@ import {
   DEFAULT_WAKEUP_PROMPT, addDeletedIds, filterDeleted,
 } from './grokbotAccount.js';
 import { formatSpendFooter, mergeTurnProof } from './spendProof.js';
-import { zooModelIds } from './models.js';
+import { zooModelIds, zooModelRow, mediaKindOf } from './models.js';
 import { prefixVisitorRichText } from './grokbotweb.js';
 import {
   ingestUpload, lookupUpload, readUploadChunk, readUploadImage, readUploadText,
@@ -2393,9 +2393,24 @@ const LOCAL_TOOLS = [
 
 export const LOCAL_TOOL_NAMES = LOCAL_TOOLS.map((t) => t.function.name);
 
+/**
+ * OpenAI-compatible upstreams cap `tools` at 128. MEASURED 2026-09-01:
+ * surplusintelligence `400 Invalid 'tools': array too long … got 130` — every
+ * bot turn with both browsers attached died at the door. Locals first, then
+ * the browser MCPs (the bots' real work), then whatever fits.
+ */
+export const MAX_TOOLS = 128;
+export function capTools(list, max = MAX_TOOLS) {
+  if (!Array.isArray(list) || list.length <= max) return list;
+  const name = (t) => String(t?.function?.name || '');
+  const local = list.filter((t) => LOCAL_TOOL_NAMES.includes(name(t)));
+  const browser = list.filter((t) => !LOCAL_TOOL_NAMES.includes(name(t)) && /^(chrome|brave)-devtools__/.test(name(t)));
+  const rest = list.filter((t) => !local.includes(t) && !browser.includes(t));
+  return [...local, ...browser, ...rest].slice(0, max);
+}
 function liveTools() {
   const extra = hostMcpTools();
-  return extra.length ? [...LOCAL_TOOLS, ...extra] : LOCAL_TOOLS;
+  return capTools(extra.length ? [...LOCAL_TOOLS, ...extra] : LOCAL_TOOLS);
 }
 
 async function captureScreenshot(log) {
@@ -2744,6 +2759,58 @@ function zooTextFromMessage(msg, data) {
   return '';
 }
 
+let mediaClient = null;
+function receiptToX402(r) {
+  if (!r) return {};
+  return { billedUsd: r.billedUsd, directUsd: r.directUsd ?? r.billedUsd, rail: r.rail, tx: r.tx, line: r.line, paid: r.asset };
+}
+/** Pay the media endpoint, poll the job, paint the URL. Same PayClient path as zoo_video. */
+async function mediaTurn({ model, kind, prompt, log, onProgress, signal }) {
+  const { PayClient } = await import('./pay.js');
+  const { config } = await import('./config.js');
+  const { withNamespace } = await import('./namespace.js');
+  mediaClient ||= new PayClient();
+  const say = (m) => { try { onProgress?.(m); } catch { /* */ } };
+  say(`Rendering ${kind} with ${model}…`);
+  log(`cursor-backend:      media ${kind} POST model=${model} ${JSON.stringify(String(prompt || '').slice(0, 60))}`);
+  let response; let receipt; let data = {};
+  try {
+    ({ response, receipt } = await mediaClient.fetch(`${config.apiBase}/v1/${kind}s/generations`, {
+      method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ model, prompt }),
+    }));
+    data = await response.json().catch(() => ({}));
+  } catch (e) {
+    return { text: `${kind} generation failed: ${e.message}`, data: {} };
+  }
+  if (!response.ok) return { text: `${kind} generation failed: HTTP ${response.status} ${JSON.stringify(data).slice(0, 240)}`, data: { x402: receiptToX402(receipt) } };
+  if (kind === 'image') {
+    const url = data?.data?.[0]?.url || data?.outputs?.image_url || data?.url || null;
+    return { text: url ? `🖼️ ${url}` : JSON.stringify(data).slice(0, 400), data: { x402: receiptToX402(receipt) } };
+  }
+  const id = data?.id;
+  let url = data?.outputs?.video_url || null;
+  let status = data?.status || 'queued';
+  let err = null;
+  const t0 = Date.now();
+  while (!url && id && Date.now() - t0 < 8 * 60_000) {
+    if (signal?.aborted) throw new Error('superseded');
+    await new Promise((ok) => setTimeout(ok, 5000));
+    try {
+      const r = await fetch(`${config.apiBase}/v1/videos/${encodeURIComponent(id)}`, { headers: withNamespace({}), signal: AbortSignal.timeout(15000) });
+      const j = await r.json().catch(() => ({}));
+      status = j?.status || status;
+      url = j?.outputs?.video_url || null;
+      if (status === 'failed') { err = j?.error?.message || JSON.stringify(j?.error || j).slice(0, 200); break; }
+    } catch (e) { log(`cursor-backend:      media poll ${e.message}`); }
+    say(`Rendering video… ${status} ${Math.round((Date.now() - t0) / 1000)}s`);
+  }
+  const text = url
+    ? `🎬 ${url}`
+    : err ? `video failed: ${err}` : `video job ${id || '?'} still ${status} after 8 min — check later: ${config.apiBase}/v1/videos/${id || ''}`;
+  log(`cursor-backend:      media video done id=${id} status=${status} url=${url ? 'yes' : 'no'}`);
+  return { text, data: { x402: receiptToX402(receipt) } };
+}
+
 async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
   const model = currentModel(agentId);
   const helper = localExecSse.size > 0;
@@ -2757,6 +2824,14 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
   };
   await ensureTranscriptHydrated(agentId, log);
   try { await reattachChrome({ log }); } catch (e) { log(`cursor-backend:      chrome reattach ${e.message}`); }
+  // A bot pinned to a video/image model: the prompt IS the render request.
+  // A chat POST to ByteDance/Seedance-2.5 came back 502 with an empty body
+  // and painted "(empty zoo reply)" — measured 2026-09-01.
+  if (!chatOnly) {
+    let mediaKind = null;
+    try { mediaKind = mediaKindOf(await zooModelRow(model)); } catch { mediaKind = null; }
+    if (mediaKind) return await mediaTurn({ model, kind: mediaKind, prompt: spoken, log, onProgress: opts.onProgress, signal: opts.signal });
+  }
   log(`cursor-backend:      zoo POST :8402 model=${model} helper=${helper ? localExecSse.size : 0} hist=${historyMessages(agentId, spoken).length}${chatOnly ? ` visitor=${visitor.shortname} chat-only` : ''} ${JSON.stringify((spoken || '').slice(0, 60))}`);
   if (typeof opts.onProgress === 'function') opts.onProgress('Working on your Mac…');
 

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/lib/models.js

@@ -541,3 +541,31 @@ export function wantsAnthropicModelList(headers = {}) {
 export function modelsListForRequest(payload, headers) {
   return wantsAnthropicModelList(headers) ? anthropicModelList(payload) : publishModelList(payload);
 }
+
+/* ── media rows (video / image) ─────────────────────────────────────────── */
+let rowsCache = { at: 0, rows: null, base: '' };
+/** Raw catalog rows incl. media (`kind`, `endpoint`), cached like zooModelIds. */
+export async function zooCatalogRows() {
+  if (rowsCache.rows && rowsCache.base === config.apiBase && Date.now() - rowsCache.at < CATALOG_TTL_MS) return rowsCache.rows;
+  const r = await fetchHeaders(`${config.apiBase}/v1/models`);
+  if (!r.ok) throw new Error(`model catalog fetch failed: HTTP ${r.status}`);
+  const d = await r.json();
+  const rows = Array.isArray(d?.data) ? d.data : [];
+  if (rows.length) rowsCache = { at: Date.now(), rows, base: config.apiBase };
+  return rows;
+}
+export async function zooModelRow(id) {
+  const want = String(id || '');
+  if (!want) return null;
+  const rows = await zooCatalogRows();
+  return rows.find((m) => m?.id === want) || rows.find((m) => String(m?.id || '').toLowerCase() === want.toLowerCase()) || null;
+}
+/** 'video' | 'image' | null — a chat POST to one of these is a guaranteed empty reply. */
+export function mediaKindOf(row) {
+  const k = String(row?.kind || '').toLowerCase();
+  if (k === 'video' || k === 'image') return k;
+  const ep = String(row?.endpoint || '');
+  if (/\/videos\/generations/.test(ep)) return 'video';
+  if (/\/images\/generations/.test(ep)) return 'image';
+  return null;
+}

package/package.json

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