openzoo 0.48.50 → 0.48.51

package/lib/anthropic.js

@@ -177,3 +177,109 @@ export function writeAnthropicSse(res, message, upstream) {
   ev('message_stop', {});
   res.end();
 }
+
+/**
+ * Translate an OpenAI SSE stream into an Anthropic one, INCREMENTALLY.
+ *
+ * The buffered path above exists because the gateway used to answer with a
+ * finished JSON body. It streams for real now, and piping those frames straight
+ * through gives an Anthropic client a 200 whose body it cannot parse — observed
+ * as "API returned an empty or malformed response (HTTP 200)". The stopgap was
+ * to ask the gateway not to stream and keep buffering, which is correct and
+ * silent: Claude Code sends max_tokens=32000 against a 600-turn transcript, so a
+ * turn is MINUTES of zero bytes and reads as a hang.
+ *
+ * So: same grammar, emitted as it arrives.
+ *
+ * BLOCK INDICES ARE NOT THE OPENAI ONES. Anthropic numbers content blocks
+ * sequentially across the whole message, while OpenAI numbers tool_calls in
+ * their own space starting at 0 — which collides with the text block. Tool
+ * indices are therefore remapped on first sight and remembered.
+ *
+ * `onReceipt` takes the gateway's trailing `: x402 {...}` SSE comment, which is
+ * swallowed here rather than forwarded: it is ours, and the Anthropic grammar
+ * has no room for it.
+ */
+export function streamOpenAIToAnthropic(res, upstream, requestedModel, onReceipt) {
+  const headers = {
+    'content-type': 'text/event-stream; charset=utf-8',
+    'cache-control': 'no-cache, no-transform',
+    'x-accel-buffering': 'no',
+    connection: 'keep-alive',
+  };
+  const settle = upstream?.headers?.get?.('x-payment-response');
+  if (settle) headers['x-payment-response'] = settle;
+  res.writeHead(200, headers);
+  const ev = (type, data) => res.write(`event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`);
+
+  let started = false;
+  let textIndex = -1;      // Anthropic index of the text block, -1 until opened
+  let nextIndex = 0;       // next free Anthropic block index
+  const toolIndex = new Map();   // OpenAI tool_calls[].index -> Anthropic index
+  const open = new Set();
+  let stopReason = 'end_turn';
+  let usage = null;
+  let msgId = null;
+
+  const start = () => {
+    if (started) return;
+    started = true;
+    ev('message_start', {
+      message: {
+        id: msgId ?? `msg_${Date.now()}`, type: 'message', role: 'assistant',
+        model: requestedModel, content: [], stop_reason: null, stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    });
+  };
+
+  const onChunk = (d) => {
+    if (d.id && !msgId) msgId = d.id;
+    if (d.usage) usage = d.usage;
+    const ch = (d.choices ?? [])[0];
+    if (!ch) return;
+    start();
+    const delta = ch.delta ?? {};
+    if (typeof delta.content === 'string' && delta.content.length) {
+      if (textIndex < 0) {
+        textIndex = nextIndex++;
+        ev('content_block_start', { index: textIndex, content_block: { type: 'text', text: '' } });
+        open.add(textIndex);
+      }
+      ev('content_block_delta', { index: textIndex, delta: { type: 'text_delta', text: delta.content } });
+    }
+    for (const t of delta.tool_calls ?? []) {
+      const k = t.index ?? 0;
+      if (!toolIndex.has(k)) {
+        const idx = nextIndex++;
+        toolIndex.set(k, idx);
+        ev('content_block_start', {
+          index: idx,
+          content_block: { type: 'tool_use', id: t.id ?? `toolu_${idx}`, name: t.function?.name ?? '', input: {} },
+        });
+        open.add(idx);
+      }
+      const frag = t.function?.arguments;
+      if (typeof frag === 'string' && frag.length) {
+        ev('content_block_delta', {
+          index: toolIndex.get(k),
+          delta: { type: 'input_json_delta', partial_json: frag },
+        });
+      }
+    }
+    if (ch.finish_reason) stopReason = STOP_REASON[ch.finish_reason] ?? 'end_turn';
+  };
+
+  const finish = () => {
+    start();   // a stream that produced nothing still owes the client a message
+    for (const i of open) ev('content_block_stop', { index: i });
+    ev('message_delta', {
+      delta: { stop_reason: stopReason, stop_sequence: null },
+      usage: { output_tokens: usage?.completion_tokens ?? 0 },
+    });
+    ev('message_stop', {});
+    res.end();
+  };
+
+  return { onChunk, finish, receipt: onReceipt, usageOf: () => usage };
+}

package/lib/proxy.js

@@ -15,7 +15,7 @@ import { maybeRewriteModel, rewritablePath, augmentModelList, ALIAS_IDS } from '
 import { forgetContext } from './contexts.js';
 import { injectBrief } from './brief.js';
 import { withNamespace } from './namespace.js';
-import { anthropicToOpenAI, openAIToAnthropic, writeAnthropicSse } from './anthropic.js';
+import { anthropicToOpenAI, openAIToAnthropic, streamOpenAIToAnthropic, writeAnthropicSse } from './anthropic.js';
 import { responsesToChat, chatToResponses, writeResponsesSse } from './responses.js';
 
 const HOP_BY_HOP = new Set([
@@ -955,7 +955,15 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         // 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;
+        // STREAM AGAIN. This forced `stream:false` for a few hours because
+        // relay() piped the gateway's OpenAI frames straight to a client that
+        // speaks message_start / content_block_delta, producing a 200 nobody
+        // could parse. Buffering fixed the parse and cost the whole point:
+        // Claude Code sends max_tokens=32000 against a 600-turn transcript, so
+        // every turn became minutes of zero bytes and read as a hang.
+        // streamOpenAIToAnthropic() translates the grammar frame by frame, so
+        // the lane can be fast AND readable.
+        converted.stream = clientWantsStream;
         bodyBuf = Buffer.from(JSON.stringify(converted));
         anthropicMode = true;
         req.url = '/v1/chat/completions';
@@ -1282,7 +1290,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       // 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) => {
+      const meterStreamed = (x) => {
         if (paid || typeof x?.billedUsd !== 'number') return;
         sessionSpent += x.billedUsd;
         sessionCogs += typeof x.cogsUsd === 'number' ? x.cogsUsd : x.billedUsd / MARKUP;
@@ -1297,7 +1305,42 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         paidCalls += 1;
         if (viaTunnel) tunnelSpent += x.billedUsd;
         say(`credit -> $${x.billedUsd.toFixed(6)}  ·  session $${sessionSpent.toFixed(6)}`);
-      });
+      };
+
+      // ANTHROPIC CLIENTS GET THE SAME STREAM, IN THEIR OWN GRAMMAR.
+      // Translated frame by frame rather than buffered, so Claude Code sees
+      // tokens as they are produced instead of nothing until the turn ends.
+      if (anthropicMode && wantsStream
+          && (response.headers.get('content-type') || '').includes('text/event-stream')
+          && response.ok && response.body) {
+        const tr = streamOpenAIToAnthropic(res, response, anthropicModel, meterStreamed);
+        let pending = '';
+        const body = Readable.fromWeb(response.body);
+        res.on('close', () => body.destroy());
+        try {
+          for await (const c of body) {
+            pending += c.toString('utf8');
+            const lines = pending.split('\n');
+            pending = lines.pop() ?? '';
+            for (const line of lines) {
+              if (line.startsWith(': x402 ')) {
+                try { meterStreamed(JSON.parse(line.slice(7))); } catch { /* not ours */ }
+                continue;
+              }
+              if (!line.startsWith('data:')) continue;
+              const payload = line.slice(5).trim();
+              if (!payload || payload === '[DONE]') continue;
+              try { tr.onChunk(JSON.parse(payload)); } catch { /* frame split across chunks */ }
+            }
+          }
+        } catch (e) {
+          log(`anthropic stream aborted: ${e.message}`);
+        }
+        tr.finish();
+        return;
+      }
+
+      await relay(res, response, meterStreamed);
     } catch (err) {
       if (err instanceof QuoteTooHighError) {
         log(err.message);

package/package.json

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