openzoo 0.50.77 → 0.50.79

package/README.md

@@ -25,6 +25,10 @@ paid $0.002137 (9.5× cheaper than direct) · rail solana · tx 5Kd…
 
 **Claude Code / grokui Auto** — `openzoo claude` sets the Anthropic API key + base URL to the local OpenZoo proxy (x402 pay-per-call). You do **not** need to authenticate Claude first. grokui orange Auto is this harness, not a `RUN:` text parser. PATH `~/.local/bin` is required on Mac so `claude` is found.
 
+**Agent of Empires** (tmux session manager for coding agents, [agent-of-empires](https://github.com/agent-of-empires/agent-of-empires)) — `openzoo aoe` registers an `openzoo` agent in aoe's `config.toml` (`[session.custom_agents] openzoo = "openzoo claude"`, detected as `claude` so status hooks, resume and fork all work), starts a background proxy if none is listening (no public tunnel unless `--tunnel`), then runs `aoe`. `openzoo aoe add . -l` creates and launches one session in the current directory; in the TUI pick **openzoo** from the agent picker. `Alt+z` opens a tool session with the wallet balance and the live receipts log. Terminal view only: aoe's structured view runs `claude-agent-acp` itself, which bills Anthropic, not the zoo. `--override-claude` additionally makes aoe's built-in `claude` agent launch through openzoo; `--no-launch` writes config only.
+
+**Orca** ([stablyai/orca](https://github.com/stablyai/orca), the desktop orchestrator for parallel agents) — Orca launches any CLI agent in a worktree terminal, so type `openzoo claude` as the agent command (or pick **openzoo** from the agent picker once the upstream catalog entry lands). Orca treats it as Claude Code: same process, same hooks and status dots, same `--dangerously-skip-permissions` default. No account switching applies, because nothing is logged in; every turn pays x402.
+
 `GET /v1/models` is the live OpenRouter catalog **after** dropping `:batch`, `$0` / missing prices, and `openzoo-*` twins. Claude Code's `/model` picker (Anthropic-shaped GET) is a short list: current Opus/Sonnet/Haiku-class + a few real gateway models + `openzoo/auto`.
 
 Mac:

package/bin/openzoo.js

@@ -142,6 +142,15 @@ usage:
                          path hard-codes $0.00 and ignores /v1/models pricing)
                          --all (whole catalog) --models a,b (exact ids)
                          --default <id> (set the agents' primary model)
+  npx openzoo aoe [aoe args]  Agent of Empires (tmux session manager for coding
+                         agents): registers "openzoo" as an agent in aoe's
+                         config.toml (= Claude Code on the zoo, detected as
+                         claude so status/resume work), starts a background
+                         proxy if none is up, then runs aoe.
+                         aoe add . -l   one session in this dir, launched
+                         --no-launch (config only) --no-proxy --tunnel
+                         --override-claude (aoe's built-in claude pays via
+                         the zoo too) --no-receipts (skip the Alt+z tool)
   npx openzoo mcp        stdio MCP server (tools: zoo_ask, zoo_bind, zoo_models, zoo_wallet, zoo_contexts)
   npx openzoo unblock    restore the editor's own backend in the hosts file
   npx openzoo tunnel     public-url-only mode (everything key-gated, no keyless localhost)
@@ -201,6 +210,9 @@ async function main() {
     case 'openclaw':
       await (await import('../lib/openclaw.js')).setupOpenClaw(process.argv.slice(3));
       break;
+    case 'aoe':
+      await (await import('../lib/aoe.js')).setupAoe(process.argv.slice(3));
+      break;
     case 'voice':
       await (await import('../lib/voice.js')).runVoice(process.argv.slice(3));
       break;

package/lib/aoe.js

@@ -0,0 +1,314 @@
+/**
+ * `npx openzoo aoe [aoe args...]` — register openzoo as an agent in Agent of
+ * Empires (https://github.com/agent-of-empires/agent-of-empires), make sure a
+ * proxy is up for the sessions it will spawn, then hand off to `aoe`.
+ *
+ * AoE runs each coding agent in its own tmux session and picks the agent from
+ * a registry it ships (`aoe agents`). openzoo is not in that registry, but AoE
+ * has a first-class hook for exactly this shape: `[session.custom_agents]`
+ * names a command, and `[session.agent_detect_as]` tells AoE which built-in
+ * the command wraps so status hooks, resume flags and the structured-view
+ * adapter are inherited. `openzoo claude` IS Claude Code (it spawns the real
+ * CLI with ANTHROPIC_BASE_URL pointed at the local proxy and forwards every
+ * flag untouched), so `openzoo = "openzoo claude"` + `openzoo = "claude"` is
+ * the whole integration: `aoe add --tool openzoo` launches a Claude Code
+ * session that pays per turn over x402 with no API key and no account.
+ *
+ * Everything written is a surgical edit of the user's config.toml: keys are
+ * inserted into the tables they belong to (header form or inline form,
+ * whichever the file already uses), never a second `[session.custom_agents]`
+ * header, which TOML rejects as a duplicate table and would take the whole
+ * config down with it. Re-running is idempotent.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { config } from './config.js';
+
+export const AGENT_NAME = 'openzoo';
+export const TOOL_NAME = 'openzoo';
+
+/**
+ * Where AoE reads its global config.toml. Mirrors `get_app_dir_path` in
+ * agent-of-empires/src/session/mod.rs: Linux is always XDG; macOS prefers an
+ * existing XDG dir, then an existing legacy `~/.agent-of-empires`, then XDG
+ * only when `XDG_CONFIG_HOME` is set explicitly; everything else is legacy.
+ * OPENZOO_AOE_CONFIG overrides outright (tests, unusual layouts).
+ */
+export function aoeConfigPath({
+  env = process.env, home = os.homedir(), platform = process.platform, exists = fs.existsSync,
+} = {}) {
+  if (env.OPENZOO_AOE_CONFIG) return env.OPENZOO_AOE_CONFIG;
+  const xdg = path.join(env.XDG_CONFIG_HOME || path.join(home, '.config'), 'agent-of-empires');
+  const legacy = path.join(home, '.agent-of-empires');
+  let dir;
+  if (platform === 'linux') dir = xdg;
+  else if (platform === 'darwin') {
+    if (exists(xdg)) dir = xdg;
+    else if (exists(legacy)) dir = legacy;
+    else dir = env.XDG_CONFIG_HOME ? xdg : legacy;
+  } else dir = legacy;
+  return path.join(dir, 'config.toml');
+}
+
+/**
+ * The command AoE will put in a tmux pane. `openzoo` on PATH when it is
+ * (global install); otherwise the exact node + script that is running right
+ * now, so `npx openzoo aoe` users get a session that launches instead of a
+ * "command not found" pane. AoE verifies the first word is on PATH before it
+ * creates a session, which is also why an absolute path beats `npx openzoo`.
+ */
+export function openzooLaunchCommand({ env = process.env, execPath = process.execPath, script = process.argv[1] } = {}) {
+  const name = 'openzoo' + (process.platform === 'win32' ? '.cmd' : '');
+  for (const dir of String(env.PATH || '').split(path.delimiter)) {
+    if (!dir) continue;
+    try { fs.accessSync(path.join(dir, name), fs.constants.X_OK); return 'openzoo'; } catch { /* next */ }
+  }
+  return `${shQuote(execPath)} ${shQuote(script)}`;
+}
+
+/** Quote one argv word for the shell AoE hands the command to. */
+export function shQuote(s) {
+  return /^[A-Za-z0-9_/.:@%+=-]+$/.test(s) ? s : `'${String(s).replace(/'/g, "'\\''")}'`;
+}
+
+/** TOML basic string. JSON's escapes are a subset of TOML's for the characters
+ *  a path or command can contain, so this is exact, not approximate. */
+export function tomlString(s) {
+  return JSON.stringify(String(s));
+}
+
+function keyMatches(rawKey, key) {
+  const k = rawKey.trim();
+  return k === key || k === `"${key}"` || k === `'${key}'`;
+}
+
+/** Split an inline-table body on commas that are not inside a string. */
+function splitInline(body) {
+  const parts = [];
+  let cur = '';
+  let quote = null;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (quote) {
+      cur += ch;
+      if (ch === '\\' && quote === '"') { cur += body[++i] ?? ''; continue; }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") { quote = ch; cur += ch; continue; }
+    if (ch === ',') { parts.push(cur); cur = ''; continue; }
+    cur += ch;
+  }
+  if (cur.trim()) parts.push(cur);
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+
+/**
+ * Set `key = value` inside TOML table `table` (dotted, e.g.
+ * `session.custom_agents`), replacing any existing value for that key.
+ * Pure: string in, string out.
+ *
+ * Handles the two spellings a hand-edited config uses:
+ *   [session.custom_agents]          header form → key inserted under it
+ *   [session]
+ *   custom_agents = { a = "b" }      inline form → entry injected into the braces
+ * and appends a fresh header only when neither exists. `value` must already be
+ * a TOML literal (see tomlString).
+ */
+export function upsertTomlKey(toml, table, key, value) {
+  const lines = String(toml || '').split('\n');
+  const parent = table.includes('.') ? table.slice(0, table.lastIndexOf('.')) : '';
+  const child = table.slice(table.lastIndexOf('.') + 1);
+  const headerOf = (line) => {
+    const m = line.match(/^\s*\[([^[\]]+)\]\s*(#.*)?$/);
+    return m ? m[1].trim().replace(/\s+/g, '').replace(/"/g, '') : null;
+  };
+  let section = '';
+  let headerIdx = -1;
+  let inlineIdx = -1;
+  const out = [];
+  for (const line of lines) {
+    const h = headerOf(line);
+    if (h !== null) {
+      section = h;
+      if (h === table && headerIdx === -1) headerIdx = out.length;
+      out.push(line);
+      continue;
+    }
+    if (section === table) {
+      const m = line.match(/^\s*("[^"]*"|'[^']*'|[A-Za-z0-9_-]+)\s*=/);
+      if (m && keyMatches(m[1], key)) continue; // ours, rewritten below
+    }
+    if (section === parent && inlineIdx === -1) {
+      const m = line.match(/^\s*("[^"]*"|'[^']*'|[A-Za-z0-9_-]+)\s*=\s*\{/);
+      if (m && keyMatches(m[1], child)) inlineIdx = out.length;
+    }
+    out.push(line);
+  }
+  const entry = `${key} = ${value}`;
+  if (headerIdx !== -1) {
+    out.splice(headerIdx + 1, 0, entry);
+  } else if (inlineIdx !== -1) {
+    const line = out[inlineIdx];
+    const open = line.indexOf('{');
+    const close = line.lastIndexOf('}');
+    if (close > open) {
+      const body = splitInline(line.slice(open + 1, close))
+        .filter((p) => !keyMatches(p.split('=')[0], key));
+      out[inlineIdx] = `${line.slice(0, open + 1)} ${[entry, ...body].join(', ')} ${line.slice(close)}`;
+    } else {
+      // Multi-line inline table (TOML 1.1). Rare; a fresh header would clash
+      // with it, so refuse loudly rather than corrupt the file.
+      throw new Error(`cannot edit multi-line inline table \`${child}\` in [${parent}] — add ${entry} by hand`);
+    }
+  } else {
+    while (out.length && out[out.length - 1].trim() === '') out.pop();
+    if (out.length) out.push('');
+    out.push(`[${table}]`, entry);
+  }
+  return `${out.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd()}\n`;
+}
+
+/** Drop a whole `[table]` block (header through the next header). */
+export function stripTomlTable(toml, table) {
+  const lines = String(toml || '').split('\n');
+  const out = [];
+  let skipping = false;
+  for (const line of lines) {
+    const m = line.match(/^\s*\[([^[\]]+)\]\s*(#.*)?$/);
+    if (m) skipping = m[1].trim().replace(/\s+/g, '').replace(/"/g, '') === table;
+    if (!skipping) out.push(line);
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n');
+}
+
+/**
+ * Merge openzoo into an AoE config. Pure.
+ *
+ *  - session.custom_agents.openzoo   = "<launch> claude"   the agent
+ *  - session.agent_detect_as.openzoo = "claude"            inherit Claude's
+ *    status hooks, resume/fork flags and structured-view adapter
+ *  - tools.openzoo                   receipts tail on Alt+z (persistent tool
+ *    session; the proxy's log is the spend ledger)
+ *  - session.agent_command_override.claude (opt-in, `overrideClaude`): every
+ *    built-in claude session in AoE launches through openzoo too
+ */
+export function mergeAoeConfig(toml, {
+  launch = 'openzoo', logPath = '~/.openzoo/proxy.log', overrideClaude = false, receipts = true,
+} = {}) {
+  let out = String(toml || '');
+  const changes = [];
+  const claudeCmd = tomlString(`${launch} claude`);
+  out = upsertTomlKey(out, 'session.custom_agents', AGENT_NAME, claudeCmd);
+  changes.push(`session.custom_agents.${AGENT_NAME} = ${claudeCmd}`);
+  out = upsertTomlKey(out, 'session.agent_detect_as', AGENT_NAME, '"claude"');
+  changes.push(`session.agent_detect_as.${AGENT_NAME} = "claude"`);
+  if (overrideClaude) {
+    out = upsertTomlKey(out, 'session.agent_command_override', 'claude', claudeCmd);
+    changes.push(`session.agent_command_override.claude = ${claudeCmd}`);
+  }
+  out = stripTomlTable(out, `tools.${TOOL_NAME}`);
+  if (receipts) {
+    const cmd = tomlString(`${launch} balance; tail -n 40 -f ${logPath}`);
+    // Comment INSIDE the block: stripTomlTable drops header-to-next-header, so
+    // a comment above the header would survive every re-run and pile up.
+    out = `${out.trimEnd()}\n\n[tools.${TOOL_NAME}]\n# openzoo receipts: wallet balance, then the proxy's live payment log.\ncommand = ${cmd}\nhotkey = "Alt+z"\n`;
+    changes.push(`tools.${TOOL_NAME} (Alt+z) = ${cmd}`);
+  }
+  return { toml: out, changes };
+}
+
+function aoeInstalled() {
+  const r = spawnSync('aoe', ['--version'], { encoding: 'utf8' });
+  return r.status === 0 ? (r.stdout || '').trim() : null;
+}
+
+async function proxyUp(base) {
+  try { return (await fetch(`${base}/info`, { signal: AbortSignal.timeout(2500) })).ok; } catch { return false; }
+}
+
+/**
+ * Start a proxy that outlives this command. AoE sessions are tmux sessions:
+ * they keep running after the TUI closes, so a proxy tied to this process
+ * would vanish under them. `openzoo claude` inside a pane heals a missing
+ * proxy at launch, but a proxy that dies mid-conversation is a wall of API
+ * errors in every other session, so the long-lived one is started here.
+ * No public tunnel unless asked: a detached proxy nobody is watching must not
+ * open a URL + key that spends the wallet with no session cap.
+ */
+function startDetachedProxy({ tunnel }) {
+  const logPath = path.join(os.homedir(), '.openzoo', 'proxy.log');
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  const fd = fs.openSync(logPath, 'a');
+  const env = { ...process.env };
+  if (!tunnel && !env.OPENZOO_NO_TUNNEL) env.OPENZOO_NO_TUNNEL = '1';
+  const child = spawn(process.execPath, [process.argv[1], 'proxy'], {
+    detached: true, stdio: ['ignore', fd, fd], env,
+  });
+  child.unref();
+  fs.closeSync(fd);
+  return { pid: child.pid, logPath };
+}
+
+export async function setupAoe(argv = []) {
+  const flags = new Set(argv.filter((a) => a.startsWith('--')));
+  const rest = argv.filter((a) => !['--no-launch', '--no-proxy', '--tunnel', '--override-claude', '--no-receipts'].includes(a));
+  const cfgPath = aoeConfigPath();
+  const launch = openzooLaunchCommand();
+
+  let existing = '';
+  try { existing = fs.readFileSync(cfgPath, 'utf8'); } catch { existing = ''; }
+  const { toml, changes } = mergeAoeConfig(existing, {
+    launch,
+    logPath: path.join(os.homedir(), '.openzoo', 'proxy.log'),
+    overrideClaude: flags.has('--override-claude'),
+    receipts: !flags.has('--no-receipts'),
+  });
+  if (toml !== existing) {
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    fs.writeFileSync(cfgPath, toml);
+  }
+  console.error(`openzoo: ${toml === existing ? 'already in' : 'written to'} ${cfgPath}`);
+  for (const c of changes) console.error(`  ${c}`);
+  console.error('  agent "openzoo" = Claude Code on the zoo: pays x402 per turn, no API key, no account.');
+  console.error('  terminal view only — AoE\'s structured view runs claude-agent-acp itself, which bills Anthropic.');
+
+  const version = aoeInstalled();
+  if (!version) {
+    console.error('');
+    console.error('openzoo: `aoe` is not installed (Agent of Empires — tmux session manager for coding agents).');
+    console.error('  brew install aoe');
+    console.error('  curl -fsSL https://raw.githubusercontent.com/agent-of-empires/agent-of-empires/main/scripts/install.sh | bash');
+    console.error('  then:  openzoo aoe        (TUI)     openzoo aoe add . -l   (one session, launched)');
+    process.exit(flags.has('--no-launch') ? 0 : 1);
+  }
+
+  const base = `http://localhost:${config.port}/v1`;
+  if (!flags.has('--no-proxy')) {
+    if (await proxyUp(base)) {
+      console.error(`openzoo: proxy already up on ${base}`);
+    } else {
+      const { pid, logPath } = startDetachedProxy({ tunnel: flags.has('--tunnel') });
+      let up = false;
+      for (let i = 0; i < 40 && !up; i++) {
+        await new Promise((r) => setTimeout(r, 300));
+        up = await proxyUp(base);
+      }
+      if (up) console.error(`openzoo: proxy started in the background (pid ${pid}, receipts in ${logPath}; stop: kill ${pid})`);
+      else console.error(`openzoo: proxy not answering yet on ${base} — sessions will start one themselves; see ${logPath}`);
+    }
+  }
+  if (flags.has('--no-launch')) return;
+
+  // `openzoo aoe add …` → `aoe add --tool openzoo …` unless the caller chose.
+  const args = [...rest];
+  if (args[0] === 'add' && !args.some((a) => a === '--tool' || a === '--cmd' || a === '-c')) {
+    args.splice(1, 0, '--tool', AGENT_NAME);
+  }
+  console.error(`openzoo: aoe ${version} — running: aoe ${args.join(' ')}`.trimEnd());
+  const child = spawn('aoe', args, { stdio: 'inherit' });
+  child.on('exit', (code) => process.exit(code ?? 0));
+  child.on('error', (e) => { console.error(`openzoo: could not launch aoe: ${e.message}`); process.exit(1); });
+}

package/lib/botlog.js

@@ -42,7 +42,7 @@ const MILESTONE = [
   /ERROR|FAIL|uncaught|rejection|timed out/,
   /wakeups restored|wakeup fire/,
   /ozRevive|ship_|ship:/,
-  /sendPrompt done/,
+  /sendPrompt done|>> sendPrompt/,
   /create_agent tool|deleteAgents n=/,
   /x_compose|chrome reattach/,
 ];
@@ -57,7 +57,7 @@ export function isBotMilestone(line) {
 /**
  * Terminal gets milestones (or everything with verbose); the FULL stream is
  * always appended to `file` so quiet mode never destroys evidence.
- * Default file: ~/.openzoo/bot.log (truncated at start of each run).
+ * Default file: ~/.openzoo/bot.log (appended; one header line per run).
  */
 export function makeBotLogger({ verbose = false, write = (m) => console.error(m), file = defaultBotLogPath(), fsMod = null } = {}) {
   let fd = null;
@@ -65,8 +65,10 @@ export function makeBotLogger({ verbose = false, write = (m) => console.error(m)
     try {
       const fsx = fsMod || fsSync;
       fsx.mkdirSync(pathMod.dirname(file), { recursive: true });
-      fd = fsx.openSync(file, 'w');
-      fsx.writeSync(fd, `# openzoo bot full log ${new Date().toISOString()}\n`);
+      // APPEND, never truncate: the minutely revive cron restarts a dead
+      // hijack, and a truncating open erased the very turn being debugged.
+      fd = fsx.openSync(file, 'a');
+      fsx.writeSync(fd, `# openzoo bot run ${new Date().toISOString()} pid=${process.pid}\n`);
     } catch { fd = null; }
   }
   return (m) => {

package/lib/cursorbackend.js

@@ -45,7 +45,7 @@ import {
   DEFAULT_WAKEUP_PROMPT, addDeletedIds, filterDeleted,
 } from './grokbotAccount.js';
 import { formatSpendFooter, mergeTurnProof } from './spendProof.js';
-import { zooModelIds } from './models.js';
+import { zooModelIds, zooModelRow, mediaKindOf } from './models.js';
 import { prefixVisitorRichText } from './grokbotweb.js';
 import {
   ingestUpload, lookupUpload, readUploadChunk, readUploadImage, readUploadText,
@@ -1626,7 +1626,38 @@ function entryPlainText(v) {
 /** Prior turns for zooComplete. sendPrompt used to POST only the latest user
  *  line, so the model said each thread starts blank while the UI still showed
  *  the canvas. Skip the last user echo of `currentPrompt` (already appended). */
-function historyMessages(agentId, currentPrompt) {
+/**
+ * Strict user/assistant alternation. The abliteration lane 400s
+ * "Invalid model provider request" on `auauauuuau` (wakeup + "continue" +
+ * nudge = three user turns; error text + reply = two assistant turns).
+ * Lossless fold: texts joined with a blank line; tool turns never crossed.
+ */
+export function foldSameRole(messages) {
+  const out = [];
+  const foldable = (m) => m && (m.role === 'user' || m.role === 'assistant') && !m.tool_calls && !m.tool_call_id;
+  for (const m of messages || []) {
+    const last = out[out.length - 1];
+    if (last && foldable(last) && foldable(m) && last.role === m.role) {
+      const a = last.content; const b = m.content;
+      let content;
+      if (Array.isArray(a) || Array.isArray(b)) {
+        const arr = (v) => (Array.isArray(v) ? v : (v == null || v === '' ? [] : [{ type: 'text', text: String(v) }]));
+        content = [...arr(a), ...arr(b)];
+      } else {
+        const sa = a == null ? '' : String(a); const sb = b == null ? '' : String(b);
+        content = sa && sb ? `${sa}\n\n${sb}` : (sa || sb);
+      }
+      out[out.length - 1] = { ...last, content };
+      continue;
+    }
+    out.push(m);
+  }
+  return out;
+}
+function historyMessages(...args) {
+  return foldSameRole(historyMessagesRaw(...args));
+}
+function historyMessagesRaw(agentId, currentPrompt) {
   const entries = agentTranscript(agentId).entries || [];
   const cur = String(currentPrompt || '').trim();
   const out = [];
@@ -2393,9 +2424,24 @@ const LOCAL_TOOLS = [
 
 export const LOCAL_TOOL_NAMES = LOCAL_TOOLS.map((t) => t.function.name);
 
+/**
+ * OpenAI-compatible upstreams cap `tools` at 128. MEASURED 2026-09-01:
+ * surplusintelligence `400 Invalid 'tools': array too long … got 130` — every
+ * bot turn with both browsers attached died at the door. Locals first, then
+ * the browser MCPs (the bots' real work), then whatever fits.
+ */
+export const MAX_TOOLS = 128;
+export function capTools(list, max = MAX_TOOLS) {
+  if (!Array.isArray(list) || list.length <= max) return list;
+  const name = (t) => String(t?.function?.name || '');
+  const local = list.filter((t) => LOCAL_TOOL_NAMES.includes(name(t)));
+  const browser = list.filter((t) => !LOCAL_TOOL_NAMES.includes(name(t)) && /^(chrome|brave)-devtools__/.test(name(t)));
+  const rest = list.filter((t) => !local.includes(t) && !browser.includes(t));
+  return [...local, ...browser, ...rest].slice(0, max);
+}
 function liveTools() {
   const extra = hostMcpTools();
-  return extra.length ? [...LOCAL_TOOLS, ...extra] : LOCAL_TOOLS;
+  return capTools(extra.length ? [...LOCAL_TOOLS, ...extra] : LOCAL_TOOLS);
 }
 
 async function captureScreenshot(log) {
@@ -2744,6 +2790,58 @@ function zooTextFromMessage(msg, data) {
   return '';
 }
 
+let mediaClient = null;
+function receiptToX402(r) {
+  if (!r) return {};
+  return { billedUsd: r.billedUsd, directUsd: r.directUsd ?? r.billedUsd, rail: r.rail, tx: r.tx, line: r.line, paid: r.asset };
+}
+/** Pay the media endpoint, poll the job, paint the URL. Same PayClient path as zoo_video. */
+async function mediaTurn({ model, kind, prompt, log, onProgress, signal }) {
+  const { PayClient } = await import('./pay.js');
+  const { config } = await import('./config.js');
+  const { withNamespace } = await import('./namespace.js');
+  mediaClient ||= new PayClient();
+  const say = (m) => { try { onProgress?.(m); } catch { /* */ } };
+  say(`Rendering ${kind} with ${model}…`);
+  log(`cursor-backend:      media ${kind} POST model=${model} ${JSON.stringify(String(prompt || '').slice(0, 60))}`);
+  let response; let receipt; let data = {};
+  try {
+    ({ response, receipt } = await mediaClient.fetch(`${config.apiBase}/v1/${kind}s/generations`, {
+      method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ model, prompt }),
+    }));
+    data = await response.json().catch(() => ({}));
+  } catch (e) {
+    return { text: `${kind} generation failed: ${e.message}`, data: {} };
+  }
+  if (!response.ok) return { text: `${kind} generation failed: HTTP ${response.status} ${JSON.stringify(data).slice(0, 240)}`, data: { x402: receiptToX402(receipt) } };
+  if (kind === 'image') {
+    const url = data?.data?.[0]?.url || data?.outputs?.image_url || data?.url || null;
+    return { text: url ? `🖼️ ${url}` : JSON.stringify(data).slice(0, 400), data: { x402: receiptToX402(receipt) } };
+  }
+  const id = data?.id;
+  let url = data?.outputs?.video_url || null;
+  let status = data?.status || 'queued';
+  let err = null;
+  const t0 = Date.now();
+  while (!url && id && Date.now() - t0 < 8 * 60_000) {
+    if (signal?.aborted) throw new Error('superseded');
+    await new Promise((ok) => setTimeout(ok, 5000));
+    try {
+      const r = await fetch(`${config.apiBase}/v1/videos/${encodeURIComponent(id)}`, { headers: withNamespace({}), signal: AbortSignal.timeout(15000) });
+      const j = await r.json().catch(() => ({}));
+      status = j?.status || status;
+      url = j?.outputs?.video_url || null;
+      if (status === 'failed') { err = j?.error?.message || JSON.stringify(j?.error || j).slice(0, 200); break; }
+    } catch (e) { log(`cursor-backend:      media poll ${e.message}`); }
+    say(`Rendering video… ${status} ${Math.round((Date.now() - t0) / 1000)}s`);
+  }
+  const text = url
+    ? `🎬 ${url}`
+    : err ? `video failed: ${err}` : `video job ${id || '?'} still ${status} after 8 min — check later: ${config.apiBase}/v1/videos/${id || ''}`;
+  log(`cursor-backend:      media video done id=${id} status=${status} url=${url ? 'yes' : 'no'}`);
+  return { text, data: { x402: receiptToX402(receipt) } };
+}
+
 async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
   const model = currentModel(agentId);
   const helper = localExecSse.size > 0;
@@ -2757,6 +2855,14 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
   };
   await ensureTranscriptHydrated(agentId, log);
   try { await reattachChrome({ log }); } catch (e) { log(`cursor-backend:      chrome reattach ${e.message}`); }
+  // A bot pinned to a video/image model: the prompt IS the render request.
+  // A chat POST to ByteDance/Seedance-2.5 came back 502 with an empty body
+  // and painted "(empty zoo reply)" — measured 2026-09-01.
+  if (!chatOnly) {
+    let mediaKind = null;
+    try { mediaKind = mediaKindOf(await zooModelRow(model)); } catch { mediaKind = null; }
+    if (mediaKind) return await mediaTurn({ model, kind: mediaKind, prompt: spoken, log, onProgress: opts.onProgress, signal: opts.signal });
+  }
   log(`cursor-backend:      zoo POST :8402 model=${model} helper=${helper ? localExecSse.size : 0} hist=${historyMessages(agentId, spoken).length}${chatOnly ? ` visitor=${visitor.shortname} chat-only` : ''} ${JSON.stringify((spoken || '').slice(0, 60))}`);
   if (typeof opts.onProgress === 'function') opts.onProgress('Working on your Mac…');
 
@@ -2922,6 +3028,14 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
       }
     }
     const data = await r.json().catch(() => ({}));
+    // EVIDENCE FOR THE NEXT DEBUG: the exact body behind a non-200, on disk.
+    // "Invalid model provider request." reproduced with no probe until the
+    // real transcript could be replayed.
+    if (r.status !== 200) {
+      try {
+        fs.writeFileSync(path.join(os.homedir(), '.openzoo', 'zoo-last-error-body.json'), JSON.stringify({ at: new Date().toISOString(), status: r.status, agentId, response: data, payload }, null, 1));
+      } catch { /* */ }
+    }
     if (r.status === 402) {
       const raw = zooTextFromMessage(data?.choices?.[0]?.message, data)
         || data?.error?.message

package/lib/models.js

@@ -541,3 +541,31 @@ export function wantsAnthropicModelList(headers = {}) {
 export function modelsListForRequest(payload, headers) {
   return wantsAnthropicModelList(headers) ? anthropicModelList(payload) : publishModelList(payload);
 }
+
+/* ── media rows (video / image) ─────────────────────────────────────────── */
+let rowsCache = { at: 0, rows: null, base: '' };
+/** Raw catalog rows incl. media (`kind`, `endpoint`), cached like zooModelIds. */
+export async function zooCatalogRows() {
+  if (rowsCache.rows && rowsCache.base === config.apiBase && Date.now() - rowsCache.at < CATALOG_TTL_MS) return rowsCache.rows;
+  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 rows = Array.isArray(d?.data) ? d.data : [];
+  if (rows.length) rowsCache = { at: Date.now(), rows, base: config.apiBase };
+  return rows;
+}
+export async function zooModelRow(id) {
+  const want = String(id || '');
+  if (!want) return null;
+  const rows = await zooCatalogRows();
+  return rows.find((m) => m?.id === want) || rows.find((m) => String(m?.id || '').toLowerCase() === want.toLowerCase()) || null;
+}
+/** 'video' | 'image' | null — a chat POST to one of these is a guaranteed empty reply. */
+export function mediaKindOf(row) {
+  const k = String(row?.kind || '').toLowerCase();
+  if (k === 'video' || k === 'image') return k;
+  const ep = String(row?.endpoint || '');
+  if (/\/videos\/generations/.test(ep)) return 'video';
+  if (/\/images\/generations/.test(ep)) return 'image';
+  return null;
+}

package/lib/openclaw.js

@@ -18,6 +18,14 @@
  * charges at most this, less with trailing volume and leCore context reuse.
  * A client-side estimate can only be honest-or-high; receipts on the proxy
  * console stay the ground truth.
+ *
+ * RE-MEASURED on OpenClaw 2026.8.2 (2026-09-02): the block this writes still
+ * validates (`openclaw config validate` accepts baseUrl/apiKey/api/models with
+ * cost/contextWindow/maxTokens), and a hand-added provider still gets no live
+ * discovery — 2026.8's "live model discovery" is provider-plugin-owned. The
+ * bundled `extensions/openzoo` provider plugin (upstream PR) is the proper
+ * 2026.8+ path: discovery + pricing from /v1/models, no config surgery. This
+ * command stays for older builds and for pinning an exact model list.
  */
 import fs from 'node:fs';
 import os from 'node:os';

package/package.json

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