openzoo 0.43.5 → 0.43.7

package/lib/grokui.mjs

@@ -115,7 +115,13 @@ Via RUN you can also make YOUR OWN paid openzoo calls — POST to
 http://localhost:8402/v1/chat/completions (or /v1/hrr/bind) with curl/python/etc. Auth is
 "Authorization: Bearer sk-openzoo" — any string works, x402 pays per call, not the key. Do
 NOT tell the user you "can't fire the paid calls" or need "their client's bearer key" —
-that's wrong, you can make these calls yourself via RUN.
+that's wrong, you can make these calls yourself via RUN. When you do, set max_tokens
+generously (1000+, not 50) — a reasoning model can burn its ENTIRE budget on internal
+reasoning before writing any visible answer, especially against a large bound corpus, and
+comes back with content:null and finish_reason:"length" (confirmed live) if you starve it.
+/v1/hrr/bind also caps around ~8MB per request after JSON-escaping — chunk large corpora
+(e.g. 512KB raw per request) and pass the PREVIOUS chunk's context_id on each next request
+to append to the same bound context, rather than one giant request that silently fails partway.
 For normal questions just answer directly — do not use any of these unless the request
 actually calls for delegation or file work.`;
 
@@ -230,17 +236,39 @@ function newGroupThread(names) {
 // turn's brain()/brainStream() call picks up t.contextId once it lands, via
 // the X-HRR-Context header, so retrieval is real and automatic, not a prompt
 // claim about a mechanism that doesn't exist.
+// Chunked, not one shot: a single request over ~8MB (post JSON-escaping)
+// gets rejected, so a large/growing thread's bind would silently fail past
+// whatever point it crossed that line — confirmed live by a bot's own RUN
+// diagnostic ("Failed at chunk 2 — JSON escaping pushed a 3MB chunk over the
+// ~8MB request limit"). 512KB raw per request leaves wide margin. Each
+// chunk after the first carries the PREVIOUS chunk's context_id so the
+// sidecar appends to the same bound context instead of starting fresh.
+const BIND_CHUNK_BYTES = 512 * 1024;
 async function bindThread(t) {
-  const corpus = t.history.map((h) => (h.who === 'user' ? 'you' : (h.name || t.name)) + ': ' + h.text).join('\n');
-  if (!corpus.trim()) return;
+  // Only bind what's NEW since the last successful bind, continuing the
+  // existing context_id — previously this rebuilt and re-sent the WHOLE
+  // history from scratch every turn (discarding t.contextId), so bind cost
+  // grew with total conversation length and was re-paid on every message.
+  const from = t.boundHistoryCount || 0;
+  const delta = t.history.slice(from);
+  if (!delta.length) return;
+  const corpus = delta.map((h) => (h.who === 'user' ? 'you' : (h.name || t.name)) + ': ' + h.text).join('\n');
+  if (!corpus.trim()) { t.boundHistoryCount = t.history.length; return; }
   try {
-    const r = await fetch(`${PROXY}/hrr/bind`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ corpus }),
-    });
-    const j = await r.json().catch(() => ({}));
-    if (j?.context_id) { t.contextId = j.context_id; saveThreads(); }
+    let ctx = t.contextId;
+    for (let i = 0; i < corpus.length; i += BIND_CHUNK_BYTES) {
+      const part = corpus.slice(i, i + BIND_CHUNK_BYTES);
+      const body = ctx ? { corpus: part, context_id: ctx } : { corpus: part };
+      const r = await fetch(`${PROXY}/hrr/bind`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const j = await r.json().catch(() => ({}));
+      if (j?.context_id) ctx = j.context_id;
+      else break; // this chunk failed — stop, keep whatever bound so far rather than lose it all
+    }
+    if (ctx) { t.contextId = ctx; t.boundHistoryCount = t.history.length; saveThreads(); }
   } catch { /* leCore sidecar unreachable — thread still works, just not bound this round */ }
 }
 
@@ -249,6 +277,15 @@ async function bindThread(t) {
 // anything runs; 'auto' mode (set via "/mode auto" in chat) runs immediately.
 // Either way this is not sandboxed like WRITE/READ — it can do anything the
 // signed-in user's shell can — so 'ask' is the default, not 'auto'.
+// Some underlying models were tuned with native tool-calling and leak their
+// own control tokens (e.g. DeepSeek's "<||DSML||tool_calls>") as trailing
+// plain text when this harness doesn't wire a `tools` schema. Left in, that
+// text becomes part of the shell command string and breaks /bin/sh's parser
+// ("unexpected token `newline'") — confirmed live. Strip it before exec.
+function sanitizeRunCommand(command) {
+  return command.replace(/<\|+[^<>\n]*\|+>/g, '').trim();
+}
+
 function execCommand(command, cwd) {
   return new Promise((resolve) => {
     exec(command, { cwd, timeout: 120000, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {

package/lib/podagent.mjs

@@ -191,53 +191,84 @@ function hasImages(messages) {
 // A non-ok response with no usable content used to silently become '', which
 // grokui.mjs then renders as a generic "(no response)" — indistinguishable
 // from a model that genuinely had nothing to say. Callers should know WHY.
-function httpErrorNote(status) {
-  if (status === 402) return '(payment failed — the wallet\'s x402 retry gave up after HTTP 402. Try again; if it keeps happening, check the wallet balance/RPC.)';
+async function httpErrorNote(status) {
+  if (status === 402) {
+    // print the ACTUAL address in the chat, not a link elsewhere to go find it.
+    // fetch() does NOT reject on 4xx/5xx, so an older proxy without /wallet
+    // returns an error body that parses fine and yields "undefined" fields —
+    // check r.ok and the fields themselves before interpolating them.
+    try {
+      const r = await fetch(`${PROXY}/wallet`);
+      const w = r.ok ? await r.json() : null;
+      if (w?.funding && w?.evm) {
+        // funded === false is the genuinely-empty case; funded === true after
+        // the retries above means the rail/quote failed, not the balance
+        if (w.funded === false) {
+          return `(payment failed — HTTP 402, the wallet is empty. ${w.funding}. EVM (Base/Robinhood): ${w.evm}.)`;
+        }
+        return `(payment failed — HTTP 402 after ${PAYMENT_RETRIES} retries, though the wallet holds ${w.balances || 'a balance'}. Send it again; if it keeps failing the quoted asset may not be convertible right now. Fund with: ${w.funding})`;
+      }
+    } catch { /* proxy unreachable — fall through to the generic note */ }
+    return `(payment failed — HTTP 402 after ${PAYMENT_RETRIES} retries. Run \`npx openzoo\` to check wallet balances.)`;
+  }
   if (status === 429) return '(rate limited — HTTP 429, try again in a moment)';
   if (status >= 500) return `(upstream error — HTTP ${status}, try again)`;
   return status ? `(request failed — HTTP ${status})` : '';
 }
 
+// A 402 that reached this layer means the proxy's own x402 retry gave up on
+// this attempt, but the NEXT attempt usually settles (measured: same wallet,
+// same rail, second call pays fine). Surfacing that as a chat message makes
+// the user do the retry by hand — so do it here instead.
+const PAYMENT_RETRIES = 3;
+async function postChat(body, contextId) {
+  let r;
+  for (let attempt = 0; attempt <= PAYMENT_RETRIES; attempt++) {
+    r = await fetch(`${PROXY}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json', authorization: 'Bearer sk-openzoo',
+        // real leCore memory for this thread, bound via POST /v1/hrr/bind — NOT
+        // a fabricated mechanism. Retrieval runs automatically once this header
+        // is set; nothing more for the model to invent or explain.
+        ...(contextId ? { 'x-hrr-context': contextId } : {}),
+      },
+      body: JSON.stringify(body),
+    });
+    if (r.status !== 402 || attempt === PAYMENT_RETRIES) return r;
+    await new Promise((res) => setTimeout(res, 800 * (attempt + 1)));
+  }
+  return r;
+}
+
 /** One openzoo chat turn. Paid per call by the box's own wallet via the local
  *  proxy — no key, no account. */
 export async function brain(messages, contextId) {
-  const r = await fetch(`${PROXY}/chat/completions`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json', authorization: 'Bearer sk-openzoo',
-      // real leCore memory for this thread, bound via POST /v1/hrr/bind — NOT
-      // a fabricated mechanism. Retrieval runs automatically once this header
-      // is set; nothing more for the model to invent or explain.
-      ...(contextId ? { 'x-hrr-context': contextId } : {}),
-    },
-    // explicit, not relying on the gateway's "inject when caller said nothing"
-    // default — an explicit plugins array is always respected as-is, so this
-    // guarantees every bot on every model actually has web search, instead of
-    // hoping nothing upstream (local proxy, gateway config) already set one.
-    // 900 was cutting real (especially web-search-backed) answers off mid-sentence
-    body: JSON.stringify({ model: hasImages(messages) ? VISION_MODEL : MODEL, max_tokens: 4096, messages, plugins: [{ id: 'web' }] }),
-  });
+  // explicit plugins, not relying on the gateway's "inject when caller said
+  // nothing" default — an explicit array is always respected as-is, so every
+  // bot on every model actually has web search. max_tokens 900 was cutting
+  // real (especially web-search-backed) answers off mid-sentence.
+  const r = await postChat(
+    { model: hasImages(messages) ? VISION_MODEL : MODEL, max_tokens: 4096, messages, plugins: [{ id: 'web' }] },
+    contextId,
+  );
   const j = await r.json().catch(() => ({}));
   const content = j?.choices?.[0]?.message?.content;
-  return content || (r.ok ? '' : httpErrorNote(r.status));
+  return content || (r.ok ? '' : await httpErrorNote(r.status));
 }
 
 /** 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) {
-  const r = await fetch(`${PROXY}/chat/completions`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json', authorization: 'Bearer sk-openzoo',
-      ...(contextId ? { 'x-hrr-context': contextId } : {}),
-    },
-    body: JSON.stringify({ model: hasImages(messages) ? VISION_MODEL : MODEL, max_tokens: 4096, messages, plugins: [{ id: 'web' }], stream: true }),
-  });
+  const r = await postChat(
+    { model: hasImages(messages) ? VISION_MODEL : MODEL, max_tokens: 4096, messages, plugins: [{ id: 'web' }], stream: true },
+    contextId,
+  );
   if (!r.ok || !r.body) {
     // fall back to the non-streaming path rather than fail outright
     const content = await r.json().then((j) => j?.choices?.[0]?.message?.content).catch(() => undefined);
-    const text = content || (r.ok ? '' : httpErrorNote(r.status));
+    const text = content || (r.ok ? '' : await httpErrorNote(r.status));
     if (text) onDelta(text);
     return text;
   }

package/lib/proxy.js

@@ -355,6 +355,23 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       return;
     }
 
+    // Public addresses only — never the private key. Exists so a caller (the
+    // grokui error path, in particular) can print REAL funding instructions
+    // inline instead of telling the user to go look somewhere else.
+    if (req.method === 'GET' && (req.url || '').split('?')[0] === '/v1/wallet') {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({
+        solana: client.address,
+        evm: client.evmAddress,
+        funding: fundingLine(client.address),
+        // from the same background poll the startup/refresh lines use, so a
+        // caller can tell a genuinely empty wallet from a transient 402
+        balances: balanceLine(lastSnap || []) || null,
+        funded: (lastSnap || []).some((b) => b.ui > 0),
+      }));
+      return;
+    }
+
     if ((req.url || '').split('?')[0] === '/mcp') {
       try {
         const { handleMcpRequest } = await import('./mcphttp.js');

package/package.json

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