openzoo 0.49.18 → 0.50.1

package/lib/xburner.js

@@ -0,0 +1,80 @@
+/**
+ * A managed x402 burner per X account, DERIVED not stored.
+ *
+ * @openzoobot's paid lane needs the ASKER to pay, and an X reply is a terrible
+ * place to ask someone to install a wallet. So each X account id gets a burner
+ * the zoo drives on their behalf, funded by them and auto-topped-up, holding
+ * only a working balance — the same shape as the local burner `npx openzoo`
+ * already creates, one per account instead of one per machine.
+ *
+ * DERIVED, NOT STORED, and that is the whole security argument:
+ *   seed(user) = HMAC-SHA512(master, "openzoo-xbot-v1:" + userId)
+ * There is exactly ONE secret on disk no matter how many accounts ever mention
+ * the bot. A per-user keyfile store would mean thousands of secrets, a backup
+ * problem, a deletion problem, and a breach that scales with adoption. Here the
+ * blast radius is one file that already had to be protected, and a burner can
+ * be re-derived on any machine from that file alone — nothing to lose, nothing
+ * to migrate, no keypair that exists only on whichever laptop ran the poller.
+ *
+ * The tradeoff, stated plainly: the master file CAN derive every burner, so it
+ * is as sensitive as all of them combined. That is why it is 0600, never
+ * logged, never sent anywhere, and why balances are kept at working size by
+ * auto top-up rather than being allowed to accumulate.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { Keypair } from '@solana/web3.js';
+
+const MASTER_FILE = process.env.OPENZOO_XBOT_MASTER
+  || path.join(os.homedir(), '.openzoo', 'xbot-master.key');
+
+/** Bump if the derivation ever changes — old burners must keep deriving. */
+const DERIVATION = 'openzoo-xbot-v1';
+
+export function loadOrCreateMaster(file = MASTER_FILE) {
+  try {
+    const hex = fs.readFileSync(file, 'utf8').trim();
+    const buf = Buffer.from(hex, 'hex');
+    if (buf.length === 32) return buf;
+    throw new Error('bad length');
+  } catch {
+    const buf = crypto.randomBytes(32);
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    // wx: never clobber an existing master. Overwriting it would orphan every
+    // burner ever handed out — funds still on-chain, key unrecoverable.
+    try {
+      fs.writeFileSync(file, buf.toString('hex') + '\n', { mode: 0o600, flag: 'wx' });
+    } catch {
+      return Buffer.from(fs.readFileSync(file, 'utf8').trim(), 'hex');
+    }
+    return buf;
+  }
+}
+
+/**
+ * Deterministic burner for an X user id.
+ * Keyed on the numeric id, never the handle: handles are reassignable, and a
+ * burner that follows a renamed handle would hand a new owner the old wallet.
+ */
+export function deriveBurner(xUserId, master = loadOrCreateMaster()) {
+  if (!xUserId) throw new Error('deriveBurner needs an X user id');
+  const mac = crypto.createHmac('sha512', master)
+    .update(`${DERIVATION}:${String(xUserId)}`)
+    .digest();
+  const keypair = Keypair.fromSeed(Uint8Array.from(mac.subarray(0, 32)));
+  const evmPrivateKey = `0x${mac.subarray(32, 64).toString('hex')}`;
+  return {
+    keypair,
+    evmPrivateKey,
+    address: keypair.publicKey.toBase58(),
+    xUserId: String(xUserId),
+  };
+}
+
+/** Address only — for a reply that tells someone where to send funds. */
+export function burnerAddress(xUserId, master) {
+  return deriveBurner(xUserId, master).address;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openzoo",
-  "version": "0.49.18",
-  "description": "Local x402-paying proxy + MCP server for openzoo.fun \u2014 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.",
+  "version": "0.50.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",
   "bin": {
@@ -10,14 +10,13 @@
   "files": [
     "bin",
     "lib",
-    "README.md",
-    "vendor/modelroute"
+    "README.md"
   ],
   "engines": {
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test test/*.test.js && node scripts/assert-grokui-pin.mjs && node scripts/assert-app-html-script.mjs && node scripts/assert-overlaid-openzoo.mjs"
+    "test": "node --test test/*.test.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",

package/lib/anthropic.js

@@ -1,369 +0,0 @@
-/**
- * Anthropic Messages API shape, served by the openzoo proxy.
- *
- * WHY: harnesses that speak Anthropic (Claude Code via ANTHROPIC_BASE_URL, the
- * Anthropic SDKs) could not use the zoo at all — it speaks OpenAI chat
- * completions. Pointing DNS or /etc/hosts at localhost does not work: the TLS
- * cert will not match and the client refuses the connection. A translating
- * endpoint is the only mechanism that actually routes such a harness through
- * x402 payment, and it needs no system changes.
- *
- * Translation is deliberately conservative: what maps cleanly is mapped, and
- * anything unrecognised is passed through rather than dropped, so a field this
- * file has never heard of still reaches the model.
- */
-
-/** Anthropic content blocks -> an OpenAI message content value. */
-function blocksToOpenAI(content) {
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-  const parts = [];
-  for (const b of content) {
-    if (b?.type === 'text') parts.push({ type: 'text', text: b.text ?? '' });
-    else if (b?.type === 'image' && b.source?.type === 'base64') {
-      parts.push({
-        type: 'image_url',
-        image_url: { url: `data:${b.source.media_type};base64,${b.source.data}` },
-      });
-    }
-  }
-  if (parts.length === 1 && parts[0].type === 'text') return parts[0].text;
-  return parts.length ? parts : '';
-}
-
-/**
- * Anthropic request -> OpenAI request.
- *
- * The two shapes disagree on three things that matter: `system` is a top-level
- * field (OpenAI wants a system MESSAGE), tool results are user-turn blocks
- * (OpenAI wants role:"tool" messages), and tool schemas live under
- * `input_schema` rather than `parameters`.
- */
-export function anthropicToOpenAI(body) {
-  const messages = [];
-  if (body.system) {
-    const text = typeof body.system === 'string'
-      ? body.system
-      : (Array.isArray(body.system) ? body.system.map((b) => b?.text ?? '').join('\n') : '');
-    if (text) messages.push({ role: 'system', content: text });
-  }
-
-  for (const m of body.messages ?? []) {
-    const blocks = Array.isArray(m.content) ? m.content : null;
-    const toolResults = blocks?.filter((b) => b?.type === 'tool_result') ?? [];
-    const toolUses = blocks?.filter((b) => b?.type === 'tool_use') ?? [];
-
-    // A user turn carrying tool_result blocks becomes one OpenAI tool message
-    // per result — they are answers to specific calls, not prose.
-    for (const tr of toolResults) {
-      messages.push({
-        role: 'tool',
-        tool_call_id: tr.tool_use_id,
-        content: typeof tr.content === 'string' ? tr.content : JSON.stringify(tr.content ?? ''),
-      });
-    }
-
-    if (toolUses.length) {
-      messages.push({
-        role: 'assistant',
-        content: blocksToOpenAI(blocks.filter((b) => b?.type === 'text')) || null,
-        tool_calls: toolUses.map((t) => ({
-          id: t.id,
-          type: 'function',
-          function: { name: t.name, arguments: JSON.stringify(t.input ?? {}) },
-        })),
-      });
-      continue;
-    }
-
-    const rest = blocks ? blocks.filter((b) => b?.type !== 'tool_result') : m.content;
-    const content = blocksToOpenAI(rest);
-    if (content && (!Array.isArray(content) || content.length)) {
-      messages.push({ role: m.role, content });
-    }
-  }
-
-  const out = { ...body, messages };
-  delete out.system;
-  delete out.anthropic_version;
-  delete out.metadata;
-  // A SERVER-SIDE web_search TOOL IS A PLUGIN, NOT A FUNCTION — TRANSLATE IT.
-  //
-  // Claude Code's Web Search arrives as an Anthropic server tool (type
-  // "web_search_20250305", name "web_search") with NO input_schema, because
-  // Anthropic runs it itself. Routed to OpenRouter->some other provider, nobody
-  // runs it, and the old code simply DROPPED it (no schema) — so the model got
-  // no search capability and every Web Search came back "0 results". Silent,
-  // and worse than the 400 it replaced: the agent believes it searched.
-  //
-  // OpenRouter's `web` plugin is the cross-model equivalent — search-then-inject
-  // middleware that works on every model. Detect the server tool and switch it
-  // on, mapping max_uses -> max_results, rather than discarding the intent.
-  const webTool = (Array.isArray(body.tools) ? body.tools : [])
-    .find((t) => t?.type?.startsWith?.('web_search') || t?.name === 'web_search');
-  if (webTool) {
-    const existing = Array.isArray(body.plugins) ? body.plugins : [];
-    if (!existing.some((p) => p?.id === 'web')) {
-      const web = { id: 'web' };
-      if (Number.isFinite(webTool.max_uses)) web.max_results = webTool.max_uses;
-      out.plugins = [...existing, web];
-    }
-  }
-  if (Array.isArray(body.tools) && body.tools.length) {
-    out.tools = body.tools
-      .filter((t) => t?.name && t?.input_schema)
-      .map((t) => ({
-        type: 'function',
-        function: { name: t.name, description: t.description, parameters: t.input_schema },
-      }));
-    if (!out.tools.length) delete out.tools;
-  }
-  // TOOL_CHOICE MAY NOT OUTLIVE TOOLS.
-  //
-  // The block above DROPS any tool without a name+input_schema — which is every
-  // server-side tool (web_search, computer, bash), because those carry no schema
-  // in the Anthropic shape. When that empties the list, `out.tools` is deleted.
-  // But tool_choice was set unconditionally, so the body went upstream with a
-  // choice and nothing to choose from.
-  //
-  // OBSERVED on grok-4.6: a Claude Code Web Search 400'd with "A tool_choice was
-  // set on the request but no tools were specified." Every provider rejects this
-  // shape; it just words it differently. Gate the choice on tools surviving.
-  const hasTools = Array.isArray(out.tools) && out.tools.length > 0;
-  if (!hasTools) {
-    delete out.tool_choice;
-  } else if (body.tool_choice?.type === 'auto') out.tool_choice = 'auto';
-  else if (body.tool_choice?.type === 'any') out.tool_choice = 'required';
-  else if (body.tool_choice?.type === 'tool') {
-    out.tool_choice = { type: 'function', function: { name: body.tool_choice.name } };
-  }
-  if (body.stop_sequences) { out.stop = body.stop_sequences; delete out.stop_sequences; }
-  return out;
-}
-
-const STOP_REASON = {
-  stop: 'end_turn', length: 'max_tokens', tool_calls: 'tool_use', content_filter: 'stop_sequence',
-};
-
-/** OpenAI completion -> Anthropic message. */
-export function openAIToAnthropic(data, requestedModel) {
-  const choice = (data.choices ?? [])[0] ?? {};
-  const msg = choice.message ?? {};
-  const content = [];
-  if (msg.content) content.push({ type: 'text', text: msg.content });
-  // Same reason as the streaming path: a refusal arrives with `content: null`
-  // and the sentence in `refusal`, so dropping it yields an empty message that
-  // reads as a broken model rather than as the answer it is.
-  else if (typeof msg.refusal === 'string' && msg.refusal.length) {
-    content.push({ type: 'text', text: msg.refusal });
-  }
-  for (const t of msg.tool_calls ?? []) {
-    let input = {};
-    try { input = JSON.parse(t.function?.arguments || '{}'); } catch { input = {}; }
-    content.push({ type: 'tool_use', id: t.id, name: t.function?.name, input });
-  }
-  return {
-    id: data.id ?? `msg_${Date.now()}`,
-    type: 'message',
-    role: 'assistant',
-    model: requestedModel ?? data.model,
-    content,
-    stop_reason: STOP_REASON[choice.finish_reason] ?? 'end_turn',
-    stop_sequence: null,
-    usage: {
-      input_tokens: data.usage?.prompt_tokens ?? 0,
-      output_tokens: data.usage?.completion_tokens ?? 0,
-    },
-  };
-}
-
-/**
- * Emit a finished completion as an Anthropic SSE stream.
- *
- * The zoo settles payment before it answers, so there is nothing to stream
- * until generation is done — same reason the OpenAI path re-emits chunks. A
- * client that asked for a stream and got a JSON body treats the connection as
- * dead and RETRIES, and every retry is another payment.
- */
-export function writeAnthropicSse(res, message, upstream) {
-  // x-accel-buffering: no keeps the cloudflare tunnel / nginx from buffering
-  // the stream and merging the tool_use frames a client parses incrementally.
-  const headers = {
-    'content-type': 'text/event-stream; charset=utf-8',
-    'cache-control': 'no-cache',
-    '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`);
-
-  ev('message_start', {
-    message: { ...message, content: [], stop_reason: null, usage: { ...message.usage, output_tokens: 0 } },
-  });
-  message.content.forEach((block, index) => {
-    if (block.type === 'text') {
-      ev('content_block_start', { index, content_block: { type: 'text', text: '' } });
-      ev('content_block_delta', { index, delta: { type: 'text_delta', text: block.text } });
-    } else {
-      ev('content_block_start', { index, content_block: { type: 'tool_use', id: block.id, name: block.name, input: {} } });
-      ev('content_block_delta', { index, delta: { type: 'input_json_delta', partial_json: JSON.stringify(block.input ?? {}) } });
-    }
-    ev('content_block_stop', { index });
-  });
-  ev('message_delta', {
-    delta: { stop_reason: message.stop_reason, stop_sequence: null },
-    usage: { output_tokens: message.usage.output_tokens },
-  });
-  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 ?? {};
-    // A REASONING CHUNK IS NOT A SILENT CHUNK.
-    //
-    // Only `delta.content` produced output here, so a reasoning model emitted
-    // NOTHING on the socket for the whole time it was thinking. fable reasons
-    // before it answers — measured at 53 completion tokens to say one word — so
-    // a real turn is minutes of zero bytes, and any hop in between is entitled
-    // to drop a connection that has gone idle.
-    //
-    // OBSERVED: a fable turn rendering as "I'll ground this in your own context
-    // first (holo), scout the monorepo layout, then f" and stopping mid-word.
-    // Claude Code 2.1.232 PRESERVES partial responses on a mid-stream drop
-    // instead of erroring, which is why this reads as "empty/truncated output"
-    // rather than as the connection failure it is.
-    //
-    // `ping` is in Anthropic's own SSE grammar and carries no content, so a
-    // client either ignores it or treats it as liveness — never as text.
-    if (!(typeof delta.content === 'string' && delta.content.length)
-        && !(delta.tool_calls ?? []).length
-        && !(typeof delta.refusal === 'string' && delta.refusal.length)) {
-      ev('ping', {});
-    }
-    // A REFUSAL IS A RESPONSE. SHOW IT.
-    //
-    // Upstream returns refusals out-of-band: `finish_reason: "content_filter"`,
-    // `content: null`, and the actual sentence in `refusal`. We only ever read
-    // `delta.content`, so the whole turn translated to a VALID, EMPTY stream —
-    // message_start, message_stop, output_tokens 0 — and rendered as silence.
-    //
-    // OBSERVED: a security audit of the user's OWN exploited protocol returning
-    // nothing at all, repeatedly, and reading as "fable is broken" when the
-    // provider had in fact answered: "This request triggered restrictions on
-    // violative cyber content and was blocked under Anthropic's Usage Policy."
-    // Being told you were refused is actionable — you can rephrase, or route to
-    // another model. Being shown an empty box is not.
-    if (typeof delta.refusal === 'string' && delta.refusal.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.refusal } });
-    }
-    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 };
-}