npm - openzoo - Versions diffs - 0.43.7 → 0.43.9 - Mend

openzoo 0.43.7 → 0.43.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 (4) hide show

package/lib/grokui.mjs CHANGED Viewed

@@ -529,7 +529,7 @@ const APP_HTML = `<!doctype html>
   .tname { font-size: 14px; font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
   .tprev { font-size: 12px; color: #8e8e93; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
   .tdot { width: 8px; height: 8px; border-radius: 50%; background: #0a84ff; flex: 0 0 8px; }
-  #main { flex: 1; display: flex; flex-direction: column; height: 100vh; }
+  #main { flex: 1; min-width: 0; display: flex; flex-direction: column; height: 100vh; }
   #chatHeader { padding: 14px 20px; border-bottom: 1px solid #1c1c1e; display: flex; align-items: center; gap: 10px;
                 font-weight: 600; }
   #chatHeader .tavatar { width: 26px; height: 26px; border-radius: 7px; font-size: 11px; flex: 0 0 26px; }
@@ -549,21 +549,48 @@ const APP_HTML = `<!doctype html>
   #hud .hember { color: #f28c4d; }
   #hud .hfoot { border-top: 1px solid #333340; margin-top: 10px; padding-top: 8px; color: #999aa8; font-size: 10px; }
   #sidebar, #main { -webkit-app-region: no-drag; }
-  #log { flex: 1; overflow-y: auto; padding: 20px 24px 12px; display: flex; flex-direction: column; gap: 6px;
+  #log { flex: 1; min-width: 0; overflow-y: auto; overflow-x: hidden; padding: 20px 24px 12px;
+         display: flex; flex-direction: column; gap: 6px;
          -webkit-user-select: text; user-select: text; }
   .hdr { align-self: flex-start; display: flex; align-items: center; gap: 6px; margin: 12px 0 4px;
          color: #8e8e93; font-size: 13px; }
   .hdr .avatar { width: 18px; height: 18px; border-radius: 5px; display: flex; align-items: center;
                  justify-content: center; color: #fff; font-size: 9px; font-weight: 700; }
-  .row { display: flex; max-width: 78%; margin: 2px 0; }
+  /* min-width:0 is load-bearing. A flex item defaults to min-width:auto, so it
+     refuses to shrink below its content's intrinsic width — one long
+     unbreakable line (a curl command, a JSON blob) in a <pre> then stretches
+     the row past max-width, widens the whole column, and pushes the header's
+     cost button off-screen. */
+  .row { display: flex; max-width: 78%; min-width: 0; margin: 2px 0; }
   .row.user { align-self: flex-end; }
   .row.bot { align-self: flex-start; }
   .bubble { padding: 11px 16px; border-radius: 20px; white-space: pre-wrap; word-break: break-word;
+            min-width: 0; max-width: 100%; overflow-x: hidden;
             -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%; }
+  .runcard { background: #1c1c1e; border: 1px solid #333; border-radius: 14px; padding: 12px 14px;
+             max-width: 100%; min-width: 0; overflow: hidden; }
   .runcmd { font-family: Menlo, monospace; font-size: 12.5px; color: #ececec; white-space: pre-wrap;
             word-break: break-word; margin-bottom: 8px; }
   .runactions { display: flex; gap: 8px; }
@@ -754,11 +781,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;
@@ -1077,8 +1171,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/namespace.js CHANGED Viewed

@@ -47,8 +47,73 @@ export function namespaceHeaderValue() {
   return cached;
 }
-/** Merge the namespace header into any headers object. */
+/**
+ * PROVE the namespace claim instead of merely asserting it.
+ *
+ * The header above is derived from the PUBLIC key, so on its own it is not
+ * authentication: anyone who knows this wallet's address can recompute the
+ * same value and land in the same sidecar tenant — and since the sidecar gates
+ * context access purely on tenant match, that is the whole door. The gateway
+ * (nsauth.ts) verifies a signature over `openzoo-namespace:<ns>:<ts>` and
+ * derives the tenant from sha256(chain:signer:namespace), which binds the
+ * PROVEN signer in, so another wallet signing an identical label lands
+ * somewhere else.
+ *
+ * Signed with the same Solana key x402 already pays from — no new secret, and
+ * nothing leaves the machine but a public key and a signature. The timestamp
+ * is what bounds replay (the gateway enforces its own window), so it is minted
+ * per call and these headers are deliberately NOT cached.
+ */
+const PKCS8_ED25519_PREFIX = Buffer.from('302e020100300506032b657004220420', 'hex');
+function signNamespace(namespace) {
+  const w = loadOrCreateWallet();
+  const timestamp = String(Date.now());
+  // Node has no raw-ed25519 signer, but it will build one from a PKCS8 DER
+  // wrapper around the 32-byte seed (a Solana secretKey is seed||pubkey).
+  const der = Buffer.concat([PKCS8_ED25519_PREFIX, Buffer.from(w.keypair.secretKey.slice(0, 32))]);
+  const key = crypto.createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
+  const sig = crypto.sign(null, Buffer.from(`openzoo-namespace:${namespace}:${timestamp}`), key);
+  return {
+    'x-openzoo-namespace-sig': base58encode(sig),
+    'x-openzoo-namespace-signer': w.keypair.publicKey.toBase58(),
+    'x-openzoo-namespace-ts': timestamp,
+    'x-openzoo-namespace-chain': 'solana',
+  };
+}
+/** Merge the namespace header — and its proof — into any headers object. */
 export function withNamespace(headers = {}) {
   const ns = namespaceHeaderValue();
-  return ns ? { ...headers, 'x-openzoo-namespace': ns } : headers;
+  if (!ns) return headers;
+  let proof = {};
+  try {
+    proof = signNamespace(ns);
+  } catch {
+    // Unsigned still works while the gateway is in soft launch. Sending the
+    // bare namespace is strictly better than sending nothing: it keeps the
+    // caller in their existing tenant instead of silently relocating every
+    // bound corpus to the shared one.
+  }
+  return { ...headers, 'x-openzoo-namespace': ns, ...proof };
+}
+// Bitcoin-alphabet base58, matching what the gateway's bs58 decode expects.
+// Local rather than a dependency for the same reason lib/x402.js keeps its own.
+const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+function base58encode(bytes) {
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = (carry / 58) | 0;
+    }
+    while (carry > 0) { digits.push(carry % 58); carry = (carry / 58) | 0; }
+  }
+  let out = '';
+  for (const b of bytes) { if (b === 0) out += '1'; else break; } // leading zeros
+  for (let i = digits.length - 1; i >= 0; i--) out += B58[digits[i]];
+  return out;
 }

package/lib/proxy.js CHANGED Viewed

@@ -678,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.7",
+  "version": "0.43.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",