openzoo 0.48.46 → 0.48.48

package/lib/proxy.js

@@ -66,20 +66,43 @@ async function readBody(req) {
   return Buffer.concat(chunks);
 }
 
-/** Pipe an upstream fetch Response to the client, unbuffered (SSE-safe). */
-function relay(res, upstream) {
+/** Pipe an upstream fetch Response to the client, unbuffered (SSE-safe).
+ *
+ *  `onReceipt` is called with the gateway's x402 block when it arrives. On a
+ *  STREAMED call there is no JSON body to carry that block, so the gateway
+ *  emits it as an SSE COMMENT (`: x402 {...}`) after the last frame — comments
+ *  are discarded by every compliant client, so nothing downstream sees it, but
+ *  without reading it here every spend and savings figure on the status line
+ *  would silently read zero the moment real streaming was switched on.
+ *
+ *  Sniffing NEVER delays a byte: each chunk is written to the client first and
+ *  only then scanned. */
+function relay(res, upstream, onReceipt) {
   const headers = {};
   upstream.headers.forEach((v, k) => {
     if (!['transfer-encoding', 'connection', 'content-encoding', 'content-length'].includes(k)) headers[k] = v;
   });
   res.writeHead(upstream.status, headers);
   if (!upstream.body) { res.end(); return Promise.resolve(); }
+  const sse = (upstream.headers.get('content-type') || '').includes('text/event-stream');
   return new Promise((resolve) => {
     const body = Readable.fromWeb(upstream.body);
     body.on('error', () => res.destroy());
     res.on('close', () => body.destroy());
     body.on('end', resolve);
-    body.pipe(res);
+    if (!sse || typeof onReceipt !== 'function') { body.pipe(res); return; }
+    let pending = '';
+    body.on('data', (c) => {
+      res.write(c);
+      pending += c.toString('utf8');
+      const lines = pending.split('\n');
+      pending = lines.pop() ?? '';   // a comment can straddle two chunks
+      for (const line of lines) {
+        if (!line.startsWith(': x402 ')) continue;
+        try { onReceipt(JSON.parse(line.slice(7))); } catch { /* not our frame */ }
+      }
+    });
+    body.on('end', () => res.end());
   });
 }
 
@@ -840,6 +863,10 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // answer back on the way out. See lib/anthropic.js.
     let anthropicMode = false;
     let anthropicModel = null;
+    // The CLIENT's streaming intent, kept separate from the body we send
+    // upstream. The Anthropic lane asks the gateway for a complete message (we
+    // can only translate a finished one) while still owing the caller SSE.
+    let clientWantsStream = false;
     let responsesMode = false;
     let responsesModel = null;
     let responsesCustom = null;   // names of freeform tools needing custom_tool_call on the way back
@@ -889,7 +916,24 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       try {
         const inbound = JSON.parse(bodyBuf.toString('utf8'));
         anthropicModel = inbound.model;
-        bodyBuf = Buffer.from(JSON.stringify(anthropicToOpenAI(inbound)));
+        // ANTHROPIC CLIENTS CANNOT READ AN OPENAI STREAM.
+        //
+        // The gateway now streams for real, and `relay()` pipes those frames
+        // through untouched — which is correct for an OpenAI client and
+        // unreadable to Claude Code, which speaks the Anthropic SSE grammar
+        // (message_start / content_block_delta / message_stop). It surfaced as
+        // "API returned an empty or malformed response (HTTP 200)": a 200 whose
+        // body the client cannot parse.
+        //
+        // The translation we have (openAIToAnthropic + writeAnthropicSse) works
+        // on a COMPLETE message, so this lane asks the gateway not to stream and
+        // keeps the buffered translation. That costs Claude Code the
+        // time-to-first-byte win until an incremental OpenAI->Anthropic frame
+        // translator exists; a readable answer late beats an unreadable one now.
+        const converted = anthropicToOpenAI(inbound);
+        clientWantsStream = converted.stream === true || inbound.stream === true;
+        converted.stream = false;
+        bodyBuf = Buffer.from(JSON.stringify(converted));
         anthropicMode = true;
         req.url = '/v1/chat/completions';
         url = `${config.apiBase}${req.url}`;
@@ -916,7 +960,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       }
       try {
         const parsed = JSON.parse(bodyBuf.toString('utf8'));
-        wantsStream = parsed?.stream === true;
+        wantsStream = parsed?.stream === true || clientWantsStream;
         // REASONING MODELS SPEND max_tokens ON THINKING FIRST.
         //
         // The budget covers hidden reasoning AND the visible answer, so a
@@ -1197,7 +1241,25 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           return;
         }
       }
-      await relay(res, response);
+      // A STREAMED call is metered from the gateway's trailing SSE comment —
+      // same figures the JSON path reads out of `data.x402`, same counters, so
+      // the status line does not care which transport served the answer.
+      await relay(res, response, (x) => {
+        if (paid || typeof x?.billedUsd !== 'number') return;
+        sessionSpent += x.billedUsd;
+        sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
+        sessionDirect += typeof x.directUsd === 'number' ? x.directUsd : x.billedUsd;
+        if (typeof x.actualUsd === 'number' && x.actualUsd >= 0) { sessionActual += x.actualUsd; actualCalls += 1; }
+        if (didSpill) {
+          const lc = x.lecore || {};
+          log(`spill priced (streamed): ${x.pricing} · basis ${x.counterfactualTokensUsed ?? '?'} tok vs sent ${lc.tokensBefore ?? '?'} -> ${lc.tokensAfter ?? '?'} · billed ${(x.billedUsd ?? 0).toFixed(5)} direct ${(x.directUsd ?? 0).toFixed(5)}`);
+          spillSpend += x.billedUsd;
+          spillDirect += 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)}`);
+      });
     } catch (err) {
       if (err instanceof QuoteTooHighError) {
         log(err.message);

package/package.json

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