openzoo 0.9.2 → 0.9.4

package/lib/proxy.js

@@ -2,10 +2,11 @@ import http from 'node:http';
 import crypto from 'node:crypto';
 import { Readable } from 'node:stream';
 import {
-  config, FUNDING_ASSETS, fundingLine, liveRails, railFundingHint, railFundingAddresses, unfundableRails, RAIL_FUNDING,
+  config, FUNDING_ASSETS, EVM_FUNDING_ASSETS, evmRpcFor, fundingLine, liveRails, railFundingHint, railFundingAddresses, unfundableRails, RAIL_FUNDING,
 } from './config.js';
 import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
 import { tokenBalance } from './x402.js';
+import { evmTokenBalance } from './evm.js';
 import { bindCorpus, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import { maybeRewriteModel, rewritablePath, augmentModelList, ALIAS_IDS } from './models.js';
 import { forgetContext } from './contexts.js';
@@ -56,6 +57,42 @@ function jsonErr(res, status, message, extraFields = {}) {
 
 const mb = (n) => (n / 1048576).toFixed(1);
 
+/**
+ * Every fundable balance across all three chains, for the startup line and
+ * the live refresh. Each read is independent and advisory — one lagging RPC
+ * drops its entry rather than blanking the whole line.
+ */
+async function snapshotBalances(client) {
+  const out = [];
+  try {
+    const bals = await Promise.all(
+      FUNDING_ASSETS.map((a) => tokenBalance(client.connection, client.keypair.publicKey, a.mint)),
+    );
+    FUNDING_ASSETS.forEach((a, i) => out.push({ symbol: a.symbol, ui: Number(bals[i].ui ?? 0), chain: 'solana' }));
+  } catch { /* Solana RPC hiccup — EVM entries still report */ }
+  const owner = client.evmAddress;
+  if (owner) {
+    await Promise.all(Object.entries(EVM_FUNDING_ASSETS).flatMap(([rail, assets]) => assets.map(async (a) => {
+      try {
+        const raw = await evmTokenBalance({ rpcUrl: evmRpcFor(rail), token: a.address, owner });
+        out.push({ symbol: a.symbol, ui: Number(raw) / 10 ** a.decimals, chain: rail });
+      } catch { /* advisory */ }
+    })));
+  }
+  // Parallel reads land in racy order; sort so the printed line is stable
+  // and diffs against the previous snapshot read cleanly.
+  const rank = { solana: 0, base: 1, robinhood: 2 };
+  return out.sort((a, b) => (rank[a.chain] ?? 9) - (rank[b.chain] ?? 9) || a.symbol.localeCompare(b.symbol));
+}
+
+/** Solana entries always show; EVM entries only once they hold something. */
+function balanceLine(snap) {
+  return snap
+    .filter((b) => b.chain === 'solana' || b.ui > 0)
+    .map((b) => `${b.ui} ${b.symbol}${b.chain !== 'solana' ? ` (${b.chain})` : ''}`)
+    .join('  ·  ');
+}
+
 /**
  * The zoo answers chat completions as ONE JSON object (it settles payment
  * before serving — there is nothing to stream until generation is done).
@@ -81,6 +118,27 @@ function serveAsSse(res, data, upstream) {
     if (c.message?.content) {
       ev({ ...base, choices: [{ index: c.index ?? 0, delta: { content: c.message.content }, finish_reason: null }] });
     }
+    // Agent mode lives or dies here: a finish_reason of "tool_calls" with the
+    // calls themselves dropped strands the harness mid-turn (observed: Cursor
+    // agent hangs). Streaming spec: tool_calls ride the delta with an index,
+    // arguments as a string chunk — one full chunk per call is valid SSE.
+    if (Array.isArray(c.message?.tool_calls) && c.message.tool_calls.length) {
+      ev({
+        ...base,
+        choices: [{
+          index: c.index ?? 0,
+          delta: {
+            tool_calls: c.message.tool_calls.map((t, i) => ({
+              index: i,
+              id: t.id,
+              type: t.type || 'function',
+              function: { name: t.function?.name, arguments: t.function?.arguments ?? '' },
+            })),
+          },
+          finish_reason: null,
+        }],
+      });
+    }
     ev({ ...base, choices: [{ index: c.index ?? 0, delta: {}, finish_reason: c.finish_reason ?? 'stop' }], ...(data.usage ? { usage: data.usage } : {}) });
   }
   res.write('data: [DONE]\n\n');
@@ -175,6 +233,17 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   const log = silent ? () => {} : (...a) => console.log(...a);
   let sessionSpent = 0;
   let tunnelSpent = 0;
+  // Live balance refresh state — the real implementation is assigned in the
+  // banner section below; the handler only ever calls scheduleRefresh().
+  let lastSnap = null;
+  let refreshBalances = async () => {};
+  let refreshPending = false;
+  const scheduleRefresh = (ms) => {
+    if (silent || refreshPending) return;
+    refreshPending = true;
+    const t = setTimeout(async () => { refreshPending = false; await refreshBalances(); }, ms);
+    t.unref?.();
+  };
   // Set once cloudflared is up (see below). Gating keys off the REQUEST's
   // origin, not off whether the URL exists yet, so there is no startup window
   // where public traffic slips through ungated.
@@ -319,6 +388,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         if (requireToken) log(`${line}  ·  session $${sessionSpent.toFixed(6)}`);
         else if (viaTunnel) log(`${line}  ·  public-url session $${tunnelSpent.toFixed(6)}`);
         else log(line);
+        scheduleRefresh(4000); // settlement lands on-chain in a few seconds
       }
       // Chat completions come back as one JSON object (settle-before-serve).
       // Cache it against retries, and if the harness asked to stream, honour
@@ -366,15 +436,39 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     console.log(`wallet (fund me) · solana: ${client.address}`);
     if (client.evmAddress) console.log(`wallet (fund me) · evm (base / robinhood): ${client.evmAddress}`);
     try {
-      const bals = await Promise.all(
-        FUNDING_ASSETS.map((a) => tokenBalance(client.connection, client.keypair.publicKey, a.mint)),
-      );
-      const parts = FUNDING_ASSETS.map((a, i) => `${bals[i].ui ?? 0} ${a.symbol}`);
-      console.log(`balance: ${parts.join('  ·  ')}`);
-      if (!bals.some((b) => b.raw)) {
+      lastSnap = await snapshotBalances(client);
+      console.log(`balance: ${balanceLine(lastSnap) || '(no RPC reachable — advisory only)'}`);
+      if (!lastSnap.some((b) => b.ui > 0)) {
         console.log(`fund it: ${fundingLine('the address above')} — a few cents goes a long way.`);
       }
     } catch { /* RPC hiccup: balance is advisory */ }
+    // LIVE REFRESH: the startup line goes stale the moment a call settles or
+    // the user funds mid-session. Poll on an interval (and shortly after each
+    // paid call), print ONLY on change, and call out arrivals explicitly so
+    // "did my top-up land?" answers itself in the running log.
+    refreshBalances = async () => {
+      try {
+        const snap = await snapshotBalances(client);
+        if (!snap.length) return;
+        const prev = new Map((lastSnap || []).map((b) => [`${b.chain}:${b.symbol}`, b.ui]));
+        const changed = snap.some((b) => Math.abs((prev.get(`${b.chain}:${b.symbol}`) ?? 0) - b.ui) > 1e-9)
+          || snap.length !== (lastSnap || []).length;
+        if (!changed) return;
+        if (lastSnap) {
+          for (const b of snap) {
+            const gain = b.ui - (prev.get(`${b.chain}:${b.symbol}`) ?? 0);
+            if (gain > 1e-9) console.log(`funding arrived: +${gain.toFixed(6)} ${b.symbol}${b.chain !== 'solana' ? ` (${b.chain})` : ''}`);
+          }
+        }
+        lastSnap = snap;
+        console.log(`balance: ${balanceLine(snap)}`);
+      } catch { /* advisory — never noisy on RPC trouble */ }
+    };
+    const pollSecs = Number(process.env.OPENZOO_BALANCE_POLL_SECS ?? 45);
+    if (pollSecs > 0) {
+      const timer = setInterval(refreshBalances, pollSecs * 1000);
+      timer.unref?.();
+    }
     // Which rails the zoo will actually settle right now, straight off a live
     // 402 — so nobody funds a lane the resource is not currently offering.
     try {

package/package.json

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