openzoo 0.44.0 → 0.45.0

package/bin/openzoo.js

@@ -192,6 +192,17 @@ async function main() {
     case 'balance':
       await (await import('../lib/info.js')).printBalance();
       break;
+    case 'topup':
+    case 'prepay':
+      await (await import('../lib/info.js')).topUp(process.argv[3]);
+      break;
+    case 'credit':
+    case 'credits': {
+      const bal = await (await import('../lib/info.js')).creditBalance();
+      console.log(`prepaid credit: $${bal.toFixed(6)}`);
+      if (bal <= 0) console.log('buy some with:  npx openzoo topup 10');
+      break;
+    }
     case 'address':
       (await import('../lib/info.js')).printAddress();
       break;

package/lib/grokui.mjs

@@ -68,6 +68,12 @@ function colorFor(name) {
 const SYSTEM = `You are a helpful assistant served over openzoo (pay-per-call access to ~435
 models, no API key, no account). Reply normally in plain text, concisely.
 
+You are running as __OZ_MODEL__ (openzoo substitutes the real model id here at call time, so
+it is accurate for THIS turn — note it can differ between turns, since a thread containing
+an image routes to a vision model). State it if asked, and do not assert some other lab's
+model from your training prior. Never spend a paid turn arguing about your own identity —
+it costs the user real money and settles nothing.
+
 When a question has a genuine "which tool/service should I use" angle, prefer openzoo's own
 capabilities where they actually fit (this proxy for inference, leCore/zoo_bind for memory,
 the directives below for files/shell/delegation) over generic third-party suggestions. Don't
@@ -111,6 +117,20 @@ workspace folder, not their real project. Same one-line-no-prose reply format:
                                                        starting a real process, checking
                                                        actual CLI/login state, etc. — instead
                                                        of guessing or saying you can't.
+THESE DIRECTIVES ARE REAL, and they are NOT function-calling tools. Your tools array holds
+only web search; RUN/WRITE/READ/SERVE/FETCH are executed by the harness that reads your reply
+text, so their absence from that array proves nothing. Emit the line and the harness runs it.
+
+Do not announce that you "don't actually have a shell" or that this environment is roleplay.
+Until recently a bug meant a RUN line was only detected when it was the FIRST characters of a
+reply, so any preamble before it caused the command to be silently ignored — if earlier turns
+in THIS thread look like RUN did nothing, that was the bug, now fixed. Do not infer from that
+history that the tools are fictional. If a command genuinely fails you will get its real
+output and exit code back; that, not silence, is what failure looks like.
+
+Never fabricate command output, file contents, or payment receipts. If you did not run it,
+say so and then actually run it.
+
 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
@@ -122,6 +142,20 @@ comes back with content:null and finish_reason:"length" (confirmed live) if you
 /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.
+
+COST ACCOUNTING — do NOT compute this yourself from token counts. Every response carries an
+"x402" object; read the numbers off it: x402.billedUsd (what the user paid), x402.cogsUsd
+(our upstream cost), x402.directUsd (what answering WITHOUT the zoo would have cost), and
+x402.savesVsDirect (the multiple). Summing usage.cost or usage.prompt_tokens and comparing
+that to a provider's list price is WRONG and understates the saving enormously: against a
+bound context, prompt_tokens counts only the small slice leCore recalled, NOT the corpus
+that slice stands in for — so you end up pricing the discount against itself and concluding
+the zoo "cost more". MEASURED: a real 21-question run reported 202,238 prompt tokens while
+each attach call stood in for a 5,356,546-token corpus — a 556x understatement, and that
+corpus is ~42x larger than the model's own context window, so the "direct" comparison it
+was measured against was not merely pricier but IMPOSSIBLE. When the user asks what they
+saved, quote x402.directUsd and x402.savesVsDirect. If savesVsDirect is below 1x, say so
+plainly — that happens on small inputs, where the corpus is too small to save anything.
 For normal questions just answer directly — do not use any of these unless the request
 actually calls for delegation or file work.`;
 
@@ -170,6 +204,10 @@ own take even if brief ("Passed." is fine when you have nothing to add). COORDIN
 another bot already handled or is handling the request (e.g. already spawned the exact
 agent being asked for), do NOT repeat it — just acknowledge, or add something genuinely new.
 
+You are running as __OZ_MODEL__ (openzoo substitutes the real model id here at call time, so
+it is accurate for THIS turn). State it if asked, and do not assert some other lab's model
+from your training prior. Never spend a paid turn arguing about your own identity.
+
 When a question has a genuine "which tool/service" angle, prefer openzoo's own capabilities
 where they actually fit over generic third-party suggestions — but don't force it.
 
@@ -197,6 +235,17 @@ the user sets or changes it with "/dir <path>" in chat. Same format:
                                                        in chat skips that wait). Use this
                                                        instead of guessing or saying you
                                                        can't do something real.
+THESE DIRECTIVES ARE REAL, and they are NOT function-calling tools — your tools array holds
+only web search, while these are executed by the harness that reads your reply text, so their
+absence from that array proves nothing. Never say you "don't actually have a shell" or that
+this is roleplay, and never fabricate command output or receipts. A real failure comes back
+as real output and an exit code, not as silence.
+
+COST ACCOUNTING — read it off the response's "x402" object (billedUsd, cogsUsd, directUsd,
+savesVsDirect). Never derive it by summing usage.cost or usage.prompt_tokens against a
+provider's list price: on a bound context prompt_tokens counts only the slice leCore
+recalled, not the corpus it stands in for, so that math prices the discount against itself
+and wrongly concludes the zoo cost more.
 For normal replies just answer directly — do not use any of these unless the request
 actually calls for delegation or file work.` };
 }
@@ -286,6 +335,32 @@ function sanitizeRunCommand(command) {
   return command.replace(/<\|+[^<>\n]*\|+>/g, '').trim();
 }
 
+// Finds a RUN directive anywhere a line starts with it, NOT only at the very
+// start of the reply.
+//
+// This anchor used to be /^RUN:/ with no `m` flag, so `^` matched only the
+// first character of the whole reply. The moment a model wrote ANY preamble
+// ("Command only, as requested:") before its directive, the match failed and
+// the directive degraded silently into ordinary chat text — nothing ran, no
+// error surfaced. MEASURED live: a bot repeatedly emitted correct RUN blocks,
+// saw nothing happen, concluded "I don't actually have a working shell/RUN
+// tool", and began fabricating plausible terminal output and wallet receipts
+// instead. The user had to reverse-engineer it themselves and ask for "the cmd
+// without any pretext". Models put preamble before directives constantly, so
+// this failed far more often than it worked.
+//
+// Also tolerates the directive being wrapped in a markdown code fence, which
+// is the other shape models reach for unprompted.
+function parseRun(reply) {
+  const m = /^[ \t>*-]*RUN:[ \t]*([\s\S]+)/m.exec(reply);
+  if (!m) return null;
+  let cmd = m[1];
+  const fenced = /^```[\w-]*\n([\s\S]*?)```/.exec(cmd.trim());
+  if (fenced) cmd = fenced[1];
+  else cmd = cmd.replace(/\n```[\s\S]*$/, ''); // trailing fence + any posttext
+  return sanitizeRunCommand(cmd);
+}
+
 function execCommand(command, cwd) {
   return new Promise((resolve) => {
     exec(command, { cwd, timeout: 120000, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
@@ -413,9 +488,9 @@ async function runTurn(threadId, userText, onEvent, images) {
           ? (await brainStream(msgs, (delta) => onEvent({ type: 'delta', name: m.name, color: m.color, delta }), t.contextId)).trim()
           : (await brain(msgs, t.contextId)).trim();
       } catch (e) { r = `error: ${e.message}`; }
-      const runMatch = /^RUN:\s*([\s\S]+)/.exec(r);
-      if (runMatch) {
-        const command = runMatch[1].trim();
+      const runCmd = parseRun(r);
+      if (runCmd) {
+        const command = runCmd;
         if (t.runMode === 'auto') {
           const output = await execCommand(command, dirFor(t.id));
           const shown = `$ ${command}\n${output}`;
@@ -457,9 +532,9 @@ async function runTurn(threadId, userText, onEvent, images) {
     reply = `error: ${e.message}`;
   }
   t.messages.push({ role: 'assistant', content: reply });
-  const runMatch = /^RUN:\s*([\s\S]+)/.exec(reply);
-  if (runMatch) {
-    const command = runMatch[1].trim();
+  const runCmd = parseRun(reply);
+  if (runCmd) {
+    const command = runCmd;
     if (t.runMode === 'auto') {
       const output = await execCommand(command, dirFor(t.id));
       const shown = `$ ${command}\n${output}`;
@@ -492,7 +567,7 @@ function threadSummary(t) {
   return { id: t.id, name: t.name, color: t.color, parent: t.parent, status: t.status,
     preview: last ? (last.who === 'user' ? last.text : last.text).slice(0, 60) : '',
     createdAt: t.createdAt, lastActivityAt: t.lastActivityAt || t.createdAt,
-    dir: t.dir || WORKSPACE_DIR };
+    dir: t.dir || WORKSPACE_DIR, runMode: t.runMode || 'ask' };
 }
 
 const APP_HTML = `<!doctype html>
@@ -536,7 +611,21 @@ const APP_HTML = `<!doctype html>
   .hname { display: flex; flex-direction: column; gap: 1px; min-width: 0; }
   .hdir { font-weight: 400; font-size: 11px; color: #8e8e93; white-space: nowrap; overflow: hidden;
           text-overflow: ellipsis; max-width: 420px; }
-  #hudBtn { margin-left: auto; }
+  /* Run-mode toggle. The "/mode auto|ask" chat command still works and is
+     still what the bots are told about, but it is invisible until you know it
+     exists — and it controls whether shell commands run without asking, which
+     is exactly the setting a user should be able to SEE at a glance. */
+  #modeToggle { margin-left: auto; display: flex; align-items: center; gap: 0;
+                background: #1c1c1e; border: 1px solid #333340; border-radius: 999px; padding: 2px; }
+  .modebtn { border: 0; background: none; color: #8e8e93; font: inherit; font-size: 11px;
+             font-weight: 600; padding: 4px 11px; border-radius: 999px; cursor: pointer;
+             white-space: nowrap; transition: background .12s, color .12s; }
+  .modebtn:hover { color: #ececec; }
+  .modebtn.on { color: #000; }
+  .modebtn.ask.on { background: #b8f240; }
+  .modebtn.auto.on { background: #f28c4d; }
+  .modebtn:focus-visible { outline: 2px solid #6ab0ff; outline-offset: 2px; }
+  #hudBtn { margin-left: 10px; }
   #chatHeaderId { display: flex; align-items: center; gap: 10px; }
   #hud { position: fixed; top: 40px; right: 14px; width: 250px; background: rgba(14,14,17,.94);
          border: 1px solid #333340; border-radius: 10px; padding: 12px 14px; font: 11px/1.5 Menlo, monospace;
@@ -548,6 +637,13 @@ const APP_HTML = `<!doctype html>
   #hud .hlime { color: #b8f240; }
   #hud .hember { color: #f28c4d; }
   #hud .hfoot { border-top: 1px solid #333340; margin-top: 10px; padding-top: 8px; color: #999aa8; font-size: 10px; }
+  /* Only rendered when the multiple is under 1x — it explains WHY, and what to
+     do about it, instead of leaving a bad-looking number unexplained. */
+  #hud .hhint { display: none; margin-top: 8px; padding: 7px 9px; border-radius: 8px;
+                background: rgba(242,140,77,.10); border: 1px solid rgba(242,140,77,.32);
+                color: #f0c9a8; font-size: 10.5px; line-height: 1.45; }
+  #hud .hhint.show { display: block; }
+  #hud .hhint b { color: #f28c4d; font-weight: 600; }
   #sidebar, #main { -webkit-app-region: no-drag; }
   #log { flex: 1; min-width: 0; overflow-y: auto; overflow-x: hidden; padding: 20px 24px 12px;
          display: flex; flex-direction: column; gap: 6px;
@@ -695,6 +791,12 @@ const APP_HTML = `<!doctype html>
   <div id="main">
     <div id="chatHeader">
       <div id="chatHeaderId"></div>
+      <div id="modeToggle" data-component="run-mode-toggle" role="group" aria-label="Shell command mode">
+        <button class="modebtn ask on" id="modeAsk" data-mode="ask"
+                title="Shell commands pause and wait for your approval">ask</button>
+        <button class="modebtn auto" id="modeAuto" data-mode="auto"
+                title="Shell commands run immediately, with no approval prompt">auto</button>
+      </div>
       <button class="icon-btn" id="hudBtn">◎</button>
     </div>
     <div id="hud">
@@ -704,6 +806,7 @@ const APP_HTML = `<!doctype html>
       <div class="hrow"><span>margin</span><span id="hYouMargin" class="hlime">—</span></div>
       <div class="hrow"><span>direct would be</span><span id="hYouDirect" class="hember">—</span></div>
       <div class="hrow"><span>saved vs. naked calls</span><span id="hYouSaved" class="hlime">—</span></div>
+      <div class="hhint" id="hHint"></div>
       <div class="hfoot" id="hFoot">loading…</div>
     </div>
     <div id="log"></div>
@@ -778,7 +881,29 @@ const APP_HTML = `<!doctype html>
       '<div class="tavatar" style="background:' + t.color + '">' + initials(t.name) + '</div>' +
       '<div class="hname"><div>' + t.name + '</div><div class="hdir" title="' + escapeHtml(t.dir || '') +
       '">' + escapeHtml(t.dir || '') + ' · type /dir &lt;path&gt; to change</div></div>';
+    setModeButtons(t.runMode || 'ask');
+  }
+
+  // The toggle reflects the SERVER's value rather than local state — the mode
+  // is per-thread and also settable by typing "/mode auto", so anything that
+  // tracked it client-side would drift the moment either path was used.
+  function setModeButtons(mode) {
+    document.getElementById('modeAsk').className = 'modebtn ask' + (mode === 'ask' ? ' on' : '');
+    document.getElementById('modeAuto').className = 'modebtn auto' + (mode === 'auto' ? ' on' : '');
+  }
+
+  async function setMode(mode) {
+    if (!activeId) return;
+    setModeButtons(mode); // optimistic: the click should feel instant
+    // Reuses the SAME "/mode" path the chat command takes, so there is one
+    // implementation of the rule rather than a second one that can disagree.
+    await fetch('/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ threadId: activeId, task: '/mode ' + mode }) });
+    await loadThreads(); // refresh runMode + the confirmation line /mode appends
+    await render();
   }
+  document.getElementById('modeAsk').addEventListener('click', () => setMode('ask'));
+  document.getElementById('modeAuto').addEventListener('click', () => setMode('auto'));
 
   function escapeHtml(s) { return s.replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c])); }
   // Inline span-level markdown. Runs AFTER escapeHtml, so every tag below is
@@ -1167,6 +1292,7 @@ const APP_HTML = `<!doctype html>
       document.getElementById('hYouMargin').textContent = margin;
       document.getElementById('hYouDirect').textContent = usd(direct);
       const savedEl = document.getElementById('hYouSaved');
+      const hintEl = document.getElementById('hHint');
       if (spent > 0) {
         const mult = direct / spent;
         // honest either way: >=1x is a real saving vs a naked direct call,
@@ -1176,8 +1302,19 @@ const APP_HTML = `<!doctype html>
         // 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';
+        // Under 1x is real, but on its own it just reads as "this is a bad
+        // deal". It isn't a verdict on the product — it's a verdict on how
+        // little you've given it to work against: you're billed on the tokens
+        // actually forwarded, while "direct" is the cost of shipping the whole
+        // corpus. The forwarded slice grows barely at all as the corpus grows,
+        // so the ratio climbs with corpus size. Say that, and say what to do.
+        hintEl.className = mult >= 1 ? 'hhint' : 'hhint show';
+        hintEl.innerHTML = '<b>feed it more.</b> you\\'re billed on the slice actually sent, '
+          + 'not the corpus — so the more you bind, the further ahead this gets. '
+          + 'small inputs cost more than sending them straight.';
       } else {
         savedEl.textContent = '—';
+        hintEl.className = 'hhint';
       }
       document.getElementById('hFoot').textContent = (you.paidCalls || 0) + ' paid calls this session';
     } catch (e) {

package/lib/info.js

@@ -73,3 +73,57 @@ export async function printBalance() {
     console.log(`        or USDC on Base to ${evmAddress}`);
   }
 }
+
+/**
+ * PREPAY. Buys gateway credit in ONE settlement so later calls skip the
+ * per-call payment round trip entirely.
+ *
+ * That round trip is where the latency lives, not the model: MEASURED against
+ * the live gateway, a 402 challenge comes back in 0.12s while a full paid call
+ * takes 9-37s end to end. The gateway already applies credit automatically
+ * whenever a balance covers the quote — nothing could BUY it until now.
+ *
+ * Credit is keyed by the signed namespace, so it belongs to this wallet and
+ * cannot be spent by anyone else.
+ */
+export async function topUp(usdArg) {
+  const usd = Number(usdArg);
+  if (!Number.isFinite(usd) || usd < 1 || usd > 500) {
+    throw new Error('usage: openzoo topup <usd>   (1-500)');
+  }
+  const { PayClient } = await import('./pay.js');
+  const client = new PayClient();
+  const url = `${config.apiBase}/v1/credits/topup`;
+
+  const before = await creditBalance();
+  console.log(`credit before: $${before.toFixed(6)}`);
+  console.log(`buying $${usd.toFixed(2)} of credit — one on-chain settlement...`);
+
+  const { response, paid } = await client.fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ usd }),
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(`topup failed (HTTP ${response.status}): ${body.error || body.detail || 'unknown'}`);
+  }
+  console.log('');
+  console.log(`credited:  $${Number(body.creditedUsd ?? usd).toFixed(2)}${paid ? '' : ' (from existing credit)'}`);
+  console.log(`balance:   $${Number(body.balanceUsd ?? 0).toFixed(6)}`);
+  if (body.tx) console.log(`tx:        ${body.tx}`);
+  console.log('');
+  console.log('calls now settle against this balance instead of paying on-chain each time.');
+}
+
+/** Current prepaid credit for this wallet's namespace. */
+export async function creditBalance() {
+  const { withNamespace } = await import('./namespace.js');
+  try {
+    const r = await fetch(`${config.apiBase}/v1/credits`, { headers: withNamespace({}) });
+    const j = await r.json();
+    return Number(j.balanceUsd) || 0;
+  } catch {
+    return 0;
+  }
+}

package/lib/podagent.mjs

@@ -27,7 +27,7 @@ const PORTS = (process.env.OZ_AGENT_PORTS || '1337,6080,1340,6081')
   .split(',').map((s) => Number(s.trim())).filter(Boolean);
 const LOG = process.env.OZ_AGENT_LOG || '/var/log/openzoo/agent.jsonl';
 export const PROXY = process.env.OZ_PROXY || 'http://127.0.0.1:8402/v1';
-const MODEL = process.env.OZ_BRAIN_MODEL || 'deepseek/deepseek-v4-pro-0813';
+export const MODEL = process.env.OZ_BRAIN_MODEL || 'deepseek/deepseek-v4-pro-0813';
 const MAX_STEPS = Number(process.env.OZ_MAX_STEPS || 10);
 
 // Matches the Grok Bot chat surface itself (dark canvas, right-aligned grey
@@ -184,8 +184,32 @@ 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';
+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
+// thread drops back to the cheaper text model.
+const VISION_WINDOW = Number(process.env.OZ_VISION_WINDOW || 8);
+
+// This used to scan the WHOLE history, so a single pasted image pinned every
+// later turn in that thread to the vision model forever — permanently, and
+// invisibly, at 1.5x input and 2.5x output (claude-sonnet-5 $6/$30 per M vs
+// deepseek-v4-pro $3.96/$11.88, priced live off /v1/models). A thread where
+// someone shared one screenshot an hour ago was still paying vision rates for
+// pure text chat.
 function hasImages(messages) {
-  return messages.some((m) => Array.isArray(m.content) && m.content.some((c) => c?.type === 'image_url'));
+  return messages.slice(-VISION_WINDOW).some(msgHasImage);
+}
+
+// When we DO fall back to the text model, the old image_url blocks must not go
+// with it — a non-vision model either errors on them or silently ignores them
+// while still being billed for the payload. Replace them with a marker so the
+// model knows an image was there rather than seeing a gap it might deny.
+function stripImages(messages) {
+  return messages.map((m) => {
+    if (!msgHasImage(m)) return m;
+    const text = m.content.filter((c) => c?.type === 'text').map((c) => c.text).join(' ').trim();
+    return { ...m, content: `${text}${text ? ' ' : ''}[image sent earlier, no longer in context]` };
+  });
 }
 
 // A non-ok response with no usable content used to silently become '', which
@@ -243,13 +267,29 @@ async function postChat(body, contextId) {
 
 /** One openzoo chat turn. Paid per call by the box's own wallet via the local
  *  proxy — no key, no account. */
+// Which model actually serves a turn is decided HERE, not by the caller: a
+// thread carrying an image routes to VISION_MODEL. A system prompt written
+// once at thread creation therefore cannot name it correctly, and a bot left
+// to guess asserts whatever its training prior says — MEASURED: a Claude-served
+// turn insisted it was Claude while the app's default is DeepSeek, and burned
+// several paid turns arguing. So the prompt carries a placeholder and the real
+// id is substituted at call time, per turn.
+function withModelId(messages, model) {
+  return messages.map((m) => (m.role === 'system' && typeof m.content === 'string' && m.content.includes('__OZ_MODEL__')
+    ? { ...m, content: m.content.replaceAll('__OZ_MODEL__', model) }
+    : m));
+}
+
 export async function brain(messages, contextId) {
   // 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 vision = hasImages(messages);
+  const model = vision ? VISION_MODEL : MODEL;
+  messages = vision ? messages : stripImages(messages);
   const r = await postChat(
-    { model: hasImages(messages) ? VISION_MODEL : MODEL, max_tokens: 4096, messages, plugins: [{ id: 'web' }] },
+    { model, max_tokens: 4096, messages: withModelId(messages, model), plugins: [{ id: 'web' }] },
     contextId,
   );
   const j = await r.json().catch(() => ({}));
@@ -261,8 +301,11 @@ export async function brain(messages, contextId) {
  *  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 vision = hasImages(messages);
+  const model = vision ? VISION_MODEL : MODEL;
+  messages = vision ? messages : stripImages(messages);
   const r = await postChat(
-    { model: hasImages(messages) ? VISION_MODEL : MODEL, max_tokens: 4096, messages, plugins: [{ id: 'web' }], stream: true },
+    { model, max_tokens: 4096, messages: withModelId(messages, model), plugins: [{ id: 'web' }], stream: true },
     contextId,
   );
   if (!r.ok || !r.body) {

package/lib/proxy.js

@@ -779,6 +779,34 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     server.listen(config.port, bindHost, resolve);
   });
 
+  // AUTO-PREPAY. Paying on-chain per call is where the latency lives: the
+  // gateway answers its 402 challenge in ~0.12s while a full settled call
+  // MEASURED 9-37s end to end. Credit is applied automatically server-side
+  // whenever a balance covers the quote, so buying it once makes every later
+  // call skip verify+settle entirely.
+  //
+  // Runs in the background — never block the listener on a payment — and only
+  // when this wallet actually has funds, so a fresh/empty wallet is untouched.
+  // Opt out with OPENZOO_NO_AUTOTOPUP=1; size it with OPENZOO_AUTOTOPUP_USD.
+  if (!process.env.OPENZOO_NO_AUTOTOPUP) {
+    (async () => {
+      try {
+        const { creditBalance, topUp } = await import('./info.js');
+        const have = await creditBalance();
+        const want = Number(process.env.OPENZOO_AUTOTOPUP_USD || 5);
+        // Only top up when nearly dry, so restarting the proxy does not keep
+        // buying credit on top of a healthy balance.
+        if (have >= Math.min(1, want)) return;
+        say(`prepaid credit $${have.toFixed(4)} — topping up $${want} so calls stop settling on-chain each time...`);
+        await topUp(want);
+      } catch (e) {
+        // A wallet with no funds, or a gateway that refuses, must never stop
+        // the proxy from serving: calls just fall back to paying per call.
+        say(`auto top-up skipped: ${String(e.message || e).slice(0, 120)}`);
+      }
+    })();
+  }
+
   if (!silent) {
     // VERSION IN THE BANNER, deliberately. `npx openzoo` can serve a STALE
     // cached copy — npx reuses a cache entry that matches the bare spec, so a

package/lib/x402.js

@@ -1,4 +1,5 @@
 import {
+  ComputeBudgetProgram,
   Connection,
   PublicKey,
   Transaction,
@@ -153,6 +154,22 @@ export function buildPayment({ accept, decimals, programId, recentBlockhash, key
   );
 
   const tx = new Transaction({ feePayer, recentBlockhash });
+  // UNIQUENESS. Everything else here is a pure function of (amount, accounts,
+  // decimals, blockhash), so two calls quoting the same price inside one
+  // blockhash window build a BYTE-IDENTICAL transaction — same signature, so
+  // the second is a duplicate and the facilitator reports it as
+  // `settle {success:false, "Simulation failed ... Logs: []"}`. Concurrent
+  // callers hit this constantly (a 10-worker run produced 8 failed_settle in
+  // one window) and each failure costs a full retry, which is most of the
+  // per-call latency.
+  //
+  // A random compute-unit LIMIT makes each message distinct at no cost: unlike
+  // setComputeUnitPrice it adds no priority fee, and an over-estimate is free
+  // — it only caps execution. The range sits far above what a transferChecked
+  // plus any funding preInstructions actually consume.
+  tx.add(ComputeBudgetProgram.setComputeUnitLimit({
+    units: 300_000 + Math.floor(Math.random() * 200_000),
+  }));
   for (const pre of preInstructions) tx.add(pre); // internal funding plumbing, if any
   tx.add(ix);
   tx.partialSign(keypair); // owner signs; feePayer slot left empty for the facilitator

package/package.json

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