openzoo 0.9.0 → 0.9.1

package/lib/proxy.js

@@ -1,4 +1,5 @@
 import http from 'node:http';
+import crypto from 'node:crypto';
 import { Readable } from 'node:stream';
 import {
   config, FUNDING_ASSETS, fundingLine, liveRails, railFundingHint, railFundingAddresses, unfundableRails, RAIL_FUNDING,
@@ -55,6 +56,64 @@ function jsonErr(res, status, message, extraFields = {}) {
 
 const mb = (n) => (n / 1048576).toFixed(1);
 
+/**
+ * The zoo answers chat completions as ONE JSON object (it settles payment
+ * before serving — there is nothing to stream until generation is done).
+ * Harnesses that sent `stream: true` expect SSE and treat a JSON body as a
+ * dead connection: Cursor shows "Reconnecting…", RETRIES, and every retry is
+ * a fresh payment. So the proxy honours the contract itself — the finished
+ * completion is re-emitted as spec-shaped chat.completion.chunk events.
+ */
+function serveAsSse(res, data, upstream) {
+  const headers = {
+    'content-type': 'text/event-stream; charset=utf-8',
+    'cache-control': 'no-cache',
+  };
+  const settle = upstream?.headers?.get?.('x-payment-response');
+  if (settle) headers['x-payment-response'] = settle;
+  res.writeHead(200, headers);
+  const base = {
+    id: data.id, object: 'chat.completion.chunk', created: data.created, model: data.model,
+  };
+  const ev = (obj) => res.write(`data: ${JSON.stringify(obj)}\n\n`);
+  for (const c of data.choices || []) {
+    ev({ ...base, choices: [{ index: c.index ?? 0, delta: { role: 'assistant' }, finish_reason: null }] });
+    if (c.message?.content) {
+      ev({ ...base, choices: [{ index: c.index ?? 0, delta: { content: c.message.content }, finish_reason: null }] });
+    }
+    ev({ ...base, choices: [{ index: c.index ?? 0, delta: {}, finish_reason: c.finish_reason ?? 'stop' }], ...(data.usage ? { usage: data.usage } : {}) });
+  }
+  res.write('data: [DONE]\n\n');
+  res.end();
+}
+
+/**
+ * Replay guard — a harness that cannot consume a response retries the SAME
+ * body within seconds, and each retry used to be a fresh payment (observed:
+ * six identical $0.06 settles for one Cursor message). An identical POST body
+ * arriving within the window is served the cached completion, not re-paid.
+ * Window is deliberately short: a genuinely new turn always differs (harnesses
+ * resend the whole conversation), so only true retries can hit.
+ */
+const REPLAY_TTL_MS = 30_000;
+const replayCache = new Map(); // sha256(body) -> { at, data, settle }
+function replayKey(bodyBuf) {
+  return crypto.createHash('sha256').update(bodyBuf).digest('hex');
+}
+function replayGet(key) {
+  const hit = replayCache.get(key);
+  if (!hit) return null;
+  if (Date.now() - hit.at > REPLAY_TTL_MS) { replayCache.delete(key); return null; }
+  return hit;
+}
+function replayPut(key, data, settle) {
+  replayCache.set(key, { at: Date.now(), data, settle });
+  if (replayCache.size > 50) {
+    const oldest = [...replayCache.entries()].sort((a, b) => a[1].at - b[1].at)[0];
+    if (oldest) replayCache.delete(oldest[0]);
+  }
+}
+
 /**
  * "The body never ships twice" at the proxy. A chat body whose LAST message
  * carries a huge pasted corpus gets split at its last blank line — corpus vs
@@ -164,12 +223,31 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // NEAREST zoo model BEFORE anything else sees the body — any POST that
     // carries a model field, not just chat/completions, so /completions,
     // /responses and future shapes all work. Never silent.
+    let wantsStream = false;
     if (rewritablePath(req.method, req.url)) {
       const rw = await maybeRewriteModel(bodyBuf);
       if (rw) {
         log(`model "${rw.from}" is not on the zoo — nearest match ${rw.to} (OPENZOO_DEFAULT_MODEL overrides)`);
         bodyBuf = rw.body;
       }
+      try { wantsStream = JSON.parse(bodyBuf.toString('utf8'))?.stream === true; } catch { /* not JSON */ }
+    }
+
+    // Retry of a body we answered seconds ago? Serve the cached completion —
+    // never pay twice for a harness's reconnect loop.
+    const isChat = req.method === 'POST' && (req.url || '').includes('/chat/completions');
+    const rKey = isChat ? replayKey(bodyBuf) : null;
+    if (rKey) {
+      const hit = replayGet(rKey);
+      if (hit) {
+        log('identical request within 30s — served the cached completion, NOT re-paid');
+        if (wantsStream) { serveAsSse(res, hit.data, null); return; }
+        const h = { 'content-type': 'application/json' };
+        if (hit.settle) h['x-payment-response'] = hit.settle;
+        res.writeHead(200, h);
+        res.end(JSON.stringify(hit.data));
+        return;
+      }
     }
     const init = { method: req.method, headers: upstreamHeaders(req) };
     if (req.method !== 'GET' && req.method !== 'HEAD') init.body = bodyBuf;
@@ -242,6 +320,25 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         else if (viaTunnel) log(`${line}  ·  public-url session $${tunnelSpent.toFixed(6)}`);
         else log(line);
       }
+      // Chat completions come back as one JSON object (settle-before-serve).
+      // Cache it against retries, and if the harness asked to stream, honour
+      // that contract ourselves. An upstream that someday truly streams (SSE
+      // content-type) passes straight through the relay below, untouched.
+      const upCt = response.headers.get('content-type') || '';
+      if (isChat && response.ok && upCt.includes('application/json')) {
+        let data = null;
+        try { data = await response.clone().json(); } catch { /* not JSON after all */ }
+        if (data?.object === 'chat.completion') {
+          if (rKey) replayPut(rKey, data, response.headers.get('x-payment-response'));
+          if (wantsStream) { serveAsSse(res, data, response); return; }
+          const h = { 'content-type': 'application/json' };
+          const settleHdr = response.headers.get('x-payment-response');
+          if (settleHdr) h['x-payment-response'] = settleHdr;
+          res.writeHead(200, h);
+          res.end(JSON.stringify(data));
+          return;
+        }
+      }
       await relay(res, response);
     } catch (err) {
       if (err instanceof QuoteTooHighError) {

package/package.json

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