openzoo 0.48.44 → 0.48.46

package/lib/launch.js

@@ -248,7 +248,14 @@ export async function launchClaude(argv) {
         + 'const lbl=(isFinite(sx2)&&sx2>0)?"x on spilled":"x vs direct";'
         + 'const col2=(on>1)?"\\x1b[32m":"\\x1b[90m";'
         + 'const save=(on==null||!isFinite(on))?"":("  \\u00b7 "+col2+on.toFixed(4)+lbl+(sv>0?(" ($"+sv.toFixed(4)+" saved)"):"")+"\\x1b[0m");'
-        + 'process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  $"+(Number(j.spendUsd)||0).toFixed(4)+"  "+(j.paidCalls||0)+" call"+((j.paidCalls||0)===1?"":"s")+save+spill+cr+"  \\u00b7 x402")}'
+        // REAL upstream cost, metered by OpenRouter (`usage.cost`), not our
+        // catalog estimate. Everything else on this line is derived from
+        // `max_tokens`, which callers set as a ceiling — measured 2026-08-19, a
+        // $0.9858 quote covered $0.007962 of actual inference. Showing the two
+        // side by side is the only way the markup is visible while it is happening.
+        + 'const ac=j.actual||{};'
+        + 'const real=(ac.calls>0)?("  \\u00b7 $"+Number(ac.upstreamUsd||0).toFixed(4)+" real"+(ac.markupX?(" ("+ac.markupX+"x)"):"")):"";'
+        + 'process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  $"+(Number(j.spendUsd)||0).toFixed(4)+"  "+(j.paidCalls||0)+" call"+((j.paidCalls||0)===1?"":"s")+save+real+spill+cr+"  \\u00b7 x402")}'
         + 'catch{process.stdout.write("\\x1b[38;5;208m\\u25cf\\x1b[0m openzoo  \\u00b7 x402")}})\'\n');
       fs.chmodSync(scriptPath, 0o755);
       const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');

package/lib/proxy.js

@@ -565,6 +565,22 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
   // while spilled calls and offloaded tokens both sat completely still.
   let spillSpend = 0;
   let spillDirect = 0;
+  // ACTUAL UPSTREAM SPEND, FROM THE PROVIDER — not our estimate of it.
+  //
+  // Every other dollar figure here is derived from OpenRouter's CATALOG price
+  // times a token count we guessed, and the guess is bad in a specific
+  // direction: output is priced on `max_tokens`, which callers set as a ceiling.
+  // MEASURED 2026-08-19: a call we quoted at $0.9858 (32,000 reserved output
+  // tokens) actually cost $0.007962 — OpenRouter's own number, 124x smaller.
+  //
+  // OpenRouter returns `usage.cost` on every completion, so the real figure is
+  // already in the response body and needs no extra request and no account-level
+  // lookup. That last part matters: /api/v1/credits reports the WHOLE key's
+  // lifetime usage, and this key also pays for ttfx direct runs and other work,
+  // so the account total can never attribute a dollar to this proxy. Per-call
+  // cost can.
+  let sessionActual = 0;
+  let actualCalls = 0;
   // CREDIT, CACHED. Users cannot tell prepaid credit from wallet balance and
   // have to guess whether a call was even paid for ("I don't think x402 made me
   // pay this at all"). The status line runs EVERY turn, so this is refreshed at
@@ -708,6 +724,18 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           savedUsd: Math.max(0, sessionDirect - sessionSpent),
           savingX: sessionSpent > 0 ? Number((sessionDirect / sessionSpent).toFixed(4)) : null,
           paidCalls,
+          // WHAT THE INFERENCE ACTUALLY COST, as reported by OpenRouter on each
+          // completion (`usage.cost`). Every other figure above is a catalog
+          // estimate built on `max_tokens`; this is metered. `margin` is the
+          // honest gross on this session — the number that says whether the
+          // pricing is sane, which no estimate can.
+          actual: {
+            calls: actualCalls,
+            upstreamUsd: Number(sessionActual.toFixed(6)),
+            billedUsd: Number(sessionSpent.toFixed(6)),
+            marginUsd: Number((sessionSpent - sessionActual).toFixed(6)),
+            markupX: sessionActual > 0 ? Number((sessionSpent / sessionActual).toFixed(2)) : null,
+          },
           mcp: `${self.replace(/\/v1$/, '')}/mcp`,
           upstream: config.apiBase,
           payment: 'x402 per request from the operator\'s local burner wallet — no API key, no account',
@@ -1093,6 +1121,14 @@ 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 */ }
+        // WHAT IT REALLY COST, straight from the provider. This rides every
+        // completion already — no extra call, and unlike the account-level
+        // /api/v1/credits total it is attributable to THIS proxy even though the
+        // same OpenRouter key also pays for ttfx and everything else.
+        if (typeof data?.usage?.cost === 'number' && data.usage.cost >= 0) {
+          sessionActual += data.usage.cost;
+          actualCalls += 1;
+        }
         // 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

package/package.json

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