openzoo 0.45.0 → 0.46.0

package/lib/grokui.mjs

@@ -293,6 +293,8 @@ function newGroupThread(names) {
 // 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;
+// Chained auto-run commands per user message. Each hop is a paid call.
+const AUTO_MAX_STEPS = Number(process.env.OZ_AUTO_MAX_STEPS || 8);
 async function bindThread(t) {
   // Only bind what's NEW since the last successful bind, continuing the
   // existing context_id — previously this rebuilt and re-sent the WHOLE
@@ -520,6 +522,7 @@ async function runTurn(threadId, userText, onEvent, images) {
     bindThread(t).catch(() => {});
     return;
   }
+  if (!/^\(command output\)/.test(userText)) t.autoSteps = 0;
   t.messages.push({ role: 'user', content: contentFor(userText, images) });
   t.status = 'thinking';
   let reply = '';
@@ -538,10 +541,31 @@ async function runTurn(threadId, userText, onEvent, images) {
     if (t.runMode === 'auto') {
       const output = await execCommand(command, dirFor(t.id));
       const shown = `$ ${command}\n${output}`;
-      t.messages.push({ role: 'user', content: `output:\n${output}` });
       t.history.push({ who: 'bot', text: shown });
       onEvent?.({ type: 'final', name: t.name, color: t.color, text: shown });
-    } else {
+      // FEED THE OUTPUT BACK. The 'ask' path already does this on approve, so
+      // auto mode was strictly LESS capable than the gated one: the command
+      // ran, the result was shown, and the model never saw it — no diagnosis,
+      // no follow-up, no next step. It looked like "auto mode does nothing".
+      //
+      // Bounded, because this is a loop that spends real money on every hop:
+      // AUTO_MAX_STEPS chained commands per user message, reset whenever the
+      // user speaks again.
+      t.autoSteps = (t.autoSteps || 0) + 1;
+      t.status = 'idle';
+      t.lastActivityAt = Date.now();
+      saveThreads();
+      if (t.autoSteps < AUTO_MAX_STEPS) {
+        runTurn(threadId, `(command output)\n${output}`, onEvent).catch(() => {});
+      } else {
+        const note = `(auto-run stopped after ${AUTO_MAX_STEPS} chained commands — say "continue" to keep going)`;
+        t.history.push({ who: 'bot', text: note });
+        onEvent?.({ type: 'final', name: t.name, color: t.color, text: note });
+        saveThreads();
+      }
+      return;
+    }
+    {
       const runId = randomUUID();
       t.pendingRun = { runId, command, cwd: dirFor(t.id) };
       t.history.push({ who: 'bot', text: command, runId, runStatus: 'pending' });

package/lib/info.js

@@ -86,10 +86,51 @@ export async function printBalance() {
  * Credit is keyed by the signed namespace, so it belongs to this wallet and
  * cannot be spent by anyone else.
  */
+/**
+ * How much credit this wallet can actually afford, in USD.
+ *
+ * Derived from a LIVE quote rather than our own price table: ask the gateway
+ * to price $1 of credit, read what each rail wants in raw units, and divide
+ * our balance by it. That way TOKEN (whose USD price we do not carry) is
+ * valued exactly as the gateway values it at settlement time.
+ */
+export async function affordableUsd() {
+  const { PayClient } = await import('./pay.js');
+  const { withNamespace } = await import('./namespace.js');
+  const client = new PayClient();
+  const r = await fetch(`${config.apiBase}/v1/credits/topup`, {
+    method: 'POST',
+    headers: withNamespace({ 'content-type': 'application/json' }),
+    body: JSON.stringify({ usd: 1 }),
+  });
+  if (r.status !== 402) return 0;
+  const ch = await r.json().catch(() => ({}));
+  let best = 0;
+  for (const row of ch.accepts || []) {
+    const perUsd = BigInt(row.maxAmountRequired || '0');
+    if (perUsd <= 0n) continue;
+    try {
+      const bal = await client.balanceForAccept?.(row);
+      const raw = typeof bal === 'bigint' ? bal : BigInt(bal?.raw ?? 0);
+      const usd = Number(raw * 1000n / perUsd) / 1000;
+      if (usd > best) best = usd;
+    } catch { /* a rail we cannot read is simply not a candidate */ }
+  }
+  return best;
+}
+
 export async function topUp(usdArg) {
-  const usd = Number(usdArg);
+  // "all" spends everything the wallet can cover, minus a small margin so a
+  // price tick between quote and settle does not fail the payment outright.
+  let usd = Number(usdArg);
+  if (String(usdArg).toLowerCase() === 'all' || usdArg === undefined) {
+    const max = await affordableUsd();
+    usd = Math.floor(max * 0.97 * 100) / 100;
+    if (!(usd >= 1)) throw new Error(`wallet covers only $${max.toFixed(4)} of credit — fund it first (openzoo balance)`);
+    console.log(`wallet covers ~$${max.toFixed(2)} — buying $${usd.toFixed(2)}`);
+  }
   if (!Number.isFinite(usd) || usd < 1 || usd > 500) {
-    throw new Error('usage: openzoo topup <usd>   (1-500)');
+    throw new Error('usage: openzoo topup <usd|all>   (1-500)');
   }
   const { PayClient } = await import('./pay.js');
   const client = new PayClient();

package/lib/pay.js

@@ -1,6 +1,6 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { getAssociatedTokenAddressSync } from '@solana/spl-token';
-import { config, fundingLine } from './config.js';
+import { config, fundingLine, evmRpcFor } from './config.js';
 import { loadOrCreateWallet } from './wallet.js';
 import {
   parse402, orderAccepts, railOf, buildPaymentOnline, tokenBalance,
@@ -137,6 +137,19 @@ export class PayClient {
     try { return privateKeyToAccount(this.evmPrivateKey).address; } catch { return null; }
   }
 
+  /** Raw balance this wallet holds of the asset a 402 row asks for. */
+  async balanceForAccept(accept) {
+    const rail = railOf(accept);
+    if (rail === 'solana') {
+      const b = await tokenBalance(this.connection, this.keypair.publicKey, accept.asset);
+      return BigInt(b.raw || 0);
+    }
+    const raw = await evmTokenBalance({
+      rpcUrl: evmRpcFor(rail), token: accept.asset, owner: this.evmAddress,
+    });
+    return BigInt(raw || 0);
+  }
+
   async buildPaymentFor(accept, onStage) {
     const rail = railOf(accept);
     if (rail === 'solana') {

package/lib/podagent.mjs

@@ -513,6 +513,13 @@ for (const port of PORTS) {
     record({ port, method: 'UPGRADE', path: req.url, bodyBytes: 0 });
     socket.write('HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n');
   });
+  // NEVER FATAL. These are the Grok-Bot-shaped agent ports, a nicety — but an
+  // unhandled 'error' event takes the whole process down, and the process that
+  // dies is the one also serving the CHAT on :4173. A stale instance holding
+  // :1337 therefore black-screened the app: Electron loaded :4173 and got
+  // ERR_CONNECTION_REFUSED, with the real cause (EADDRINUSE on a port nobody
+  // cares about) buried in a log the user never sees.
+  server.on('error', (e) => console.log(`[agent] :${port} unavailable (${e.code}) — continuing without it`));
   server.listen(port, '0.0.0.0', () => console.log(`[agent] on :${port}`));
 }
 

package/lib/proxy.js

@@ -722,6 +722,22 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       if (isChat && response.ok && upCt.includes('application/json')) {
         let data = null;
         try { data = await response.clone().json(); } catch { /* not JSON after all */ }
+        // PREPAID CALLS STILL COST MONEY. The block above only meters calls
+        // where THIS proxy answered a 402 and paid. When prepaid credit covers
+        // the quote the gateway serves 200 on the FIRST request, so there is
+        // no 402, no payment and no receipt — and the session read $0.05 / 2
+        // calls while the credit balance had actually fallen $3.017 -> $1.395
+        // over a 30-question run. The receipt still rides the response body,
+        // so meter it from there.
+        if (!paid && data?.x402 && typeof data.x402.billedUsd === 'number') {
+          const x = data.x402;
+          sessionSpent += x.billedUsd;
+          sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
+          sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
+          paidCalls += 1;
+          if (viaTunnel) tunnelSpent += x.billedUsd;
+          say(`credit -> $${x.billedUsd.toFixed(6)}  ·  session $${sessionSpent.toFixed(6)}`);
+        }
         if (data?.object === 'chat.completion') {
           if (rKey) replayPut(rKey, data, response.headers.get('x-payment-response'));
           // Anthropic-shaped caller gets an Anthropic-shaped answer, streamed
@@ -789,22 +805,36 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // 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 () => {
+    // Keep credit topped up, forever, from whatever the wallet holds.
+    //
+    // The first version ran ONCE at startup and bought a fixed $5, so funding
+    // the wallet later did nothing at all — the user sent TOKEN and kept
+    // paying on-chain per call. This checks on an interval and spends what the
+    // wallet can actually cover, priced by the gateway's own live quote (so
+    // TOKEN is valued exactly as it settles).
+    const FLOOR = Number(process.env.OPENZOO_AUTOTOPUP_FLOOR || 2);
+    const EVERY = Number(process.env.OPENZOO_AUTOTOPUP_EVERY_MS || 60_000);
+    let topping = false;
+    const tick = async () => {
+      if (topping) return;
+      topping = true;
       try {
-        const { creditBalance, topUp } = await import('./info.js');
+        const { creditBalance, topUp, affordableUsd } = 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);
+        if (have >= FLOOR) return;
+        const can = await affordableUsd();
+        if (can < 1) return;             // nothing to convert; stay quiet
+        say(`credit $${have.toFixed(4)} below $${FLOOR} — wallet covers ~$${can.toFixed(2)}, topping up`);
+        await topUp('all');
       } 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)}`);
+      } finally {
+        topping = false;
       }
-    })();
+    };
+    tick();
+    const timer = setInterval(tick, EVERY);
+    timer.unref?.();   // never hold the process open just for this
   }
 
   if (!silent) {

package/package.json

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