openzoo 0.48.43 → 0.48.45

package/lib/launch.js

@@ -177,6 +177,19 @@ export async function launchClaude(argv) {
     const SAFE = /^claude-(opus|sonnet|fable)-/;
     if (SAFE.test(bare)) env.ANTHROPIC_MODEL = `openzoo-${bare}`;
   }
+  // THE ACTUAL SWITCHES. Three earlier attempts missed these entirely:
+  // autoCompactEnabled in settings (global, trapped a session), a raised
+  // CLAUDE_CODE_MAX_CONTEXT_TOKENS (clamped to 200k by the model table), and an
+  // unrecognised model alias (resolves fine, still compacted). DISABLE_COMPACT
+  // and DISABLE_AUTO_COMPACT are in the binary and are the direct controls.
+  //
+  // Correct here for the same reason as everything else in this block: the
+  // proxy binds the prefix and forwards a bounded tail, so the request that
+  // leaves this machine stays small no matter how long the conversation runs.
+  if (process.env.OPENZOO_KEEP_COMPACT !== '1') {
+    env.DISABLE_COMPACT = process.env.DISABLE_COMPACT || '1';
+    env.DISABLE_AUTO_COMPACT = process.env.DISABLE_AUTO_COMPACT || '1';
+  }
   // RAISE THE CEILING, because the proxy already removed it.
   //
   // Claude Code counts the WHOLE local transcript against the model's window and
@@ -235,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');
@@ -428,6 +448,19 @@ export async function launchHarness(cmd, args) {
     const SAFE = /^claude-(opus|sonnet|fable)-/;
     if (SAFE.test(bare)) env.ANTHROPIC_MODEL = `openzoo-${bare}`;
   }
+  // THE ACTUAL SWITCHES. Three earlier attempts missed these entirely:
+  // autoCompactEnabled in settings (global, trapped a session), a raised
+  // CLAUDE_CODE_MAX_CONTEXT_TOKENS (clamped to 200k by the model table), and an
+  // unrecognised model alias (resolves fine, still compacted). DISABLE_COMPACT
+  // and DISABLE_AUTO_COMPACT are in the binary and are the direct controls.
+  //
+  // Correct here for the same reason as everything else in this block: the
+  // proxy binds the prefix and forwards a bounded tail, so the request that
+  // leaves this machine stays small no matter how long the conversation runs.
+  if (process.env.OPENZOO_KEEP_COMPACT !== '1') {
+    env.DISABLE_COMPACT = process.env.DISABLE_COMPACT || '1';
+    env.DISABLE_AUTO_COMPACT = process.env.DISABLE_AUTO_COMPACT || '1';
+  }
   // RAISE THE CEILING, because the proxy already removed it.
   //
   // Claude Code counts the WHOLE local transcript against the model's window and

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.43",
+  "version": "0.48.45",
   "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",