openzoo 0.49.8 → 0.49.9

package/lib/models.js

@@ -1,5 +1,11 @@
 import { config } from './config.js';
 import { fetchHeaders } from './fetch.js';
+import {
+  AUTO_MODEL_ID, autoHasPricedModels, autoModelListEntry, isAutoModel,
+  isPricedTokenPair, isUnservableRouteId,
+} from './modelroute.js';
+
+export { AUTO_MODEL_ID, isAutoModel, isPricedTokenPair, isUnservableRouteId };
 
 /** Same threshold as BIND_MIN_CHARS in hrr.js — kept local so this
  *  module stays importable without the wallet/rpc stack. */
@@ -50,18 +56,43 @@ export function editorSlot(id) {
 }
 
 const CATALOG_TTL_MS = 5 * 60 * 1000;
-let cache = { at: 0, ids: null };
+let cache = { at: 0, ids: null, base: null };
+
+export function resetZooModelIdsCache() {
+  cache = { at: 0, ids: null, base: null };
+}
 
 export async function zooModelIds() {
-  if (cache.ids && Date.now() - cache.at < CATALOG_TTL_MS) return cache.ids;
+  if (cache.ids && cache.base === config.apiBase && Date.now() - cache.at < CATALOG_TTL_MS) return cache.ids;
   const r = await fetchHeaders(`${config.apiBase}/v1/models`);
   if (!r.ok) throw new Error(`model catalog fetch failed: HTTP ${r.status}`);
   const d = await r.json();
-  const ids = (d.data || []).map((m) => m.id).filter(Boolean);
-  if (ids.length) cache = { at: Date.now(), ids };
+  const ids = quoteableRows(d.data).map((m) => m.id).filter((id) => id && !isAutoModel(id));
+  if (ids.length) cache = { at: Date.now(), ids, base: config.apiBase };
   return ids;
 }
 
+/** OpenRouter / gateway token price pair. Image/video rows have no prompt. */
+export function tokenPricePair(pricing) {
+  if (!pricing || typeof pricing !== 'object') return [NaN, NaN];
+  return [Number(pricing.prompt ?? pricing.input), Number(pricing.completion ?? pricing.output)];
+}
+
+/**
+ * A row the gateway can actually quote for chat. Drops :batch, ~latest
+ * pointers, openzoo-* twins, $0 / missing / non-token OpenRouter prices.
+ */
+export function isQuoteableModel(m) {
+  const id = m?.id;
+  if (isAutoModel(id)) return true;
+  if (isUnservableRouteId(id)) return false;
+  return isPricedTokenPair(...tokenPricePair(m?.pricing));
+}
+
+export function quoteableRows(data) {
+  return (Array.isArray(data) ? data : []).filter(isQuoteableModel);
+}
+
 /** Vendor fingerprints in harness model ids → zoo catalog prefixes. Order
  *  matters only for overlapping hints; first match wins. */
 const FAMILIES = [
@@ -119,6 +150,14 @@ const tokensOf = (id) => id.toLowerCase().split(/[^a-z0-9.]+/).filter((t) => t &
  * OPENZOO_DEFAULT_MODEL is an explicit user override, not a fallback tier.
  */
 export function resolveModel(requested, ids) {
+  // Virtual router id — never family-match, never steal via OPENZOO_DEFAULT_MODEL.
+  if (isAutoModel(requested)) return null;
+  // Bare Anthropic / Claude Code ids are never live on Fly/OpenRouter
+  // (`claude-opus-5` → 500 unknown model). Rewrite even on a catalog miss
+  // or if a gateway row lists the bare name — the request must not leave
+  // the sidecar as that id.
+  const native = anthropicNativeAlias(requested);
+  if (native) return native;
   if (!requested || !ids?.length || ids.includes(requested)) return null;
   // `openzoo-` prefixed names exist so an editor cannot mistake them for its
   // OWN models: Cursor claims any name in its catalog (claude-opus-5, grok-4.6)
@@ -187,6 +226,46 @@ export function resolveModel(requested, ids) {
   return best;
 }
 
+/**
+ * Bare Anthropic / Claude Code ids. MEASURED 2026-08-20 against Fly
+ * x402-tokens: POST /v1/chat/completions model=claude-opus-5 → 500
+ * `unknown model claude-opus-5`. The vendor-prefixed twin
+ * (`anthropic/claude-opus-5`) 402s and is priced. Claude Code's Auto
+ * permission classifier calls these ids on ANTHROPIC_BASE_URL; if the
+ * sidecar forwards the bare name, Bash hangs with
+ * "claude-opus-5 is temporarily unavailable, so auto mode cannot
+ * determine the safety of Bash". Always rewrite. Never send the bare
+ * id to OpenRouter / Fly. Do not push x402-tokens — alias here.
+ */
+export const ANTHROPIC_NATIVE_ALIASES = {
+  'claude-opus-5': 'anthropic/claude-opus-5',
+  'claude-opus-5-fast': 'anthropic/claude-opus-5-fast',
+  'claude-3-5-opus': 'anthropic/claude-opus-5',
+  'claude-sonnet-5': 'anthropic/claude-sonnet-5',
+  'claude-sonnet-5-fast': 'anthropic/claude-sonnet-5',
+  'claude-opus-4-8': 'anthropic/claude-opus-4.8',
+  'claude-opus-4.8': 'anthropic/claude-opus-4.8',
+  'claude-fable-5': 'anthropic/claude-fable-5',
+  'claude-haiku-4.5': 'anthropic/claude-haiku-4.5',
+};
+
+/** Claude Code sometimes suffixes a window marker (`claude-opus-5[1m]`). */
+function stripAnthropicWindowSuffix(id) {
+  return String(id || '').trim().replace(/\[[\d]+m\]$/i, '');
+}
+
+/**
+ * Priced zoo twin for a bare Anthropic / Claude Code id, or null.
+ * Vendor-prefixed ids and openzoo-* twins are left to the rest of resolveModel.
+ */
+export function anthropicNativeAlias(requested) {
+  if (!requested || typeof requested !== 'string') return null;
+  const stripped = stripAnthropicWindowSuffix(requested);
+  if (!stripped || stripped.includes('/')) return null;
+  if (/^openzoo[-/]/i.test(stripped)) return null;
+  return ANTHROPIC_NATIVE_ALIASES[stripped] || ANTHROPIC_NATIVE_ALIASES[stripped.toLowerCase()] || null;
+}
+
 /**
  * Ids harnesses ship as DEFAULTS (Cursor, Continue, Aider, Codex CLI, Cline,
  * OpenClaw, LangChain templates…). Merged into GET /v1/models so a harness
@@ -197,58 +276,51 @@ export const ALIAS_IDS = [
   'gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-4-turbo', 'gpt-3.5-turbo',
   'gpt-5', 'gpt-5-mini', 'chatgpt-4o-latest', 'o1', 'o3', 'o3-mini', 'o4-mini',
   'claude-3-5-sonnet-latest', 'claude-sonnet-4-0', 'claude-opus-4-1',
+  'claude-opus-5', 'claude-opus-5-fast', 'claude-3-5-opus', 'claude-sonnet-5',
+  'claude-opus-4-8', 'claude-fable-5',
   'gemini-2.5-pro', 'gemini-2.5-flash', 'grok-4', 'grok-3',
   'deepseek-chat', 'deepseek-reasoner', 'qwen-max', 'llama-3.3-70b',
 ];
 
+export function isHarnessAliasId(id) {
+  const stripped = stripAnthropicWindowSuffix(id);
+  return ALIAS_IDS.includes(stripped) || Boolean(anthropicNativeAlias(stripped));
+}
+
 /**
  * Merge alias rows into a /v1/models payload without duplicating real ids.
  * Each alias inherits context_length and pricing from the model it RESOLVES
  * to — a harness sizing its corpus off "gpt-4o" gets the real ceiling of the
  * model that will actually serve it, not a blank.
+ *
+ * Does not mint openzoo-* twins. Those duplicated every real id (and every
+ * :batch id) in Claude Code's /model picker.
  */
-export function augmentModelList(payload) {
-  const data = Array.isArray(payload?.data) ? payload.data : [];
+export function augmentModelList(payload, { aliases: withAliases = true } = {}) {
+  const data = quoteableRows(payload?.data);
   const have = new Set(data.map((m) => m.id));
   const ids = data.map((m) => m.id);
-  // openzoo-* twins of the popular models. An editor that validates a custom
-  // model against THIS list (Cursor's "Add model" box reports "No models
-  // available" for anything missing here) can only offer what we publish — and
-  // the openzoo- prefix is what stops it claiming the name as one of its own
-  // built-ins and routing to its backend instead of to us.
-  const branded = [];
-  for (const src0 of data) {
-    const id = src0.id;
-    // Brand only REAL upstream models. Anything we synthesised (a twin or a
-    // harness alias) must be skipped, or augmenting an already-augmented
-    // payload mints openzoo-openzoo-* and the catalog grows every pass.
-    if (!id || id.startsWith('openzoo-') || String(src0.owned_by || '').startsWith('openzoo')) continue;
-    const short = id.includes('/') ? id.split('/')[1] : id;
-    const name = `openzoo-${short}`;
-    if (have.has(name)) continue;
-    const src = data.find((m) => m.id === id);
-    branded.push({
-      id: name,
-      object: 'model',
-      owned_by: 'openzoo',
-      served_by: id,
-      ...(src?.context_length ? { context_length: src.context_length, context_window: src.context_window ?? src.context_length } : {}),
-      ...(src?.pricing ? { pricing: src.pricing } : {}),
-    });
-    have.add(name);
+  const aliases = withAliases
+    ? ALIAS_IDS.filter((id) => !have.has(id)).map((id) => {
+      const target = data.find((m) => m.id === resolveModel(id, ids));
+      return {
+        id,
+        object: 'model',
+        owned_by: 'openzoo-alias',
+        ...(target?.context_length ? { context_length: target.context_length, context_window: target.context_window ?? target.context_length } : {}),
+        ...(target?.pricing ? { pricing: target.pricing } : {}),
+        ...(target ? { served_by: target.id } : {}),
+      };
+    })
+    : [];
+  const virtual = [];
+  // Auto is listed only when its own shortlist is priced models — never an
+  // unquoted OpenRouter id that 500s `bad openrouter price`.
+  if (!have.has(AUTO_MODEL_ID) && autoHasPricedModels(undefined, ids.length ? ids : null)) {
+    virtual.push(autoModelListEntry());
+    have.add(AUTO_MODEL_ID);
   }
-  const aliases = ALIAS_IDS.filter((id) => !have.has(id)).map((id) => {
-    const target = data.find((m) => m.id === resolveModel(id, ids));
-    return {
-      id,
-      object: 'model',
-      owned_by: 'openzoo-alias',
-      ...(target?.context_length ? { context_length: target.context_length, context_window: target.context_window ?? target.context_length } : {}),
-      ...(target?.pricing ? { pricing: target.pricing } : {}),
-      ...(target ? { served_by: target.id } : {}),
-    };
-  });
-  return { ...payload, object: payload?.object || 'list', data: [...data, ...branded, ...aliases] };
+  return { ...payload, object: payload?.object || 'list', data: [...virtual, ...data, ...aliases] };
 }
 
 /**
@@ -277,14 +349,12 @@ function decorateModelEntry(m) {
 }
 
 /**
- * OpenAI-compatible /v1/models body Claude Code and every other harness can
- * read. The full zoo catalog is kept — no claude-* filter, no single opus-5
- * collapse. Extra Anthropic fields (`type`, `display_name`) sit alongside
- * OpenAI ones so a Messages-API client can label rows without a second
- * endpoint. Existing OpenAI clients ignore the extras.
+ * OpenAI-compatible /v1/models body. Quoteable chat models only — no :batch,
+ * no unpriced / image-video rows, no openzoo-* twins. Extra Anthropic fields
+ * (`type`, `display_name`) sit alongside OpenAI ones.
  */
-export function publishModelList(payload) {
-  const merged = augmentModelList(payload);
+export function publishModelList(payload, opts) {
+  const merged = augmentModelList(payload, opts);
   const data = (merged.data || []).map(decorateModelEntry);
   return {
     ...merged,
@@ -296,21 +366,37 @@ export function publishModelList(payload) {
   };
 }
 
-/**
- * Anthropic GET /v1/models shape (id + display_name + type).
- * Claude Code gateway discovery reads `data[].id` and optional `display_name`.
- * Ids are the zoo's real catalog ids — never rewritten to fake `claude-*`
- * aliases for grok / deepseek / gemini / etc.
- */
-export function anthropicModelList(payload) {
-  const published = publishModelList(payload);
-  const data = (published.data || []).map((m) => ({
+function anthropicRows(rows) {
+  return rows.map((m) => ({
     type: 'model',
     id: m.id,
     display_name: m.display_name || displayNameFor(m.id),
     ...(m.created_at ? { created_at: m.created_at } : {}),
     ...(m.served_by ? { served_by: m.served_by } : {}),
   }));
+}
+
+/** openzoo/auto first so Claude Code's picker default is the router, not opus. */
+function withAutoFirst(rows) {
+  const list = Array.isArray(rows) ? rows.slice() : [];
+  const i = list.findIndex((m) => isAutoModel(m?.id));
+  if (i > 0) {
+    const [auto] = list.splice(i, 1);
+    list.unshift(auto);
+  }
+  return list;
+}
+
+/**
+ * Anthropic GET /v1/models shape (id + display_name + type).
+ * Claude Code gateway discovery reads `data[].id` and optional `display_name`.
+ * Full quoteable catalog — every priced published id, including OpenRouter
+ * grok/gemini/gpt rows. Not a 4-id Anthropic cap, not openzoo-* clones.
+ * Picker ≠ classifier: rewriteChatModel still pins 16-token classify off opus-5.
+ */
+export function anthropicModelList(payload) {
+  const published = publishModelList(payload, { aliases: false });
+  const data = anthropicRows(withAutoFirst(published.data || []));
   return {
     data,
     has_more: false,
@@ -329,12 +415,14 @@ export function wantsAnthropicModelList(headers = {}) {
 }
 
 /**
- * Body for GET /v1/models. Always the full zoo catalog (never opus-5-only).
- * Anthropic-shaped clients get id+display_name; OpenAI clients keep object:list.
+ * Body for GET /v1/models. Quoteable catalog only (never opus-5-only, never
+ * unpriced / :batch / openzoo-* clones). Anthropic-shaped clients get the
+ * same quoteable ids in Anthropic shape (type / id / display_name) so Claude
+ * Code can select grok, gemini, gpt, etc. OpenAI clients keep object:list
+ * of every quoteable id + harness aliases.
  */
 export function modelsListForRequest(payload, headers) {
-  const published = publishModelList(payload);
-  return wantsAnthropicModelList(headers) ? anthropicModelList(published) : published;
+  return wantsAnthropicModelList(headers) ? anthropicModelList(payload) : publishModelList(payload);
 }
 
 /**
@@ -471,6 +559,9 @@ export function raiseReasoningMaxTokens(parsed, env = process.env) {
 export function rewriteChatModel(parsed, ids, { bodyLen } = {}) {
   const from = parsed?.model;
   const len = bodyLen ?? (parsed == null ? 0 : Buffer.byteLength(JSON.stringify(parsed)));
+  if (isAutoModel(from) && !isTinyClassify(parsed, len)) {
+    return { parsed, tiny: false, auto: true, from, to: AUTO_MODEL_ID, raised: false };
+  }
   if (isTinyClassify(parsed, len)) {
     const picked = pickClassifierModel(ids);
     // pickClassifierModel returns null on an empty catalog or a zoo that
@@ -489,7 +580,7 @@ export function rewriteChatModel(parsed, ids, { bodyLen } = {}) {
   if (typeof from !== 'string') {
     return { parsed, tiny: false, from, to: from, raised: false };
   }
-  const resolved = resolveModel(from, ids);
+  const resolved = resolveModel(from, ids) || anthropicNativeAlias(from);
   const next = resolved ? { ...parsed, model: resolved } : parsed;
   const bump = raiseReasoningMaxTokens(next);
   return {

package/lib/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/podagent.mjs

@@ -28,6 +28,14 @@ import {
   isRaceCountable, raceLastShip, shouldRetryRaceArrival, raceFailKind,
   summarizeRaceFailures,
 } from './livestatus.js';
+import { messageReasoning, wrapThink, stripThinkTags, reasoningPresent, splitThink } from './think.js';
+import { guardFindCwd } from './runguard.js';
+
+function emitReply(onDelta, raw) {
+  const parts = splitThink(raw);
+  if (parts.thinking) onDelta(parts.thinking, { think: true });
+  if (parts.visible) onDelta(parts.visible);
+}
 import {
   probeGatewayRace, capRaceByCredit, inferRaceTier, RACE_NO_CREDIT,
   recutRaceByHud, sessionDollarX,
@@ -42,7 +50,7 @@ export const PROXY = process.env.OZ_PROXY || 'http://127.0.0.1:8402/v1';
 function completionsProxy() {
   return process.env.OZ_PROXY || PROXY;
 }
-export const MODEL = process.env.OZ_BRAIN_MODEL || 'deepseek/deepseek-v4-pro-0813';
+export const MODEL = process.env.OZ_BRAIN_MODEL || 'openzoo/auto';
 const MAX_STEPS = Number(process.env.OZ_MAX_STEPS || 10);
 
 // Matches the Grok Bot chat surface itself (dark canvas, right-aligned grey
@@ -188,7 +196,7 @@ function execFrame(command, cwd = '/tmp') {
     approvalId: randomUUID(),
     // agent.v1.ExecServerMessage as protobuf-es JSON (camelCase). The daemon
     // assigns `id`; we only supply the shell variant.
-    serverMessage: { shellArgs: { command, workingDirectory: cwd, timeout: 120 } },
+    serverMessage: { shellArgs: { command: guardFindCwd(command, cwd), workingDirectory: cwd, timeout: 120 } },
   };
 }
 
@@ -380,15 +388,17 @@ export async function brain(messages, contextId, modelOverride, topK, signal) {
     contextId, topK, undefined, signal,
   );
   const j = await r.json().catch(() => ({}));
-  const content = j?.choices?.[0]?.message?.content;
+  const msg = j?.choices?.[0]?.message;
+  const content = msg?.content;
+  const thinking = messageReasoning(msg);
   // Same truncation catch as the streaming path (see brainStream): a reply that
   // stops because the budget ran out is not a finished reply, and this path is
   // what non-streaming callers — including every SPAWNed subagent — go through.
   if (content && j?.choices?.[0]?.finish_reason === 'length') {
     const rest = await brainContinue(messages, content, contextId, modelOverride, 0);
-    return content + rest;
+    return wrapThink(thinking, content + rest);
   }
-  return content || (r.ok ? '' : await httpErrorNote(r.status));
+  return wrapThink(thinking, content || (r.ok ? '' : await httpErrorNote(r.status)));
 }
 
 /** Resume a reply that hit the output cap, non-streaming. Bounded by
@@ -430,20 +440,31 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
   if (!r.ok || !r.body) {
     // fall back to the non-streaming path rather than fail outright
     const j = await r.json().catch(() => ({}));
-    const content = j?.choices?.[0]?.message?.content;
+    const msg = j?.choices?.[0]?.message;
+    const content = msg?.content;
+    const thinking = messageReasoning(msg);
     const proxied = sanitizeProxiedError(j?.error?.message);
     const text = content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status)));
+    if (thinking) onDelta(thinking, { think: true });
     if (text) onDelta(text);
-    return text;
+    return wrapThink(thinking, text);
   }
   const reader = r.body.getReader();
   const decoder = new TextDecoder();
-  let buf = '', full = '', reasonedChars = 0, finish = '';
+  let buf = '', full = '', reasonedChars = 0, reasonedText = '', finish = '';
   let stopWait = startModelWait(onStatus);
   const noteThinking = () => {
     stopWait();
     onStatus?.('thinking…');
   };
+  const takeReasoning = (delta, message) => {
+    const chunk = messageReasoning(message, delta);
+    if (!chunk) return;
+    reasonedChars += chunk.length;
+    reasonedText += chunk;
+    onDelta(chunk, { think: true });
+    if (!full) noteThinking();
+  };
   try {
     for (;;) {
       let chunk;
@@ -459,11 +480,11 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
         if (full) {
           const note = '\n\n(stream stalled — showing what arrived before the timeout)';
           onDelta(note);
-          return full + note;
+          return wrapThink(reasonedText, full + note);
         }
         onStatus?.('waiting on model…');
         const fallback = await brain(messages, contextId, modelOverride, topK, signal);
-        if (fallback) onDelta(fallback);
+        if (fallback) emitReply(onDelta, fallback);
         return fallback || '(stream timed out — no tokens arrived)';
       }
       const { value, done } = chunk;
@@ -488,13 +509,18 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
             full += d.content;
             onDelta(d.content);
           }
-          // Reasoning models emit their chain of thought on a SEPARATE field and
-          // only then start producing content. Count it — not to show it, but to
-          // tell "the model said nothing" apart from "the model spent its whole
-          // budget thinking and got cut off". Surface "thinking…" so the wait
-          // is not mute dots.
-          else if (d?.reasoning || d?.reasoning_content) {
-            reasonedChars += (d.reasoning || d.reasoning_content).length;
+          // Reasoning models emit their chain of thought on a SEPARATE field
+          // (reasoning_content / reasoning / thinking / thought, or a provider
+          // object with a plaintext summary). Forward the plaintext as
+          // onDelta(text, { think: true }) so the canvas can fold it — never
+          // as visible content. Encrypted blobs stay counted for the empty-
+          // after-think retry, but are not forwarded.
+          const before = reasonedChars;
+          takeReasoning(d, c?.message);
+          if (reasonedChars === before && reasoningPresent(d, c?.message)) {
+            // Encrypted-only: nothing to fold, but the model DID think —
+            // count it so an empty completion retries instead of "(no response)".
+            reasonedChars += 1;
             if (!full) noteThinking();
           }
         } catch { /* keep-alive line or partial JSON — ignore */ }
@@ -533,9 +559,9 @@ export async function brainStream(messages, onDelta, contextId, modelOverride, m
       onDelta, contextId, modelOverride,
       Math.min(budget * 2, MAX_CONTINUE_TOKENS), round + 1, topK, onStatus,
     );
-    return full + (more || '');
+    return wrapThink(reasonedText, full + (more || ''));
   }
-  return full;
+  return wrapThink(reasonedText, full);
 }
 
 // How many times a single answer may be resumed after hitting the cap. Three
@@ -628,6 +654,7 @@ export const TIER_ALIASES = {
 };
 export function normalizeTier(s) {
   const raw = String(s || '').trim().toLowerCase();
+  if (raw === 'auto') return 'auto';
   if (TIER_NAMES.includes(raw)) return raw;
   if (TIER_ALIASES[raw]) return TIER_ALIASES[raw];
   const compact = raw.replace(/[\s_]/g, '');
@@ -786,15 +813,16 @@ async function brainGatewayRace(messages, onDelta, contextId, models, need, maxT
       const r = await postChat(body, contextId, 0, onStatus, hooks.signal);
       if (!r.ok || !r.body) {
         const j = await r.json().catch(() => ({}));
-        const content = j?.choices?.[0]?.message?.content;
+        const msg = j?.choices?.[0]?.message;
+        const content = msg?.content;
         const proxied = sanitizeProxiedError(j?.error?.message);
-        const text = content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status)));
+        const text = wrapThink(messageReasoning(msg), content || (r.ok ? '' : (proxied ? `(request failed — HTTP ${r.status}: ${proxied})` : await httpErrorNote(r.status))));
         lastFail = { model: 'gateway', text: text || '', error: r.ok ? undefined : `HTTP ${r.status}` };
         if (isRaceCountable(lastFail)) {
           arrivals.push(lastFail);
           done.push(lastFail);
           feed.onBack(lastFail.model);
-          if (text) onDelta(text);
+          if (text) emitReply(onDelta, text);
           break;
         }
         if (!shouldRetryRaceArrival(lastFail) || attempt === 1) break;
@@ -846,6 +874,7 @@ async function readGatewayRaceStream(r, feed, signal) {
   const decoder = new TextDecoder();
   let buf = '';
   const texts = new Map();
+  const thinks = new Map();
   const finished = new Map();
   const live = { id: null };
   const stopWait = startModelWait(() => {});
@@ -857,11 +886,21 @@ async function readGatewayRaceStream(r, feed, signal) {
     texts.set(key, (texts.get(key) || '') + chunk);
     feed.onToken(key, chunk);
   };
+  const pushThink = (id, chunk) => {
+    if (chunk == null || chunk === '') return;
+    const key = id || live.id || 'gateway';
+    live.id = key;
+    thinks.set(key, (thinks.get(key) || '') + chunk);
+  };
   const finishOne = (id, extra = {}) => {
     const key = id || live.id || 'gateway';
     if (finished.has(key)) return;
     const text = extra.text != null ? String(extra.text) : (texts.get(key) || '');
-    const row = { model: extra.model || key, text, error: extra.error };
+    const row = {
+      model: extra.model || key,
+      text: wrapThink(thinks.get(key) || '', text),
+      error: extra.error,
+    };
     finished.set(key, row);
   };
 
@@ -909,7 +948,11 @@ async function readGatewayRaceStream(r, feed, signal) {
           const d = c?.delta;
           const id = raceRacerId(obj, live.id || 'gateway');
           if (d?.content) pushText(id, d.content);
-          else if (d?.reasoning || d?.reasoning_content) { /* thinking — not content */ }
+          // Reasoning is not a racer preview. Fold it onto the arrival so
+          // the winner's canvas row can show a thinking chip — never dump
+          // CoT into the spectator grid.
+          const think = messageReasoning(c?.message, d);
+          if (think) pushThink(id, think);
           if (c?.finish_reason) finishOne(id, { model: obj.model });
           if (ev?.ev === 'back' || ev?.ev === 'done') finishOne(ev.id, { text: ev.text, model: ev.id });
           if (ev?.ev === 'fail' || ev?.error) finishOne(ev.id, { text: ev.text || '', error: ev.error || 'empty body' });
@@ -1076,7 +1119,10 @@ export async function brainRace(messages, onDelta, contextId, models, need = 1,
     for (let attempt = 0; attempt < 2; attempt++) {
       if (raceAbort.signal.aborted && attempt > 0) break;
       try {
-        const text = await stream(messages, (chunk) => feed.onToken(m, chunk), contextId, m, maxTokens, 0, 0, undefined, raceAbort.signal);
+        const text = await stream(messages, (chunk, meta) => {
+          if (meta?.think) return;
+          feed.onToken(m, chunk);
+        }, contextId, m, maxTokens, 0, 0, undefined, raceAbort.signal);
         last = { model: m, text: text == null ? '' : String(text) };
         if (isRaceCountable(last)) {
           arrivals.push(last);
@@ -1146,7 +1192,7 @@ function raceQuestion(messages) {
 async function classifyRaceAnswer(messages, cand) {
   const prompt = 'Score this answer to one question from 0 to 10.\n\n'
     + 'QUESTION:\n' + String(raceQuestion(messages)).slice(0, 4000) + '\n\n'
-    + 'ANSWER:\n' + String(cand?.text || '').slice(0, 6000) + '\n\n'
+    + 'ANSWER:\n' + stripThinkTags(String(cand?.text || '')).slice(0, 6000) + '\n\n'
     + 'Judge on: correctness first, then completeness, then whether it actually did what was asked '
     + '(a directive like RUN: or DONE: on one line is the correct format here, not a flaw). '
     + 'Ignore length and confidence of tone.\n'
@@ -1165,7 +1211,7 @@ async function pairwiseTied(messages, tied) {
   const letters = tied.map((_, i) => String.fromCharCode(65 + i));
   const prompt = 'You are judging answers to one question. Pick the single best one.\n\n'
     + 'QUESTION:\n' + String(raceQuestion(messages)).slice(0, 4000) + '\n\n'
-    + tied.map((c, i) => 'ANSWER ' + letters[i] + ':\n' + String(c.text || '').slice(0, 6000)).join('\n\n')
+    + tied.map((c, i) => 'ANSWER ' + letters[i] + ':\n' + stripThinkTags(String(c.text || '')).slice(0, 6000)).join('\n\n')
     + '\n\nJudge on: correctness first, then completeness, then whether it actually did what was asked '
     + '(a directive like RUN: or DONE: on one line is the correct format here, not a flaw). '
     + 'Ignore length and confidence of tone.\n'