openzoo 0.49.7 → 0.49.9

package/lib/racesettle.js

@@ -180,6 +180,133 @@ export function receiptDirectUsd(x) {
   return billedOk ? billed : 0;
 }
 
+/** Zoo's share of (direct − OpenRouter) when the 402 has real savings. */
+export const SAVINGS_SHARE = 0.33;
+/**
+ * billed / usage.cost above this, without settled house cogs, is the
+ * max_tokens quote reserve — not the charge after completion.
+ * MEASURED 2026-08-19: $0.9858 reserved / $0.007962 usage.cost ≈ 124× on a ~1× call.
+ */
+export const QUOTE_RESERVE_X = 2;
+
+function money(v) {
+  return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : null;
+}
+
+function closeRatio(a, b, rel = 0.25) {
+  const den = Math.max(b, 1e-12);
+  return Math.abs(a - b) / den <= rel;
+}
+
+/**
+ * After-completion billed fields the gateway may already put on x402 / usage.
+ * Read only if present — do not invent them on the wire.
+ */
+function explicitSettledBilled(x, usage) {
+  const bags = [x, usage, x?.used, x?.settled, x?.receipt, usage?.used, usage?.settled]
+    .filter((o) => o && typeof o === 'object' && !Array.isArray(o));
+  const keys = [
+    'billedActual', 'billedActualUsd', 'settledUsd', 'settledBilledUsd',
+    'chargedUsd', 'usedUsd', 'actualBilledUsd',
+  ];
+  for (const bag of bags) {
+    for (const k of keys) {
+      const n = money(bag[k]);
+      if (n != null) return n;
+    }
+  }
+  return null;
+}
+
+/** tokens actually used × unit prices, only when both sides are already on the object. */
+function billedFromUsedTokens(x, usage) {
+  const prompt = money(usage?.prompt_tokens ?? usage?.promptTokens ?? x?.prompt_tokens);
+  const completion = money(usage?.completion_tokens ?? usage?.completionTokens ?? x?.completion_tokens);
+  const inPrice = money(x?.promptPriceUsd ?? x?.inputPriceUsd ?? x?.priceInUsd);
+  const outPrice = money(x?.completionPriceUsd ?? x?.outputPriceUsd ?? x?.priceOutUsd);
+  if (prompt != null && completion != null && inPrice != null && outPrice != null) {
+    return prompt * inPrice + completion * outPrice;
+  }
+  return null;
+}
+
+/**
+ * True when `billed` is the quote-time max_tokens ceiling, not the settled charge.
+ * A large billed/cost is honest when cogs already matches usage.cost (33% of
+ * real savings). The 124× lie is billed >> cost with at-cost / reserved cogs.
+ */
+export function isQuoteReserveBilled(billed, cost, x = {}) {
+  if (money(billed) == null || money(cost) == null) return false;
+  if (cost === 0) return billed > 0;
+  if (billed <= cost * QUOTE_RESERVE_X) return false;
+  const cogs = money(x?.cogsUsd);
+  if (cogs != null && closeRatio(cogs, cost)) return false;
+  const saved = money(x?.savedUsd);
+  if (saved == null || saved <= cost * 0.5) return true;
+  if (cogs != null && cogs > cost * QUOTE_RESERVE_X) return true;
+  return true;
+}
+
+/**
+ * Post-completion billed USD to pair with usage.cost / x.actualUsd.
+ * `x.billedUsd` is often the quote reserve (max_tokens × catalog), which made
+ * HUD markupX read 124× on a ~1× call. Prefer a settled field; otherwise
+ * reconstruct from tokens used × price or from usage.cost (+ 33% of settled
+ * savings). Never return the reserve when we learned the real upstream cost.
+ */
+export function receiptSettledBilled(x, usage) {
+  const cost = money(usage?.cost) ?? money(x?.actualUsd) ?? money(usage?.actualUsd);
+  const explicit = explicitSettledBilled(x, usage);
+  if (explicit != null) return explicit;
+
+  const fromTokens = billedFromUsedTokens(x, usage);
+  if (fromTokens != null) {
+    const billed = money(x?.billedUsd);
+    if (billed == null || isQuoteReserveBilled(billed, fromTokens, x)
+        || (cost != null && isQuoteReserveBilled(billed, cost, x))) {
+      return fromTokens;
+    }
+    return billed;
+  }
+
+  const billed = money(x?.billedUsd);
+  if (billed != null && (cost == null || !isQuoteReserveBilled(billed, cost, x))) {
+    return billed;
+  }
+  if (cost != null) {
+    const saved = settledSavedUsd(x, cost);
+    return cost + SAVINGS_SHARE * saved;
+  }
+  return billed ?? 0;
+}
+
+function settledSavedUsd(x, cost) {
+  const saved = money(x?.savedUsd);
+  if (saved == null || saved <= 0) return 0;
+  const cogs = money(x?.cogsUsd);
+  // Quote-time savedUsd rides the same max_tokens reserve. Only keep it when
+  // house cost already matches the metered upstream (settled cogs).
+  if (cogs != null && closeRatio(cogs, cost)) return saved;
+  return 0;
+}
+
+/**
+ * Pair the HUD denominator (real upstream) with the post-completion billed
+ * twin. Null when this call did not report a real cost — do not mix populations.
+ */
+export function pairActualBilled(x402, usage) {
+  const fromUsage = money(usage?.cost);
+  const fromX = money(x402?.actualUsd) ?? money(x402?.usage?.cost);
+  const upstreamUsd = fromUsage ?? fromX;
+  if (upstreamUsd == null) return null;
+  const bag = x402 && typeof x402 === 'object' ? x402 : {};
+  const usageBag = usage && typeof usage === 'object' ? usage : {};
+  return {
+    upstreamUsd,
+    billedUsd: receiptSettledBilled(bag, { ...usageBag, cost: upstreamUsd }),
+  };
+}
+
 /**
  * Session meter. spent/direct are the receipt totals as billed — never a
  * first-call rewrite, never a race_unused user refund.

package/lib/relay.js

@@ -0,0 +1,275 @@
+/**
+ * Pipe an upstream fetch Response to the client.
+ *
+ * Fly (and other CDNs) gzip error bodies. Node fetch does not always inflate
+ * those — MEASURED: a 400 from x402-tokens.fly.dev arrived still gzip-wrapped
+ * with `Content-Encoding: gzip`. The old relay stripped that header and
+ * `Content-Length`, then piped `response.body` RAW. Claude Code printed
+ * `API Error: 400` plus diamond/binary mojibake.
+ *
+ * Contract: never emit a compressed body without Content-Encoding. Prefer
+ * decompressing so the client sees application/json or text (Claude CLI can
+ * parse the error). Unknown encodings keep the header and the bytes together.
+ */
+import zlib from 'node:zlib';
+import { promisify } from 'node:util';
+import { Readable, PassThrough } from 'node:stream';
+
+const gunzipAsync = promisify(zlib.gunzip);
+const inflateAsync = promisify(zlib.inflate);
+const inflateRawAsync = promisify(zlib.inflateRaw);
+const brotliAsync = promisify(zlib.brotliDecompress);
+
+const HOP = new Set(['transfer-encoding', 'connection', 'content-length']);
+
+export function looksGzip(buf) {
+  return Buffer.isBuffer(buf) && buf.length >= 2 && buf[0] === 0x1f && buf[1] === 0x8b;
+}
+
+function headerEncoding(headers) {
+  return String(headers?.get?.('content-encoding') || '').trim();
+}
+
+/** Single known codec, or null if identity / absent / unknown / stacked. */
+export function knownCodec(encoding) {
+  const parts = String(encoding || '')
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter((s) => s && s !== 'identity');
+  if (parts.length !== 1) return null;
+  if (parts[0] === 'gzip' || parts[0] === 'x-gzip') return 'gzip';
+  if (parts[0] === 'deflate') return 'deflate';
+  if (parts[0] === 'br') return 'br';
+  return null;
+}
+
+export async function inflateEncoded(buf, encoding) {
+  const codec = knownCodec(encoding) || (looksGzip(buf) ? 'gzip' : null);
+  if (!codec) return buf;
+  // Leftover Content-Encoding after fetch already inflated: do not gunzip JSON.
+  if (codec === 'gzip' && !looksGzip(buf)) return buf;
+  try {
+    if (codec === 'gzip') return await gunzipAsync(buf);
+    if (codec === 'br') return await brotliAsync(buf);
+    try {
+      return await inflateAsync(buf);
+    } catch {
+      return await inflateRawAsync(buf);
+    }
+  } catch (err) {
+    if (!looksBinary(buf)) return buf;
+    throw err;
+  }
+}
+
+function looksBinary(buf) {
+  if (!buf || !buf.length) return false;
+  if (looksGzip(buf)) return true;
+  const n = Math.min(buf.length, 256);
+  let ctrl = 0;
+  for (let i = 0; i < n; i++) {
+    const c = buf[i];
+    if (c === 0 || c < 8 || (c > 13 && c < 32)) ctrl += 1;
+  }
+  return ctrl >= 4;
+}
+
+function copyHeaders(upstream, { decoded }) {
+  const headers = {};
+  upstream.headers.forEach((v, k) => {
+    const key = String(k).toLowerCase();
+    if (HOP.has(key)) return;
+    // Drop Content-Encoding only when the bytes we send are already inflated.
+    if (decoded && key === 'content-encoding') return;
+    headers[k] = v;
+  });
+  return headers;
+}
+
+function preferReadableType(headers, buf) {
+  const ct = String(headers['content-type'] || '');
+  if (ct && !/octet-stream|(?:x-)?gzip|br\b/i.test(ct)) return;
+  const c = buf[0];
+  headers['content-type'] = (c === 0x7b || c === 0x5b)
+    ? 'application/json; charset=utf-8'
+    : 'text/plain; charset=utf-8';
+}
+
+function jsonUpstreamErr(res, status) {
+  res.writeHead(status || 502, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ error: { message: `upstream HTTP ${status || 502}` } }));
+}
+
+async function readBody(upstream) {
+  if (!upstream.body) return Buffer.alloc(0);
+  const chunks = [];
+  for await (const c of Readable.fromWeb(upstream.body)) chunks.push(c);
+  return Buffer.concat(chunks);
+}
+
+/**
+ * Non-OK: buffer, inflate gzip/br/deflate (or gzip-magic with no header),
+ * send uncompressed JSON/text. Never forward gzip bytes with the encoding
+ * header stripped. Un-decodable compressed bodies become a short JSON error
+ * so Claude / grokui do not paint diamond mojibake — the canvas fold to
+ * `upstream HTTP 400` lives in #65; we just refuse to emit the binary.
+ */
+async function relayError(res, upstream) {
+  const encoding = headerEncoding(upstream.headers);
+  const codec = knownCodec(encoding);
+  let buf;
+  try {
+    buf = await readBody(upstream);
+  } catch {
+    jsonUpstreamErr(res, upstream.status);
+    return;
+  }
+
+  if (codec || looksGzip(buf)) {
+    try {
+      buf = await inflateEncoded(buf, encoding);
+    } catch {
+      jsonUpstreamErr(res, upstream.status);
+      return;
+    }
+    if (looksBinary(buf)) {
+      jsonUpstreamErr(res, upstream.status);
+      return;
+    }
+    const headers = copyHeaders(upstream, { decoded: true });
+    preferReadableType(headers, buf);
+    res.writeHead(upstream.status, headers);
+    res.end(buf);
+    return;
+  }
+
+  if (encoding && !codec) {
+    // Unknown / stacked coding: keep the label with the bytes.
+    res.writeHead(upstream.status, copyHeaders(upstream, { decoded: false }));
+    res.end(buf);
+    return;
+  }
+
+  if (looksBinary(buf)) {
+    jsonUpstreamErr(res, upstream.status);
+    return;
+  }
+  const headers = copyHeaders(upstream, { decoded: true });
+  preferReadableType(headers, buf);
+  res.writeHead(upstream.status, headers);
+  res.end(buf);
+}
+
+function createDecoder(codec) {
+  if (codec === 'gzip') return zlib.createGunzip();
+  if (codec === 'deflate') return zlib.createInflate();
+  if (codec === 'br') return zlib.createBrotliDecompress();
+  return null;
+}
+
+function prependChunk(chunk, rest) {
+  const out = new PassThrough();
+  out.write(chunk);
+  rest.pipe(out);
+  return out;
+}
+
+function attachBody(res, body, onReceipt, sse, resolve) {
+  body.on('error', () => res.destroy());
+  res.on('close', () => body.destroy());
+  if (!sse || typeof onReceipt !== 'function') {
+    body.pipe(res);
+    body.on('end', resolve);
+    return;
+  }
+  let pending = '';
+  body.on('data', (c) => {
+    res.write(c);
+    pending += c.toString('utf8');
+    const lines = pending.split('\n');
+    pending = lines.pop() ?? '';
+    for (const line of lines) {
+      if (!line.startsWith(': x402 ')) continue;
+      try { onReceipt(JSON.parse(line.slice(7))); } catch { /* not our frame */ }
+    }
+  });
+  body.on('end', () => { res.end(); resolve(); });
+}
+
+/**
+ * 2xx stream. Uncompressed (the cheap Fly 200) is the old pipe. Encoded
+ * bodies are inflated when we know the codec, otherwise the encoding
+ * header stays with the bytes.
+ */
+function relayOk(res, upstream, onReceipt) {
+  const encoding = headerEncoding(upstream.headers);
+  const codec = knownCodec(encoding);
+  const sse = (upstream.headers.get('content-type') || '').includes('text/event-stream');
+
+  return new Promise((resolve) => {
+    const raw = Readable.fromWeb(upstream.body);
+    raw.on('error', () => res.destroy());
+    res.on('close', () => raw.destroy());
+
+    if (!encoding) {
+      res.writeHead(upstream.status, copyHeaders(upstream, { decoded: true }));
+      attachBody(res, raw, onReceipt, sse, resolve);
+      return;
+    }
+
+    // Peek so a leftover Content-Encoding on already-plain bytes is stripped,
+    // and a real gzip body is never sent naked.
+    let decided = false;
+    raw.once('data', (chunk) => {
+      if (decided) return;
+      decided = true;
+      const head = Buffer.from(chunk);
+      const gzip = looksGzip(head);
+      if (gzip || (codec && codec !== 'gzip')) {
+        const dec = codec ? createDecoder(codec) : zlib.createGunzip();
+        if (!dec) {
+          res.writeHead(upstream.status, copyHeaders(upstream, { decoded: false }));
+          attachBody(res, prependChunk(head, raw), onReceipt, sse, resolve);
+          return;
+        }
+        dec.write(head);
+        raw.pipe(dec);
+        res.writeHead(upstream.status, copyHeaders(upstream, { decoded: true }));
+        attachBody(res, dec, onReceipt, sse, resolve);
+        return;
+      }
+      // Header leftover on plain JSON/SSE — drop encoding, replay the peek.
+      res.writeHead(upstream.status, copyHeaders(upstream, { decoded: true }));
+      attachBody(res, prependChunk(head, raw), onReceipt, sse, resolve);
+    });
+    raw.once('end', () => {
+      if (decided) return;
+      decided = true;
+      res.writeHead(upstream.status, copyHeaders(upstream, { decoded: true }));
+      res.end();
+      resolve();
+    });
+  });
+}
+
+/** Pipe an upstream fetch Response to the client, unbuffered (SSE-safe).
+ *
+ *  `onReceipt` is called with the gateway's x402 block when it arrives. On a
+ *  STREAMED call there is no JSON body to carry that block, so the gateway
+ *  emits it as an SSE COMMENT (`: x402 {...}`) after the last frame —
+ *  comments are discarded by every compliant client, so nothing downstream
+ *  sees it, but without reading it here every spend and savings figure on
+ *  the status line would silently read zero the moment real streaming was
+ *  switched on.
+ *
+ *  Sniffing NEVER delays a byte: each chunk is written to the client first
+ *  and only then scanned. */
+export function relay(res, upstream, onReceipt) {
+  if (!upstream.body) {
+    res.writeHead(upstream.status, copyHeaders(upstream, { decoded: true }));
+    res.end();
+    return Promise.resolve();
+  }
+  if (!upstream.ok) return relayError(res, upstream);
+  return relayOk(res, upstream, onReceipt);
+}

package/lib/runguard.js

@@ -0,0 +1,31 @@
+/** Pin find(1) to the thread cwd. Unbounded `find /` is a full-disk walk. */
+import path from 'node:path';
+
+export const FIND_MAXDEPTH = Number(process.env.OZ_FIND_MAXDEPTH || 8);
+
+export function guardFindCwd(command, cwd = '.') {
+  if (typeof command !== 'string' || !command) return command;
+  if (!/(?:^|[\s;|&(`])find(?:\s|$)/.test(command)) return command;
+  const root = path.resolve(cwd || '.');
+  return command.replace(/(^|[\s;|&(`])((?:sudo\s+)?)find(\s+)([^;&|`\n]*)/g, (m, pre, sudo, sp, args) => {
+    const tokens = args.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+    const paths = [];
+    let i = 0;
+    while (i < tokens.length && !String(tokens[i]).startsWith('-')) {
+      paths.push(tokens[i]);
+      i++;
+    }
+    const rest = tokens.slice(i);
+    const hasMax = rest.some((t) => t === '-maxdepth');
+    const pin = (raw) => {
+      const unquoted = String(raw).replace(/^['"]|['"]$/g, '');
+      if (!unquoted || unquoted === '.' || unquoted === './') return '.';
+      const abs = path.resolve(root, unquoted);
+      const inside = abs === root || abs.startsWith(root + path.sep);
+      return inside ? raw : '.';
+    };
+    const newPaths = (paths.length ? paths.map(pin) : ['.']);
+    const depth = hasMax ? [] : ['-maxdepth', String(FIND_MAXDEPTH)];
+    return `${pre}${sudo}find${sp}${[...newPaths, ...depth, ...rest].join(' ')}`;
+  });
+}

package/lib/spill.js

@@ -1916,7 +1916,15 @@ function emptySpillDecision(msgs, reason) {
 export function decideChatSpill(body, opts = {}) {
   const msgs = Array.isArray(body?.messages) ? body.messages : null;
   if (!msgs?.length) return emptySpillDecision(msgs, 'no-messages');
-  const minChars = opts.minPrefixChars ?? SPILL_MIN_PREFIX_CHARS;
+  let minChars = opts.minPrefixChars ?? SPILL_MIN_PREFIX_CHARS;
+  const dx = Number(opts.dollarX);
+  const model = String(body?.model || '').trim().toLowerCase();
+  const auto = model === 'openzoo/auto' || model === 'openzoo-auto' || model === 'auto';
+  // Thin HUD / Auto: bind way earlier than 16k. 2.1x session is cheap-model
+  // vs cheap-model because the prefix never cleared the gate.
+  if (auto || (Number.isFinite(dx) && dx > 0 && dx < 5)) {
+    minChars = Math.min(minChars, 2048);
+  }
 
   if (isOneShotCorpusAsk(msgs, minChars)) {
     const last = msgs[msgs.length - 1];

package/lib/think.js

@@ -0,0 +1,126 @@
+/**
+ * Model reasoning arrives on several wires:
+ *   - leaked `<think>…</think>` / `<thinking>…` in the visible reply
+ *   - `reasoning_content` / `reasoning` / `thinking` / `thought` on the delta
+ *   - provider objects with a plaintext summary next to encrypted blobs
+ *
+ * Encrypted reasoning is not a thought we can show — never dump ciphertext
+ * into the canvas. Empty plaintext means no thinking chip.
+ */
+
+const THINK_BLOCK = /<think(?:ing)?\b[^>]*>[\s\S]*?<\/think(?:ing)?>/gi;
+const THINK_OPEN = /<think(?:ing)?\b[^>]*>[\s\S]*$/i;
+const THINK_CLOSE = /<\/think(?:ing)?>/gi;
+
+const REASON_KEYS = [
+  'reasoning_content',
+  'reasoning',
+  'reasoning_details',
+  'thinking',
+  'thought',
+  'thoughts',
+  'reasoning_text',
+  'summary',
+  'text',
+];
+
+export function looksEncryptedReasoning(s) {
+  const t = String(s || '').trim();
+  if (t.length < 48) return false;
+  if (/\s/.test(t)) return false;
+  return /^[A-Za-z0-9+/_=-]+$/.test(t);
+}
+
+function keyLooksEncrypted(key) {
+  return /encrypt/i.test(String(key || ''));
+}
+
+/**
+ * Pull displayable reasoning out of a provider field. Strings that look like
+ * ciphertext, and objects typed/keyed as encrypted, become ''.
+ */
+export function reasoningPlaintext(value, depth = 0) {
+  if (value == null || depth > 6) return '';
+  if (typeof value === 'string') return looksEncryptedReasoning(value) ? '' : value;
+  if (typeof value !== 'object') return '';
+  if (Array.isArray(value)) {
+    return value.map((x) => reasoningPlaintext(x, depth + 1)).filter(Boolean).join('');
+  }
+  const type = String(value.type || value.kind || '');
+  if (/encrypt/i.test(type)) return '';
+  const parts = [];
+  for (const key of REASON_KEYS) {
+    if (!(key in value) || keyLooksEncrypted(key)) continue;
+    const inner = reasoningPlaintext(value[key], depth + 1);
+    if (inner) parts.push(inner);
+  }
+  return parts.join('');
+}
+
+/** True when a delta/message carried a reasoning field, including encrypted. */
+export function reasoningPresent(delta, message) {
+  for (const src of [delta, message]) {
+    if (!src || typeof src !== 'object') continue;
+    if (src.reasoning_content != null || src.reasoning != null
+      || src.reasoning_details != null || src.thinking != null
+      || src.thought != null || src.thoughts != null
+      || src.reasoning_text != null || src.encrypted_content != null
+      || src.reasoning_encrypted_content != null) return true;
+  }
+  return false;
+}
+
+/** Reasoning on a chat message or stream delta — never `message.content`. */
+export function messageReasoning(msg, delta) {
+  const blobs = [];
+  for (const src of [delta, msg]) {
+    if (!src || typeof src !== 'object') continue;
+    blobs.push(reasoningPlaintext(src.reasoning_content));
+    blobs.push(reasoningPlaintext(src.reasoning));
+    blobs.push(reasoningPlaintext(src.reasoning_details));
+    blobs.push(reasoningPlaintext(src.thinking));
+    blobs.push(reasoningPlaintext(src.thought));
+    blobs.push(reasoningPlaintext(src.thoughts));
+    blobs.push(reasoningPlaintext(src.reasoning_text));
+  }
+  return blobs.filter((s) => String(s || '').trim()).join('');
+}
+
+export function splitThink(text) {
+  const thoughts = [];
+  let s = String(text ?? '');
+  s = s.replace(THINK_BLOCK, (m) => {
+    const a = m.indexOf('>');
+    const b = m.toLowerCase().lastIndexOf('</think');
+    if (a >= 0 && b > a) thoughts.push(m.slice(a + 1, b));
+    return '';
+  });
+  s = s.replace(THINK_OPEN, (m) => {
+    const a = m.indexOf('>');
+    thoughts.push(a >= 0 ? m.slice(a + 1) : '');
+    return '';
+  });
+  s = s.replace(THINK_CLOSE, '');
+  const visible = s.replace(/^\n+|\n+$/g, '').trim();
+  const thinking = thoughts.join('\n').replace(/^\n+|\n+$/g, '').trim();
+  return { visible, thinking };
+}
+
+export function stripThinkTags(text) {
+  return splitThink(text).visible;
+}
+
+export function wrapThink(thinking, visible) {
+  const t = String(thinking || '').trim();
+  const v = String(visible || '');
+  if (!t) return v;
+  return `<think>${t}</think>\n${v}`;
+}
+
+/** Persist thinking on a history row; never leave tags in the visible text. */
+export function takeThink(raw, extraThink) {
+  const parts = splitThink(raw);
+  const extra = String(extraThink || '').trim();
+  const thinking = [extra, parts.thinking].filter(Boolean).join('\n').trim();
+  return { text: parts.visible, thinking: thinking || undefined };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openzoo",
-  "version": "0.49.7",
-  "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.",
+  "version": "0.49.9",
+  "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.",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -10,13 +10,14 @@
   "files": [
     "bin",
     "lib",
-    "README.md"
+    "README.md",
+    "vendor/modelroute"
   ],
   "engines": {
     "node": ">=18"
   },
   "scripts": {
-    "test": "node --test test/*.test.js && node scripts/assert-grokui-pin.mjs"
+    "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"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",