openzoo 0.43.6 → 0.43.7

package/lib/grokui.mjs

@@ -245,10 +245,17 @@ function newGroupThread(names) {
 // 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 {
-    let ctx;
+    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 };
@@ -261,7 +268,7 @@ async function bindThread(t) {
       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; saveThreads(); }
+    if (ctx) { t.contextId = ctx; t.boundHistoryCount = t.history.length; saveThreads(); }
   } catch { /* leCore sidecar unreachable — thread still works, just not bound this round */ }
 }
 
@@ -270,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, likely out of funds. Open http://localhost:8402 for this wallet\'s funding addresses (Solana USDC/TOKEN, Base USDC, Robinhood Chain) and current balance, or run `npx openzoo` in a terminal to see the same info. Try again once it\'s funded.)';
+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.6",
+  "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",