npm - openzoo - Versions diffs - 0.48.7 → 0.48.9 - Mend

openzoo 0.48.7 → 0.48.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/lib/grokui.mjs +108 -4
package/package.json +1 -1

package/lib/grokui.mjs CHANGED Viewed

@@ -336,6 +336,10 @@ function newGroupThread(names) {
 const BIND_CHUNK_BYTES = 512 * 1024;
 // Chained auto-run commands per user message. Each hop is a paid call.
 const AUTO_MAX_STEPS = Number(process.env.OZ_AUTO_MAX_STEPS || 8);
+// Ceiling on subagents per thread. Spawning is fire-and-forget and each child
+// can spawn too, so without a count it is unbounded — MEASURED as 15+ threads
+// all named tetris-contract, every one of them a live agent making paid calls.
+const SPAWN_MAX_CHILDREN = Number(process.env.OZ_SPAWN_MAX_CHILDREN || 12);
 // Injected fresh on every AUTO turn, never persisted into the thread.
 //
@@ -524,6 +528,18 @@ const SLASH_COMMANDS = [
 const usd = (n) => (n >= 0.01 || n === 0 ? '$' + n.toFixed(2) : '$' + n.toFixed(5));
+// threadId -> open SSE responses. A Set because the same thread can be open in
+// two tabs, and both should see the same tokens.
+const streamListeners = new Map();
+function emitToThread(threadId, ev) {
+  const set = streamListeners.get(threadId);
+  if (!set?.size) return;                       // nobody watching — free
+  const line = `data: ${JSON.stringify(ev)}\n\n`;
+  for (const res of set) {
+    try { res.write(line); } catch { set.delete(res); }
+  }
+}
 async function sessionStats() {
   try { return await (await fetch(`${PROXY}/session`)).json(); }
   catch { return null; }
@@ -563,7 +579,10 @@ async function handleSlash(task, t) {
       + '  FETCH: <url>                        read a page’s text\n'
       + '  MCP: <url> [| tool | {json}]        list or call MCP tools\n'
       + '  TODO: <lines>                       visible checklist\n'
-      + '  SPAWN / SEND / PING / PEEK          other bots\n\n'
+      + '  SPAWN: <name> | <task>              a NEW subagent (names are unique —\n'
+      + '                                      spawning an existing one sends to it)\n'
+      + '  SEND: <name> | <msg>                more work for an EXISTING subagent\n'
+      + '  PING / PEEK                         reach or inspect another bot\n\n'
       + 'READ, LS, GLOB, GREP, FETCH, PEEK and MCP run CONCURRENTLY when several\n'
       + 'appear in one reply — four files cost one round trip, not four.';
   }
@@ -764,6 +783,26 @@ async function tryDirective(reply, originId) {
   if (spawn) {
     const name = spawn[1].trim();
     const task = spawn[2].trim();
+    // NAMES ARE UNIQUE. This used to call newThread() unconditionally, so a
+    // model asked to "keep spawning" produced FIFTEEN threads all called
+    // tetris-contract, each one a live agent burning paid calls, and the
+    // sidebar became an unusable wall of identical rows. A repeat SPAWN is
+    // almost always the model re-issuing work for the same worker, not asking
+    // for a second identical one — so route it to the existing thread, which
+    // is what SEND already does.
+    const existing = findByName(name);
+    if (existing) {
+      runTurn(existing.id, task).catch(() => {});
+      return `${name} already exists — sent it the task instead of spawning a duplicate.`;
+    }
+    // Storm guard. Fire-and-forget spawning is unbounded by construction: each
+    // child can spawn, and nothing above it is counting.
+    const siblings = [...threads.values()].filter((x) => x.parent === originId).length;
+    if (siblings >= SPAWN_MAX_CHILDREN) {
+      return `Not spawning "${name}": this thread already has ${siblings} subagents `
+        + `(limit ${SPAWN_MAX_CHILDREN}). Reuse one with  SEND: <name> | <task>  — `
+        + `every live subagent costs paid calls.`;
+    }
     const sub = newThread(name, originId);
     runTurn(sub.id, task).catch(() => {}); // fire and forget — runs independently
     return `Spawned ${name} — working on it.`;
@@ -1765,10 +1804,45 @@ const APP_HTML = `<!doctype html>
       addRow(h.who, h.text, h.color || t.color, h.name || t.name,
         h.runId ? { id: h.runId, status: h.runStatus, output: h.runOutput } : undefined, h.images);
     }
-    if (full.status === 'thinking') addRow('bot', '…', t.color, t.name);
+    if (full.status === 'thinking') {
+      addRow('bot', streamBuf || '…', t.color, t.name);
+      // Tag the live bubble so deltas can repaint just this node instead of
+      // re-rendering (and re-fetching) the whole thread on every token.
+      const b = log.querySelector('.row:last-child .bubble');
+      if (b) b.id = 'streamBubble';
+    }
     if (wasNearBottom) log.scrollTop = log.scrollHeight;
   }
+  // --- live token stream ---------------------------------------------------
+  // The server has always been able to stream; /drive just never asked for it,
+  // so a turn showed "…" for its whole duration and then arrived in one lump.
+  let streamBuf = '';
+  let es = null, esId = null;
+  function paintStream() {
+    const b = document.getElementById('streamBubble');
+    if (!b) { render(); return; }
+    // textContent, not markdown: the partial text is frequently mid-fence or
+    // mid-link, and half-parsed markdown flickers. The final render formats it.
+    b.textContent = streamBuf || '…';
+    if (log.scrollHeight - log.scrollTop - log.clientHeight < 140) log.scrollTop = log.scrollHeight;
+  }
+  function connectStream(id) {
+    if (!id || esId === id) return;
+    if (es) es.close();
+    esId = id;
+    streamBuf = '';
+    es = new EventSource('/stream/' + id);   // EventSource reconnects on its own
+    es.onmessage = (e) => {
+      let ev;
+      try { ev = JSON.parse(e.data); } catch { return; }
+      if (ev.type === 'start') { streamBuf = ''; paintStream(); }
+      else if (ev.type === 'delta') { streamBuf += ev.delta || ''; paintStream(); }
+      else if (ev.type === 'final' || ev.type === 'run-pending') { streamBuf = ''; render(); }
+    };
+    es.onerror = () => { /* EventSource retries; the 1.2s poll is the backstop */ };
+  }
   let pendingFiles = [];
   let pendingImages = [];
   const attachChips = document.getElementById('attachChips');
@@ -2011,7 +2085,7 @@ const APP_HTML = `<!doctype html>
     }
   });
-  async function tick() { await loadThreads(); await render(); }
+  async function tick() { connectStream(activeId); await loadThreads(); await render(); }
   tick();
   setInterval(tick, 1200);
@@ -2094,6 +2168,34 @@ const server = http.createServer((req, res) => {
     })();
     return;
   }
+  // LIVE TOKENS. runTurn has always been able to stream — it takes an onEvent
+  // and calls brainStream — but /drive never passed one, so every turn used
+  // the non-streaming brain() and the UI just polled /threads every 1.2s.
+  // The user watched a "…" bubble for the whole generation and then got the
+  // answer in one lump. Same work, all of the latency, none of the feedback.
+  const sse = /^\/stream\/([^/?]+)$/.exec(req.url || '');
+  if (req.method === 'GET' && sse) {
+    const id = sse[1];
+    res.writeHead(200, {
+      'content-type': 'text/event-stream',
+      'cache-control': 'no-cache',
+      connection: 'keep-alive',
+      // Proxies in front of a box (RunPod, nginx) will happily buffer an
+      // event stream into nothing until it ends, which looks exactly like
+      // streaming being broken.
+      'x-accel-buffering': 'no',
+    });
+    res.write(': open\n\n');
+    if (!streamListeners.has(id)) streamListeners.set(id, new Set());
+    streamListeners.get(id).add(res);
+    const ka = setInterval(() => { try { res.write(': ka\n\n'); } catch { /* gone */ } }, 20000);
+    req.on('close', () => {
+      clearInterval(ka);
+      streamListeners.get(id)?.delete(res);
+      if (!streamListeners.get(id)?.size) streamListeners.delete(id);
+    });
+    return;
+  }
   // One source of truth for the composer's autocomplete — a hand-kept menu in
   // the client would drift from what the server actually handles.
   if (req.method === 'GET' && req.url === '/slash-commands') {
@@ -2231,7 +2333,9 @@ const server = http.createServer((req, res) => {
         saveThreads();
         return;
       }
-      runTurn(threadId, task, undefined, images).catch(() => {});
+      // Stream to whoever is watching this thread. emitToThread is a no-op
+      // when nobody is, so a spawned subagent nobody has open costs nothing.
+      runTurn(threadId, task, (ev) => emitToThread(threadId, ev), images).catch(() => {});
     });
     return;
   }

package/package.json CHANGED Viewed

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