openzoo 0.12.3 → 0.13.0

package/bin/openzoo.js

@@ -6,7 +6,10 @@ const HELP = `openzoo — local x402-paying proxy + MCP server for openzoo.fun
 usage:
   npx openzoo            start the proxy: http://localhost:8402/v1 (keyless) PLUS a
                          public HTTPS url for cloud IDEs (key required, printed at start)
-  npx openzoo mcp        stdio MCP server (tools: zoo_ask, zoo_models, zoo_wallet)
+  npx openzoo claude     launch Claude Code through the zoo — every turn pays x402
+                         (needs the proxy running; sets ANTHROPIC_BASE_URL for you)
+  npx openzoo launch <cmd> [args]   same, for any Anthropic-shaped harness
+  npx openzoo mcp        stdio MCP server (tools: zoo_ask, zoo_bind, zoo_models, zoo_wallet, zoo_contexts)
   npx openzoo tunnel     public-url-only mode (everything key-gated, no keyless localhost)
   npx openzoo demo       ~1M-token needle demo: direct refuses, the zoo answers
                          (run it twice — the second run reuses the bound corpus and is near-free)
@@ -47,6 +50,19 @@ async function main() {
     case 'mcp':
       await (await import('../lib/mcp.js')).startMcp();
       break;
+    case 'claude':
+    case 'launch': {
+      // `npx openzoo claude [args]` runs Claude Code (or, with `launch <cmd>`,
+      // any Anthropic-shaped harness) through the local zoo — inference paid
+      // per turn over x402. The proxy must already be running.
+      const rest = process.argv.slice(3);
+      const [harness, hargs] = cmd === 'launch'
+        ? [rest[0], rest.slice(1)]
+        : ['claude', rest];
+      if (!harness) throw new Error('usage: openzoo launch <command> [args...]');
+      await (await import('../lib/launch.js')).launchHarness(harness, hargs);
+      break;
+    }
     case 'tunnel':
       await (await import('../lib/tunnel.js')).runTunnel();
       break;

package/lib/anthropic.js

@@ -0,0 +1,172 @@
+/**
+ * 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;
+  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;
+  }
+  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 });
+  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) {
+  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 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();
+}

package/lib/bindpath.js

@@ -25,9 +25,18 @@ import { config } from './config.js';
 import { corpusHash, rememberContext, lookupContext } from './contexts.js';
 import { withNamespace } from './namespace.js';
 
-/** Bodies over this go in their own part. Under the ~8MB transport ceiling
- *  with room for JSON escaping, which can inflate text substantially. */
-export const MAX_PART_BYTES = Number(process.env.OPENZOO_BIND_PART_BYTES || 4_000_000);
+/**
+ * Bodies over this go in their own part.
+ *
+ * Sized by TIME, not just by the transport ceiling. Each append re-indexes a
+ * larger context, so parts get progressively slower — MEASURED binding a 23MB
+ * Rust tree, 4MB parts ran 25s → 30s → 65s. A minutes-long bind is also a
+ * minutes-long window in which any gateway restart destroys all the work done
+ * so far (a deploy mid-bind cost exactly that, five good parts thrown away).
+ * Smaller parts cost more round trips, finish sooner, and lose less when
+ * something upstream cycles.
+ */
+export const MAX_PART_BYTES = Number(process.env.OPENZOO_BIND_PART_BYTES || 2_000_000);
 
 /** Text-ish files worth binding. Anything else is skipped rather than
  *  silently binding a binary as mojibake. */

package/lib/launch.js

@@ -0,0 +1,43 @@
+/**
+ * `npx openzoo claude [args...]` — launch Claude Code (or any Anthropic-shaped
+ * harness) already pointed at the local zoo, so its inference is paid per turn
+ * over x402 instead of hitting Anthropic directly.
+ *
+ * This is the supported front door: ANTHROPIC_BASE_URL is an official env var
+ * Claude Code reads at startup. No DNS games, no TLS interception — the proxy
+ * serves POST /v1/messages (see lib/anthropic.js) and this just spawns the
+ * harness with the two env vars set. The proxy must already be running
+ * (`npx openzoo` in another terminal); we check first and say so if not.
+ */
+import { spawn } from 'node:child_process';
+import { config } from './config.js';
+
+export async function launchHarness(cmd, args) {
+  const base = `http://localhost:${config.port}/v1`;
+  // Fail early with a clear message rather than letting the harness spew
+  // connection errors — the #1 support question would otherwise be "why won't
+  // claude connect" when the answer is "the proxy isn't up".
+  try {
+    const r = await fetch(`${base}/models`, { signal: AbortSignal.timeout(4000) });
+    if (!r.ok) throw new Error(String(r.status));
+  } catch {
+    console.error(`openzoo: no proxy reachable at ${base}`);
+    console.error('start it first in another terminal:  npx openzoo');
+    process.exit(1);
+  }
+
+  const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: base,
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || 'sk-openzoo',
+    // Claude Code sends model ids like "claude-opus-5"; the zoo serves those,
+    // and unknown ids are matched to the nearest served model regardless.
+  };
+  console.error(`openzoo: launching \`${cmd}\` on the zoo (ANTHROPIC_BASE_URL=${base}) — every turn pays x402`);
+  const child = spawn(cmd, args, { stdio: 'inherit', env });
+  child.on('exit', (code) => process.exit(code ?? 0));
+  child.on('error', (e) => {
+    console.error(`openzoo: could not launch \`${cmd}\`: ${e.message}`);
+    process.exit(1);
+  });
+}

package/lib/proxy.js

@@ -13,6 +13,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';
 
 const HOP_BY_HOP = new Set([
   'host', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade',
@@ -298,7 +299,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       log(`path ${req.url} -> ${normalized} (base_url already ends in /v1)`);
       req.url = normalized;
     }
-    const url = `${config.apiBase}${req.url}`;
+    let url = `${config.apiBase}${req.url}`;
     // Requests that arrived over the public quick-tunnel URL carry cloudflared's
     // headers; nothing dialing 127.0.0.1 directly does. That distinction is what
     // lets localhost stay keyless while the SAME port is safely public.
@@ -369,6 +370,31 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       jsonErr(res, 400, 'bad request body');
       return;
     }
+
+    // ANTHROPIC MESSAGES SHAPE. A harness pointed here via ANTHROPIC_BASE_URL
+    // (Claude Code, the Anthropic SDKs) speaks POST /v1/messages, not chat
+    // completions — this is how such a harness routes its inference through
+    // x402 without any DNS or TLS trickery. Translate the body to OpenAI shape
+    // and rewrite the path so EVERYTHING downstream (model rewrite, brief,
+    // corpus cache, payment, replay, streaming) runs unchanged; translate the
+    // answer back on the way out. See lib/anthropic.js.
+    let anthropicMode = false;
+    let anthropicModel = null;
+    const rawPath = (req.url || '').split('?')[0];
+    if (req.method === 'POST' && (rawPath === '/v1/messages' || rawPath === '/messages')) {
+      try {
+        const inbound = JSON.parse(bodyBuf.toString('utf8'));
+        anthropicModel = inbound.model;
+        bodyBuf = Buffer.from(JSON.stringify(anthropicToOpenAI(inbound)));
+        anthropicMode = true;
+        req.url = '/v1/chat/completions';
+        url = `${config.apiBase}${req.url}`;
+      } catch {
+        jsonErr(res, 400, 'invalid anthropic messages body');
+        return;
+      }
+    }
+
     // Harness model ids ("gpt-5.6-sol", "claude-…") are rewritten onto the
     // NEAREST zoo model BEFORE anything else sees the body — any POST that
     // carries a model field, not just chat/completions, so /completions,
@@ -497,6 +523,18 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         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'));
+          // Anthropic-shaped caller gets an Anthropic-shaped answer, streamed
+          // or not, so Claude Code and the SDKs parse it natively.
+          if (anthropicMode) {
+            const msg = openAIToAnthropic(data, anthropicModel);
+            if (wantsStream) { writeAnthropicSse(res, msg, 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(msg));
+            return;
+          }
           if (wantsStream) { serveAsSse(res, data, response); return; }
           const h = { 'content-type': 'application/json' };
           const settleHdr = response.headers.get('x-payment-response');

package/package.json

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