npm - openzoo - Versions diffs - 0.43.6 → 0.43.8 - Mend

openzoo 0.43.6 → 0.43.8

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 (4) hide show

package/lib/grokui.mjs CHANGED Viewed

@@ -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) => {
@@ -545,6 +561,25 @@ const APP_HTML = `<!doctype html>
   .bubble { padding: 11px 16px; border-radius: 20px; white-space: pre-wrap; word-break: break-word;
             -webkit-user-select: text; user-select: text; cursor: text; }
   .bubble a { color: #6ab0ff; text-decoration: underline; cursor: pointer; }
+  /* rendered markdown. The bubble is pre-wrap for plain text, but block
+     elements carry their own spacing — leaving pre-wrap on would add the
+     source newlines back on top of it and double every gap. */
+  .bubble:has(> p, > .md-h, > .md-table, > .md-list, > .md-pre) { white-space: normal; }
+  .bubble > p { margin: 0 0 10px; }
+  .bubble > p:last-child { margin-bottom: 0; }
+  .md-h { margin: 14px 0 8px; font-size: 15px; font-weight: 600; line-height: 1.3; }
+  .md-h:first-child { margin-top: 0; }
+  .md-hr { border: 0; border-top: 1px solid #3a3a3c; margin: 14px 0; }
+  .md-list { margin: 0 0 10px; padding-left: 22px; }
+  .md-list li { margin: 3px 0; }
+  .bubble code { background: #1c1c1e; border: 1px solid #333; border-radius: 5px;
+                 padding: 1px 5px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12.5px; }
+  .md-pre { background: #1c1c1e; border: 1px solid #333; border-radius: 10px; padding: 10px 12px;
+            overflow-x: auto; margin: 0 0 10px; }
+  .md-pre code { background: none; border: 0; padding: 0; font-size: 12.5px; line-height: 1.45; }
+  .md-table { border-collapse: collapse; margin: 0 0 10px; font-size: 13px; display: block; overflow-x: auto; }
+  .md-table th, .md-table td { border: 1px solid #3a3a3c; padding: 5px 10px; text-align: left; vertical-align: top; }
+  .md-table th { background: #1c1c1e; font-weight: 600; }
   .bubble-images { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 8px; }
   .bubble-images img { max-width: 160px; max-height: 160px; border-radius: 12px; display: block; }
   .runcard { background: #1c1c1e; border: 1px solid #333; border-radius: 14px; padding: 12px 14px; max-width: 100%; }
@@ -738,11 +773,78 @@ const APP_HTML = `<!doctype html>
   }
   function escapeHtml(s) { return s.replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c])); }
+  // Inline span-level markdown. Runs AFTER escapeHtml, so every tag below is
+  // one we created — model output can never inject its own.
+  function mdInline(s) {
+    let o = escapeHtml(s);
+    o = o.replace(/\`([^\`]+)\`/g, '<code>$1</code>');
+    o = o.replace(/\\*\\*([^*]+)\\*\\*/g, '<strong>$1</strong>');
+    o = o.replace(/(^|[^*])\\*([^*\\n]+)\\*/g, '$1<em>$2</em>');
+    o = o.replace(/\\[([^\\]]+)\\]\\((https?:[^)\\s]+)\\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>');
+    // bare URLs, but only at a boundary — inside href="..." the preceding
+    // char is a quote, so links we just built are left alone
+    o = o.replace(/(^|[\\s(])(https?:\\/\\/[^\\s<)]+)/g, '$1<a href="$2" target="_blank" rel="noopener">$2</a>');
+    o = o.replace(/@(\\w+)/g, '<span class="mention">\u{1F465} $1</span>');
+    return o;
+  }
+  // Block-level markdown: fenced code, tables, headings, lists. Models answer
+  // in markdown by default, and rendering it as literal "## " and "| --- |"
+  // made every structured answer unreadable.
   function renderMentions(text) {
-    let out = escapeHtml(text);
-    out = out.replace(/(https?:\\/\\/[^\\s<]+)/g, '<a href="$1" target="_blank" rel="noopener">$1</a>');
-    out = out.replace(/@(\\w+)/g, '<span class="mention">\u{1F465} $1</span>');
-    return out;
+    const fences = [];
+    const src = String(text).replace(/\`\`\`([\\w-]*)\\n?([\\s\\S]*?)\`\`\`/g, (m, lang, code) => {
+      fences.push('<pre class="md-pre"><code>' + escapeHtml(code.replace(/\\n$/, '')) + '</code></pre>');
+      return '\\u0000F' + (fences.length - 1) + '\\u0000';
+    });
+    const lines = src.split('\\n');
+    const out = [];
+    let list = null, tbl = null, para = [];
+    const flushPara = () => {
+      if (!para.length) return;
+      out.push('<p>' + para.map(mdInline).join('<br>') + '</p>');
+      para = [];
+    };
+    const closeList = () => { if (list) { out.push('</' + list + '>'); list = null; } };
+    const closeTbl = () => {
+      if (!tbl) return;
+      let h = '<table class="md-table"><thead><tr>'
+        + tbl[0].map((c) => '<th>' + mdInline(c) + '</th>').join('') + '</tr></thead><tbody>';
+      for (const r of tbl.slice(1)) h += '<tr>' + r.map((c) => '<td>' + mdInline(c) + '</td>').join('') + '</tr>';
+      tbl = null;
+      out.push(h + '</tbody></table>');
+    };
+    const cells = (l) => l.replace(/^\\s*\\|/, '').replace(/\\|\\s*$/, '').split('|').map((c) => c.trim());
+    for (const line of lines) {
+      if (/^\\s*\\|.*\\|\\s*$/.test(line)) {                       // table row
+        flushPara(); closeList();
+        if (/^[\\s|:-]+$/.test(line)) continue;                 // |---|---| separator
+        (tbl = tbl || []).push(cells(line));
+        continue;
+      }
+      closeTbl();
+      const h = /^(#{1,4})\\s+(.*)$/.exec(line);
+      if (h) { flushPara(); closeList(); out.push('<h' + (h[1].length + 2) + ' class="md-h">' + mdInline(h[2]) + '</h' + (h[1].length + 2) + '>'); continue; }
+      if (/^\\s*([-*_])\\s*\\1\\s*\\1[\\s\\-*_]*$/.test(line)) { flushPara(); closeList(); out.push('<hr class="md-hr">'); continue; }
+      const ul = /^\\s*[-*]\\s+(.*)$/.exec(line);
+      const ol = /^\\s*\\d+[.)]\\s+(.*)$/.exec(line);
+      if (ul || ol) {
+        flushPara();
+        const want = ul ? 'ul' : 'ol';
+        if (list && list !== want) closeList();
+        if (!list) { list = want; out.push('<' + want + ' class="md-list">'); }
+        out.push('<li>' + mdInline((ul || ol)[1]) + '</li>');
+        continue;
+      }
+      closeList();
+      if (!line.trim()) { flushPara(); continue; }
+      // a fence placeholder is a BLOCK — letting it fall into a paragraph
+      // emits <p><pre>…</pre></p>, which browsers silently split apart
+      if (/^\\u0000F\\d+\\u0000$/.test(line.trim())) { flushPara(); out.push(line.trim()); continue; }
+      para.push(line);
+    }
+    flushPara(); closeList(); closeTbl();
+    return out.join('').replace(/\\u0000F(\\d+)\\u0000/g, (m, i) => fences[Number(i)]);
   }
   let lastSpeaker = null;
@@ -1061,8 +1163,10 @@ const APP_HTML = `<!doctype html>
         const mult = direct / spent;
         // honest either way: >=1x is a real saving vs a naked direct call,
         // <1x means you're currently paying MORE than direct would cost —
-        // don't dress that up as green when it isn't one
-        savedEl.textContent = mult.toFixed(2) + 'x';
+        // don't dress that up as green when it isn't one.
+        // Asking a bound corpus makes this genuinely large (the counterfactual
+        // is shipping the WHOLE corpus), so 2dp would read as noise up there.
+        savedEl.textContent = (mult >= 100 ? Math.round(mult) : mult.toFixed(mult >= 10 ? 1 : 2)) + 'x';
         savedEl.className = mult >= 1 ? 'hlime' : 'hember';
       } else {
         savedEl.textContent = '—';

package/lib/podagent.mjs CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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');
@@ -661,15 +678,22 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           // billedUsd = cogs * markup on a straight-markup call. Close enough
           // on a counterfactual (leCore-discounted) call too since markup is
           // still the ceiling those get capped against.
-          sessionCogs += receipt.billedUsd / MARKUP;
-          // direct: savesVsDirect = direct / billedUsd is on the receipt when
-          // leCore compression engaged (server derives it from real token
-          // counts) — exact, not estimated. When absent, nothing was
-          // compressed, so direct === what was paid (same reasoning as the
-          // like-for-like fix: no compression, no saving, not zero).
-          sessionDirect += typeof receipt.savesVsDirect === 'number'
-            ? receipt.savesVsDirect * receipt.billedUsd
-            : receipt.billedUsd;
+          // Prefer the gateway's own cogsUsd. Deriving it as billedUsd/MARKUP
+          // is only correct on a straight-markup call: under counterfactual
+          // pricing billedUsd is min(direct×discount, markupUsd), so the
+          // division understates cost and overstates margin.
+          sessionCogs += typeof receipt.cogsUsd === 'number'
+            ? receipt.cogsUsd
+            : receipt.billedUsd / MARKUP;
+          // direct = what answering this WITHOUT the zoo would have cost. On an
+          // attach call that is the whole bound corpus, which is why it can be
+          // orders of magnitude above what was billed. directUsd is exact and
+          // always present; savesVsDirect is the same number as a ratio.
+          sessionDirect += typeof receipt.directUsd === 'number'
+            ? receipt.directUsd
+            : typeof receipt.savesVsDirect === 'number'
+              ? receipt.savesVsDirect * receipt.billedUsd
+              : receipt.billedUsd;
           // The public-URL ceiling meters only public-origin spend — your own
           // local calls never eat into it.
           if (viaTunnel) tunnelSpent += receipt.billedUsd;

package/package.json CHANGED Viewed

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