openzoo 0.48.11 → 0.48.13

package/lib/grokui.mjs

@@ -236,9 +236,23 @@ function loadThreads() {
 
 function newThread(name, parent, members) {
   const id = randomUUID();
+  // A subagent INHERITS its parent's run mode, working directory and model.
+  //
+  // runMode especially: children defaulted to 'ask', so a bot spawned in auto
+  // mode emitted a RUN, the harness parked it awaiting approval, and nobody
+  // was watching that thread to approve it. The subagent looked "stuck
+  // typing…" forever while the parent reported it as working. Spawning from
+  // auto and landing in ask is never what the user meant.
+  //
+  // dir matters just as much — a child that defaults elsewhere cannot see the
+  // files the parent was sent to work on.
+  const p = parent ? threads.get(parent) : null;
   const t = { id, name, color: members ? members[0].color : colorFor(name), parent: parent || null,
     messages: members ? null : [{ role: 'system', content: SYSTEM }],
-    members: members || null, history: [], status: 'idle', createdAt: Date.now(), lastActivityAt: Date.now() };
+    members: members || null, history: [], status: 'idle', createdAt: Date.now(), lastActivityAt: Date.now(),
+    ...(p?.runMode ? { runMode: p.runMode } : {}),
+    ...(p?.dir ? { dir: p.dir } : {}),
+    ...(p?.model ? { model: p.model } : {}) };
   threads.set(id, t);
   saveThreads();
   return t;
@@ -546,6 +560,27 @@ const SLASH_COMMANDS = [
 
 const usd = (n) => (n >= 0.01 || n === 0 ? '$' + n.toFixed(2) : '$' + n.toFixed(5));
 
+// BIND, DON'T PASTE — the whole point of the thing this runs on.
+//
+// Directive results get fed back to the model as a user message, verbatim. A
+// GLOB over a 670-part upload, an LS of a big tree or an MCP tool dump is
+// thousands of tokens, and in an auto chain it is re-sent on EVERY subsequent
+// hop as conversation history: the window grows quadratically and the user
+// pays for it each time. Meanwhile the full text is already going into
+// t.history, which bindThread pushes into the thread's leCore context — so
+// the model can recall any of it on demand.
+//
+// So: feed back the head and tail (where the answer nearly always is) and say
+// plainly that the middle is recallable rather than lost.
+const FEEDBACK_MAX = Number(process.env.OZ_FEEDBACK_MAX || 3000);
+function condense(label, text) {
+  const s = String(text ?? '');
+  if (s.length <= FEEDBACK_MAX) return `${label}\n${s}`;
+  const head = s.slice(0, Math.floor(FEEDBACK_MAX * 0.7));
+  const tail = s.slice(-Math.floor(FEEDBACK_MAX * 0.3));
+  return `${label}\n${head}\n\n…[${s.length - head.length - tail.length} chars elided — the FULL output is bound to this thread's holographic context; ask for any part of it and it will be recalled]…\n\n${tail}`;
+}
+
 // 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();
@@ -1274,12 +1309,19 @@ async function runTurn(threadId, userText, onEvent, images) {
       t.lastActivityAt = Date.now();
       saveThreads();
       if (t.autoSteps < AUTO_MAX_STEPS) {
-        runTurn(threadId, `(command output)\n${output}`, onEvent).catch(() => {});
+        // BIND BEFORE CHAINING. bindThread only ran at the end of a normal
+        // turn, and both auto paths return before reaching it — so in auto
+        // mode nothing was ever bound, exactly when the agent produces the
+        // most material (command output, GLOB results, MCP tool lists). The
+        // holographic context stopped growing precisely when it mattered.
+        bindThread(t).catch(() => {});
+        runTurn(threadId, condense('(command output)', output), onEvent).catch(() => {});
       } else {
         const note = `(auto-run stopped after ${AUTO_MAX_STEPS} chained commands — say "continue" to keep going)`;
         t.history.push({ who: 'bot', text: note });
         onEvent?.({ type: 'final', name: t.name, color: t.color, text: note });
         saveThreads();
+        bindThread(t).catch(() => {});
       }
       return;
     }
@@ -1316,7 +1358,8 @@ async function runTurn(threadId, userText, onEvent, images) {
   if (t.runMode === 'auto' && ack !== null && ack !== undefined) {
     t.autoSteps = (t.autoSteps || 0) + 1;
     if (t.autoSteps < AUTO_MAX_STEPS) {
-      runTurn(threadId, `(directive result)\n${ack}`, onEvent).catch(() => {});
+      bindThread(t).catch(() => {});   // bind every hop, not just the last one
+      runTurn(threadId, condense('(directive result)', ack), onEvent).catch(() => {});
       return;
     }
     const note = `(auto stopped after ${AUTO_MAX_STEPS} steps — say "continue" to keep going)`;

package/lib/podagent.mjs

@@ -184,6 +184,10 @@ function execFrame(command, cwd = '/tmp') {
 // on a text-only model silently ignoring pasted images, any message with
 // multimodal (image_url) content routes to a model KNOWN to support vision.
 const VISION_MODEL = process.env.OZ_VISION_MODEL || 'anthropic/claude-sonnet-5';
+// Output budget per turn. Reasoning models spend this on their chain of
+// thought BEFORE emitting any content, so a budget that is merely "enough for
+// the answer" produces no answer at all on a hard prompt.
+const MAX_TOKENS = Number(process.env.OZ_MAX_TOKENS || 4096);
 const msgHasImage = (m) => Array.isArray(m.content) && m.content.some((c) => c?.type === 'image_url');
 
 // How far back an image still counts as "being discussed". Beyond this the
@@ -305,12 +309,13 @@ export async function brain(messages, contextId, modelOverride) {
 /** Same call, but streamed — invokes onDelta(text) as tokens arrive (for a
  *  live-typing UI) and resolves with the full accumulated text at the end, so
  *  callers that need to parse a directive out of the complete reply still can. */
-export async function brainStream(messages, onDelta, contextId, modelOverride) {
+export async function brainStream(messages, onDelta, contextId, modelOverride, maxTokens) {
   const vision = hasImages(messages);
   const model = vision ? VISION_MODEL : (modelOverride || MODEL);
   messages = vision ? messages : stripImages(messages);
+  const budget = maxTokens || MAX_TOKENS;
   const r = await postChat(
-    { model, max_tokens: 4096, messages: withModelId(messages, model), plugins: [{ id: 'web' }], stream: true },
+    { model, max_tokens: budget, messages: withModelId(messages, model), plugins: [{ id: 'web' }], stream: true },
     contextId,
   );
   if (!r.ok || !r.body) {
@@ -322,7 +327,7 @@ export async function brainStream(messages, onDelta, contextId, modelOverride) {
   }
   const reader = r.body.getReader();
   const decoder = new TextDecoder();
-  let buf = '', full = '';
+  let buf = '', full = '', reasonedChars = 0;
   for (;;) {
     const { value, done } = await reader.read();
     if (done) break;
@@ -335,11 +340,24 @@ export async function brainStream(messages, onDelta, contextId, modelOverride) {
       const payload = s.slice(5).trim();
       if (payload === '[DONE]') continue;
       try {
-        const delta = JSON.parse(payload)?.choices?.[0]?.delta?.content;
-        if (delta) { full += delta; onDelta(delta); }
+        const d = JSON.parse(payload)?.choices?.[0]?.delta;
+        if (d?.content) { full += d.content; onDelta(d.content); }
+        // Reasoning models emit their chain of thought on a SEPARATE field and
+        // only then start producing content. Count it — not to show it, but to
+        // tell "the model said nothing" apart from "the model spent its whole
+        // budget thinking and got cut off".
+        else if (d?.reasoning || d?.reasoning_content) reasonedChars += (d.reasoning || d.reasoning_content).length;
       } catch { /* keep-alive line or partial JSON — ignore */ }
     }
   }
+
+  // EMPTY CONTENT AFTER HEAVY REASONING is a truncation, not an answer. It
+  // surfaced in the UI as a bare "(no response)" bubble that cost the user a
+  // turn and explained nothing — on exactly the long, complex prompts where a
+  // reasoning model thinks the most. Retry ONCE with a bigger budget.
+  if (!full && reasonedChars > 0 && !maxTokens) {
+    return brainStream(messages, onDelta, contextId, modelOverride, budget * 4);
+  }
   return full;
 }
 

package/package.json

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