openzoo 0.44.1 → 0.45.1

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/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/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
@@ -779,6 +795,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/package.json

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