openzoo 0.48.50 → 0.48.52

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([
@@ -311,7 +311,7 @@ function msgText(m) {
  * severed at a plain `user` message — everything before one is self-contained.
  * A system message is never spilled: it is the operating contract, not history.
  */
-async function spillTranscript(body, log) {
+async function spillTranscript(body, log, req) {
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs || msgs.length < 6) return null;
 
@@ -391,6 +391,28 @@ async function spillTranscript(body, log) {
   }
   if (tailStart > cut) cut = tailStart;
 
+  // COHERENCE IS COUNTED IN TURNS, NOT BYTES.
+  //
+  // The byte budget alone produced windows of 2, 5 and 34 turns out of ~600 —
+  // and one fat tool result is enough to spend the whole 6,000 chars, so a busy
+  // agent turn collapses the window to almost nothing. OBSERVED live: an agent
+  // that had just run a command reported "I don't have the preceding turns of
+  // this conversation in view" and re-derived its own state from files, every
+  // turn. Retrieval brings back what is RELEVANT to the ask; it does not
+  // reliably bring back "what I just did", because the model does not know to
+  // query for it.
+  //
+  // So floor the window at a number of turns regardless of size. This costs
+  // saving — a bigger tail is a bigger `sent` — and that is the correct trade:
+  // measured 8.13x on the fleet leaves room to spend some of it on an agent
+  // that remembers its own last few moves.
+  const minTurns = Number(process.env.OPENZOO_TAIL_MIN_TURNS || 12);
+  if (msgs.length - cut < minTurns) {
+    for (let i = Math.max(firstSpillable + 1, msgs.length - minTurns); i > firstSpillable; i--) {
+      if (severable(i)) { cut = i; break; }
+    }
+  }
+
   // NEVER SPILL THE CURRENT ASK.
   //
   // The tail budget walks BACKWARD accumulating bytes, and in an agent loop the
@@ -430,7 +452,21 @@ async function spillTranscript(body, log) {
   // one. So when it does, send just the tail and keep the same context_id.
   // Anchored on the FIRST 2KB, which is stable for the life of a conversation
   // and distinguishes concurrent ones.
-  const anchor = corpus.slice(0, 2048);
+  // KEY ON THE SESSION, NOT ON THE CONTENT.
+  //
+  // The anchor was the first 2KB of corpus, which works only because a
+  // transcript's opening never changes. It is fragile in exactly the cases that
+  // matter: two sessions that open identically (same system block, same first
+  // instruction — the norm for an agent) collide onto ONE bound context and
+  // interleave their histories, and any edit near the top of a transcript
+  // silently orphans the binding and re-uploads the whole thing.
+  //
+  // Claude Code identifies its session, so use that when it is offered and fall
+  // back to the content anchor when it is not. Same memo, better key.
+  const sessionId = req?.headers?.['x-session-id']
+    || req?.headers?.['x-claude-session-id']
+    || (typeof body?.metadata?.user_id === 'string' ? body.metadata.user_id : null);
+  const anchor = sessionId ? `sid:${sessionId}` : corpus.slice(0, 2048);
   const prior = spillMemo.get(anchor);
   let bind;
   if (prior && corpus.startsWith(prior.corpus) && corpus.length > prior.corpus.length) {
@@ -515,11 +551,11 @@ async function maybeCacheCorpus(req, bodyBuf, log) {
   const oneShot = typeof last?.content === 'string'
     && last.content.length > BIND_MIN_CHARS
     && last.content.lastIndexOf('\n\n') >= BIND_MIN_CHARS;
-  if (!oneShot) return spillTranscript(body, log);
+  if (!oneShot) return spillTranscript(body, log, req);
   const cut = last.content.lastIndexOf('\n\n');
   const corpus = last.content.slice(0, cut);
   const ask = last.content.slice(cut + 2).trim();
-  if (!ask || ask.length > 8000) return spillTranscript(body, log);
+  if (!ask || ask.length > 8000) return spillTranscript(body, log, req);
 
   const bind = await bindCorpus(corpus, {
     onStage: (stage, info) => {
@@ -955,7 +991,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 +1326,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 +1341,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.52",
   "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",