openzoo 0.49.8 → 0.49.10

package/lib/proxy.js

@@ -20,12 +20,17 @@ import {
   corpusRecall,
   decideChatSpill, isOneShotCorpusAsk,
 } from './spill.js';
-import { rewritablePath, modelsListForRequest, ALIAS_IDS, rewriteChatModel, zooModelIds, CLASSIFY_MAX_TOKENS } from './models.js';
+import { rewritablePath, modelsListForRequest, isHarnessAliasId, rewriteChatModel, zooModelIds, CLASSIFY_MAX_TOKENS, raiseReasoningMaxTokens, isAutoModel } from './models.js';
+import {
+  route as routeTask, routeChatBody, fallbackChain, isRetryableStatus,
+  outcomeFromResponse, recordRouteOutcome, autoModelListEntry,
+} from './modelroute.js';
 import { forgetContext } from './contexts.js';
 import { injectBrief } from './brief.js';
 import { withNamespace } from './namespace.js';
 import { anthropicToOpenAI, openAIToAnthropic, streamOpenAIToAnthropic, writeAnthropicSse } from './anthropic.js';
 import { responsesToChat, chatToResponses, writeResponsesSse } from './responses.js';
+import { streamOpenAIToResponses } from './responses-stream.js';
 import { loadSessionSpend, saveSessionSpend } from './session.js';
 import { creditBalance, quotedPrices } from './info.js';
 import { subscriptionPublicView } from './subscription.js';
@@ -1197,6 +1202,35 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       return;
     }
 
+    // Local decision � no upstream, no payment. Same keys as Python route().
+    {
+      const routePath = (req.url || '').split('?')[0];
+      if (req.method === 'POST' && (routePath === '/route' || routePath === '/v1/route')) {
+        let payload;
+        try { payload = JSON.parse(bodyBuf.toString('utf8') || '{}'); } catch {
+          jsonErr(res, 400, 'invalid /route body');
+          return;
+        }
+        try {
+          const r = routeTask(payload.text ?? '', {
+            allow_free: payload.allow_free ?? false,
+            bindable: payload.bindable ?? true,
+            context: payload.context,
+            input_tokens: payload.input_tokens,
+            has_image: payload.has_image,
+            needs_tools: payload.needs_tools,
+            needs_json: payload.needs_json,
+            ...(payload.constraints && typeof payload.constraints === 'object' ? payload.constraints : {}),
+          });
+          res.writeHead(200, { 'content-type': 'application/json' });
+          res.end(JSON.stringify(r));
+        } catch (err) {
+          jsonErr(res, 500, `openzoo /route: ${err.message}`);
+        }
+        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
@@ -1244,7 +1278,11 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         }
         responsesModel = inbound.model;
         const meta = {};
-        bodyBuf = Buffer.from(JSON.stringify(responsesToChat(inbound, meta)));
+        const translated = responsesToChat(inbound, meta);
+        // Codex's watchdog is ~10s to first SSE byte. Force stream so we can
+        // emit response.created immediately instead of buffering Opus.
+        translated.stream = true;
+        bodyBuf = Buffer.from(JSON.stringify(translated));
         responsesCustom = meta.custom;
         responsesMode = true;
         req.url = '/v1/chat/completions';
@@ -1299,6 +1337,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
     // carries a model field, not just chat/completions, so /completions,
     // /responses and future shapes all work. Never silent.
     let wantsStream = false;
+    let autoRoute = null;
       if ((req.url || '').includes('/chat/completions') && req.method === 'POST') {
         servedRequests += 1;
         say(`\n<- request #${servedRequests} from ${(req.headers['user-agent'] || 'unknown').slice(0, 40)}`);
@@ -1332,6 +1371,26 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         try { ids = await zooModelIds(); } catch { /* catalog miss: still skip the floor on a tiny classify */ }
         const policy = rewriteChatModel(parsed, ids, { bodyLen: bodyBuf.length });
         parsed = policy.parsed;
+        if (!policy.tiny && (policy.auto || isAutoModel(parsed?.model))) {
+          autoRoute = routeChatBody(parsed, {
+            allow_free: false,
+            bindable: true,
+            // Live quoteable ids only � Auto must never emit :batch / $0 /
+            // missing-price rows that 500 `bad openrouter price` on Fly.
+            ...(ids.length ? { allow_ids: ids } : {}),
+          });
+          if (!autoRoute.model) {
+            jsonErr(res, 422, autoRoute.reason || 'openzoo/auto: no feasible model', { route: autoRoute });
+            return;
+          }
+          parsed = { ...parsed, model: autoRoute.model };
+          const bump = raiseReasoningMaxTokens(parsed);
+          parsed = bump.parsed;
+          say(`openzoo/auto -> ${autoRoute.model} p=${autoRoute.p_success} cleared=${autoRoute.cleared_bar} ${autoRoute.task_class}${autoRoute.bind_first ? ' bind_first' : ''}`);
+          if (!autoRoute.cleared_bar) {
+            say(`openzoo/auto cleared_bar=false � strongest fallback, not a normal pick`);
+          }
+        }
         if (policy.tiny) {
           // `openzoo claude` starts us silent � `log` is a no-op then. say()
           // is the proxy.log channel and never the Claude Code TTY.
@@ -1381,7 +1440,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
             log(`reasoning model ${parsed.model}: max_tokens ${policy.raisedFrom} -> ${policy.raisedTo} (thinking shares the budget; OPENZOO_REASONING_MAX_TOKENS_X=1 disables)`);
           }
         }
-        if (policy.tiny || policy.raised || (policy.to && policy.to !== policy.from)) {
+        if (policy.tiny || policy.raised || autoRoute || (policy.to && policy.to !== policy.from)) {
           bodyBuf = Buffer.from(JSON.stringify(parsed));
         }
         // Tell the agent what it is actually connected to — in band, where it
@@ -1508,9 +1567,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         const response = await fetchHeaders(url, init);
         if (response.ok) {
           const payload = await response.json();
-          // Full zoo catalog � never collapse to a single opus-5 or a claude-*
-          // allowlist. Claude Code (ANTHROPIC_BASE_URL + gateway discovery) reads
-          // data[].id / display_name; OpenAI clients keep object:"list".
+          // Quoteable catalog only. Raw OpenRouter dump includes :batch,
+          // $0 / missing prices, and we used to mint openzoo-* twins of each
+          // � Claude Code /model then showed 63 clones and Auto 500'd.
           res.writeHead(200, { 'content-type': 'application/json' });
           res.end(JSON.stringify(modelsListForRequest(payload, req.headers)));
           return;
@@ -1522,7 +1581,12 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       return;
     }
     const probe = req.method === 'GET' && /^\/v1\/models\/(.+)$/.exec(path);
-    if (probe && ALIAS_IDS.includes(decodeURIComponent(probe[1]))) {
+    if (probe && isAutoModel(decodeURIComponent(probe[1]))) {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify(autoModelListEntry()));
+      return;
+    }
+    if (probe && isHarnessAliasId(decodeURIComponent(probe[1]))) {
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end(JSON.stringify({ id: decodeURIComponent(probe[1]), object: 'model', owned_by: 'openzoo-alias' }));
       return;
@@ -1592,6 +1656,32 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       } else {
         result = await client.fetch(url, init);
       }
+      // Walk the auto shortlist on 429/5xx � cheapest-first among models that
+      // cleared the bar. Finite: one pass over fallbackChain(), never a loop.
+      if (autoRoute?.cleared_bar && isRetryableStatus(result.response.status)) {
+        const chain = fallbackChain(autoRoute);
+        for (const next of chain) {
+          const failed = result.response.status;
+          try { await result.response.arrayBuffer(); } catch { /* drain */ }
+          say(`openzoo/auto fallback HTTP ${failed} -> ${next}`);
+          const rewriteModel = (buf) => {
+            try {
+              const b = JSON.parse(buf.toString('utf8'));
+              b.model = next;
+              return Buffer.from(JSON.stringify(b));
+            } catch { return buf; }
+          };
+          bodyBuf = rewriteModel(bodyBuf);
+          init.body = bodyBuf;
+          if (cached) {
+            cached = { ...cached, body: rewriteModel(cached.body) };
+            result = await send(cached.body, cached.contextId, cached.topK, corpusCharsForSend(boundChars, cached.contextId, cached.corpus?.length));
+          } else {
+            result = await client.fetch(url, { ...init, body: bodyBuf });
+          }
+          if (!isRetryableStatus(result.response.status)) break;
+        }
+      }
       const { response, paid, receipt } = result;
       if (paid && receipt) {
         if (receipt.ok && typeof receipt.billedUsd === 'number') {
@@ -1636,6 +1726,13 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       // 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') || '';
+      const noteAutoOutcome = (status, data, streamed = false) => {
+        if (!autoRoute) return;
+        let ok = outcomeFromResponse(status, data);
+        if (ok == null) return;
+        if (streamed && status >= 200 && status < 300) ok = true;
+        recordRouteOutcome(autoRoute, ok);
+      };
       if (isChat && response.ok && upCt.includes('application/json')) {
         let data = null;
         try { data = await response.clone().json(); } catch { /* not JSON after all */ }
@@ -1694,6 +1791,7 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
           say(`credit -> $${x.billedUsd.toFixed(6)}  ·  session $${sessionSpent.toFixed(6)}`);
         }
         if (data?.object === 'chat.completion') {
+          noteAutoOutcome(response.status, data);
           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.
@@ -1759,6 +1857,39 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         say(`credit -> $${x.billedUsd.toFixed(6)}  ·  session $${sessionSpent.toFixed(6)}`);
       };
 
+      // RESPONSES CLIENTS (Codex Security) GET THE SAME STREAM, IN THEIR GRAMMAR.
+      // Without this, relay() pipes OpenAI SSE frames at a client waiting for
+      // response.created, and the 10s watchdog fires ("connection interrupted").
+      if (responsesMode && wantsStream
+          && (response.headers.get('content-type') || '').includes('text/event-stream')
+          && response.ok && response.body) {
+        const tr = streamOpenAIToResponses(res, response, responsesModel, responsesCustom);
+        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 */ }
+            }
+          }
+        } catch (e) {
+          log(`responses stream aborted: ${e.message}`);
+        }
+        tr.finish();
+        return;
+      }
+
       // 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.
@@ -1792,6 +1923,9 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         return;
       }
 
+      if (autoRoute) {
+        noteAutoOutcome(response.status, null, (upCt.includes('text/event-stream') && response.ok));
+      }
       await relay(res, response, meterStreamed);
     } catch (err) {
       if (err instanceof QuoteTooHighError) {

package/lib/racesettle.js

@@ -255,7 +255,16 @@ export function isQuoteReserveBilled(billed, cost, x = {}) {
  * 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);
+  // The gateway now sets `usage.billedUsd` explicitly, and it is exactly the
+  // settled figure this function spends the rest of its body reconstructing
+  // from tokens and prices. Take it when it is there; the reconstruction below
+  // stays for older gateways and for the race path, which has no single
+  // billed number of its own.
+  const direct = money(usage?.billedUsd);
+  if (direct != null) return direct;
+  // See pairActualBilled: `usage.cost` is our price now, not upstream's.
+  const cost = money(usage?.cost_details?.upstream_inference_cost)
+    ?? money(usage?.cost) ?? money(x?.actualUsd) ?? money(usage?.actualUsd);
   const explicit = explicitSettledBilled(x, usage);
   if (explicit != null) return explicit;
 
@@ -295,7 +304,19 @@ function settledSavedUsd(x, cost) {
  * 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);
+  // `usage.cost` IS NO LONGER THE UPSTREAM FIGURE. The gateway now reports OUR
+  // price there, because that is the field every generic OpenAI-compatible
+  // client reads and they were all showing what OpenRouter charged us instead
+  // of what the caller was charged. The upstream number moved to
+  // `cost_details.upstream_inference_cost`, which is where OpenRouter itself
+  // publishes it.
+  //
+  // This is the HUD's DENOMINATOR, so reading the new `usage.cost` here would
+  // divide billed by billed and print 1× on every call regardless of markup.
+  // Prefer the explicit upstream field; fall back to `usage.cost` only for
+  // responses from a gateway old enough to predate the move.
+  const fromUpstream = money(usage?.cost_details?.upstream_inference_cost);
+  const fromUsage = fromUpstream ?? money(usage?.cost);
   const fromX = money(x402?.actualUsd) ?? money(x402?.usage?.cost);
   const upstreamUsd = fromUsage ?? fromX;
   if (upstreamUsd == null) return null;

package/lib/responses-stream.js

@@ -0,0 +1,176 @@
+/**
+ * OpenAI chat-completions SSE -> Responses API SSE, frame by frame.
+ *
+ * WHY: Codex Security pins wire_api=responses and waits ~10s for
+ * `response.created`. The previous path buffered the whole chat completion
+ * (Opus reasoning can sit silent for longer than that) then dumped the
+ * event sequence at the end. Codex reported "connection interrupted".
+ *
+ * Same shape as streamOpenAIToAnthropic: write headers immediately, ping on
+ * silent reasoning chunks, translate content/tool deltas as they arrive.
+ */
+export function streamOpenAIToResponses(res, upstream, requestedModel, custom) {
+  const headers = {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache',
+    connection: 'keep-alive',
+    'x-accel-buffering': 'no',
+  };
+  const settle = upstream?.headers?.get?.('x-payment-response');
+  if (settle) headers['x-payment-response'] = settle;
+  res.writeHead(200, headers);
+
+  let seq = 0;
+  const send = (type, payload = {}) => {
+    res.write(`event: ${type}\n`);
+    res.write(`data: ${JSON.stringify({ type, sequence_number: seq++, ...payload })}\n\n`);
+  };
+
+  const customNames = custom instanceof Set ? custom : new Set(custom || []);
+  const responseId = `resp_${Date.now().toString(36)}`;
+  const itemId = `msg_${Math.random().toString(36).slice(2, 10)}`;
+  const shell = {
+    id: responseId,
+    object: 'response',
+    created_at: Math.floor(Date.now() / 1000),
+    status: 'in_progress',
+    model: requestedModel,
+    output: [],
+    output_text: '',
+  };
+
+  // First bytes NOW — do not wait for a content token. Codex's watchdog is ~10s
+  // and a reasoning model can think for longer than that before delta.content.
+  send('response.created', { response: shell });
+  send('response.in_progress', { response: shell });
+
+  let textStarted = false;
+  let text = '';
+  const tools = [];
+
+  const unwrapCustom = (args) => {
+    try {
+      const o = JSON.parse(args);
+      if (o && typeof o.input === 'string') return o.input;
+    } catch { /* raw text */ }
+    return args;
+  };
+
+  const ensureText = () => {
+    if (textStarted) return;
+    textStarted = true;
+    send('response.output_item.added', {
+      output_index: 0,
+      item: { id: itemId, type: 'message', role: 'assistant', status: 'in_progress', content: [] },
+    });
+    send('response.content_part.added', {
+      item_id: itemId, output_index: 0, content_index: 0,
+      part: { type: 'output_text', text: '', annotations: [] },
+    });
+  };
+
+  const toolIndexBase = () => (textStarted ? 1 : 0);
+
+  const onChunk = (d) => {
+    const ch = (d.choices ?? [])[0];
+    if (!ch) {
+      send('response.in_progress', { response: shell });
+      return;
+    }
+    const delta = ch.delta ?? {};
+    let spoke = false;
+    if (typeof delta.content === 'string' && delta.content.length) {
+      spoke = true;
+      ensureText();
+      text += delta.content;
+      send('response.output_text.delta', {
+        item_id: itemId, output_index: 0, content_index: 0, delta: delta.content,
+      });
+    }
+    for (const tc of (delta.tool_calls ?? [])) {
+      spoke = true;
+      const idx = Number.isInteger(tc.index) ? tc.index : tools.length;
+      if (!tools[idx]) {
+        const id = tc.id || `call_${idx}`;
+        const name = tc.function?.name || '';
+        const isCustom = customNames.has(name);
+        tools[idx] = {
+          id, call_id: id, name, arguments: '',
+          type: isCustom ? 'custom_tool_call' : 'function_call',
+        };
+        send('response.output_item.added', {
+          output_index: toolIndexBase() + idx,
+          item: {
+            id, type: tools[idx].type, status: 'in_progress',
+            call_id: id, name, arguments: '',
+          },
+        });
+      }
+      const piece = tc.function?.arguments || '';
+      if (!piece) continue;
+      tools[idx].arguments += piece;
+      const isCustom = tools[idx].type === 'custom_tool_call';
+      // Custom tools want raw text, but stream pieces are JSON fragments of
+      // {input:"..."}. Buffer and emit once at finish. Function tools stream.
+      if (!isCustom) {
+        send('response.function_call_arguments.delta', {
+          item_id: tools[idx].id,
+          output_index: toolIndexBase() + idx,
+          delta: piece,
+        });
+      }
+    }
+    if (!spoke) send('response.in_progress', { response: shell });
+  };
+
+  const finish = () => {
+    if (textStarted) {
+      send('response.output_text.done', {
+        item_id: itemId, output_index: 0, content_index: 0, text,
+      });
+      send('response.content_part.done', {
+        item_id: itemId, output_index: 0, content_index: 0,
+        part: { type: 'output_text', text, annotations: [] },
+      });
+      send('response.output_item.done', {
+        output_index: 0,
+        item: {
+          id: itemId, type: 'message', role: 'assistant', status: 'completed',
+          content: [{ type: 'output_text', text, annotations: [] }],
+        },
+      });
+    }
+    const output = [];
+    if (textStarted) {
+      output.push({
+        id: itemId, type: 'message', role: 'assistant', status: 'completed',
+        content: [{ type: 'output_text', text, annotations: [] }],
+      });
+    }
+    tools.forEach((call, i) => {
+      if (!call) return;
+      const idx = toolIndexBase() + i;
+      const isCustom = call.type === 'custom_tool_call';
+      const raw = isCustom ? unwrapCustom(call.arguments) : call.arguments;
+      send(isCustom ? 'response.custom_tool_call_input.delta' : 'response.function_call_arguments.delta', {
+        item_id: call.id, output_index: idx, delta: isCustom ? raw : '',
+      });
+      send(isCustom ? 'response.custom_tool_call_input.done' : 'response.function_call_arguments.done', {
+        item_id: call.id, output_index: idx,
+        ...(isCustom ? { input: raw } : { arguments: call.arguments }),
+      });
+      const item = isCustom
+        ? { id: call.id, type: 'custom_tool_call', status: 'completed', call_id: call.call_id, name: call.name, input: raw }
+        : { id: call.id, type: 'function_call', status: 'completed', call_id: call.call_id, name: call.name, arguments: call.arguments };
+      send('response.output_item.done', { output_index: idx, item });
+      output.push(item);
+    });
+    send('response.completed', {
+      response: { ...shell, status: 'completed', output, output_text: text },
+    });
+    res.write('data: [DONE]\n\n');
+    res.end();
+  };
+
+  return { onChunk, finish };
+}

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