nou-cli 0.5.0 → 0.5.2

package/dist/src/games/index.js

@@ -0,0 +1,217 @@
+/**
+ * Little games for the Games panel, drawn with text. Each one is plain state and three functions, so the
+ * panel can run any of them and the tests can play them without a terminal.
+ */
+/** A small seeded random number generator, so games can be replayed in tests. */
+function rng(seed) {
+    let s = seed >>> 0 || 1;
+    return () => {
+        s ^= s << 13;
+        s ^= s >>> 17;
+        s ^= s << 5;
+        return (s >>> 0) / 4294967296;
+    };
+}
+const blank = (w, h) => Array.from({ length: h }, () => Array(w).fill(" "));
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+const PADDLE = 3;
+const PONG_WIN = 7;
+function serve(s, toward) {
+    const vy = (s.random() - 0.5) * 1.2;
+    return { ...s, bx: s.w / 2, by: s.h / 2, vx: toward * 0.9, vy: Math.abs(vy) < 0.2 ? 0.4 : vy };
+}
+export const pong = {
+    id: "pong",
+    title: "Pong",
+    blurb: "The classic: you on the left, the computer on the right. First to 7.",
+    controls: "↑↓ or w/s move",
+    tickMs: 50,
+    colors: { "█": "#61afef", "●": "#e5c07b", "┊": "#5c6370" },
+    create(w, h, seed = Date.now()) {
+        const s = { w, h, you: Math.floor((h - PADDLE) / 2), them: Math.floor((h - PADDLE) / 2), bx: 0, by: 0, vx: 0, vy: 0, scores: [0, 0], random: rng(seed) };
+        return serve(s, -1);
+    },
+    tick(s, inputs) {
+        if (s.scores[0] >= PONG_WIN || s.scores[1] >= PONG_WIN)
+            return s;
+        let you = s.you;
+        for (const i of inputs)
+            you += i === "up" ? -1 : i === "down" ? 1 : 0;
+        you = clamp(you, 0, s.h - PADDLE);
+        // The computer follows the ball, a bit slower than it moves, so it can be beaten.
+        const target = s.by - PADDLE / 2;
+        const them = clamp(s.them + clamp(target - s.them, -0.55, 0.55), 0, s.h - PADDLE);
+        let { bx, by, vx, vy } = s;
+        bx += vx;
+        by += vy;
+        if (by < 0)
+            [by, vy] = [-by, -vy];
+        if (by > s.h - 1)
+            [by, vy] = [2 * (s.h - 1) - by, -vy];
+        // Paddles at x=1 and x=w-2; where the ball hits the paddle sets its angle.
+        if (vx < 0 && bx <= 1.5 && bx >= 0.5 && by >= you - 0.5 && by <= you + PADDLE - 0.5) {
+            [bx, vx, vy] = [1.5, Math.min(1.4, -vx * 1.05), (by - (you + PADDLE / 2 - 0.5)) * 0.5];
+        }
+        if (vx > 0 && bx >= s.w - 2.5 && bx <= s.w - 1.5 && by >= them - 0.5 && by <= them + PADDLE - 0.5) {
+            [bx, vx, vy] = [s.w - 2.5, -Math.min(1.4, vx * 1.05), (by - (them + PADDLE / 2 - 0.5)) * 0.5];
+        }
+        const next = { ...s, you, them, bx, by, vx, vy };
+        if (bx < 0)
+            return serve({ ...next, scores: [s.scores[0], s.scores[1] + 1] }, -1);
+        if (bx > s.w - 1)
+            return serve({ ...next, scores: [s.scores[0] + 1, s.scores[1]] }, 1);
+        return next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        for (let y = 0; y < s.h; y += 2)
+            grid[y][Math.floor(s.w / 2)] = "┊";
+        for (let k = 0; k < PADDLE; k++) {
+            grid[s.you + k][1] = "█";
+            grid[Math.round(s.them) + k][s.w - 2] = "█";
+        }
+        const bx = Math.round(s.bx);
+        const by = Math.round(s.by);
+        if (grid[by]?.[bx] !== undefined)
+            grid[by][bx] = "●";
+        const [a, b] = s.scores;
+        return {
+            lines: grid.map((r) => r.join("")),
+            status: `you ${a} · ${b} computer   ↑↓ move`,
+            ...(a >= PONG_WIN ? { over: "You win! ✦" } : b >= PONG_WIN ? { over: "The computer wins." } : {}),
+        };
+    },
+};
+const DIRS = { up: { x: 0, y: -1 }, down: { x: 0, y: 1 }, left: { x: -1, y: 0 }, right: { x: 1, y: 0 } };
+const OPPOSITE = { up: "down", down: "up", left: "right", right: "left" };
+function placeFood(s) {
+    for (let tries = 0; tries < 500; tries++) {
+        const p = { x: Math.floor(s.random() * s.w), y: Math.floor(s.random() * s.h) };
+        if (!s.body.some((b) => b.x === p.x && b.y === p.y))
+            return p;
+    }
+    return { x: 0, y: 0 };
+}
+export const snake = {
+    id: "snake",
+    title: "Snake",
+    blurb: "Eat, grow, don't bite yourself or the walls.",
+    controls: "arrows or wasd steer",
+    tickMs: 110,
+    colors: { "█": "#98c379", "▓": "#7ec16e", "◆": "#e06c75" },
+    create(w, h, seed = Date.now()) {
+        const y = Math.floor(h / 2);
+        const s = { w, h, body: [{ x: 4, y }, { x: 3, y }, { x: 2, y }], dir: "right", food: { x: 0, y: 0 }, score: 0, dead: false, random: rng(seed) };
+        return { ...s, food: placeFood(s) };
+    },
+    tick(s, inputs) {
+        if (s.dead)
+            return s;
+        let dir = s.dir;
+        // One turn per tick (the first that isn't straight back), so quick double taps don't fold it onto itself.
+        for (const i of inputs) {
+            if (i !== OPPOSITE[dir] && i !== dir) {
+                dir = i;
+                break;
+            }
+        }
+        const head = { x: s.body[0].x + DIRS[dir].x, y: s.body[0].y + DIRS[dir].y };
+        const eats = head.x === s.food.x && head.y === s.food.y;
+        const rest = eats ? s.body : s.body.slice(0, -1);
+        const dead = head.x < 0 || head.y < 0 || head.x >= s.w || head.y >= s.h || rest.some((b) => b.x === head.x && b.y === head.y);
+        if (dead)
+            return { ...s, dir, dead: true };
+        const next = { ...s, dir, body: [head, ...rest], score: s.score + (eats ? 1 : 0) };
+        return eats ? { ...next, food: placeFood(next) } : next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        grid[s.food.y][s.food.x] = "◆";
+        s.body.forEach((b, i) => {
+            if (grid[b.y]?.[b.x] !== undefined)
+                grid[b.y][b.x] = i === 0 ? "█" : "▓";
+        });
+        return { lines: grid.map((r) => r.join("")), status: `length ${s.body.length} · score ${s.score}`, ...(s.dead ? { over: `Game over: ${s.score} eaten.` } : {}) };
+    },
+};
+const PAD = 7;
+const BRICK_ROWS = 4;
+function launch(s) {
+    return { ...s, bx: s.paddle + PAD / 2, by: s.h - 3, vx: (s.random() < 0.5 ? -1 : 1) * 0.6, vy: -0.6 };
+}
+export const breakout = {
+    id: "breakout",
+    title: "Breakout",
+    blurb: "Knock out every brick with the ball. Three lives.",
+    controls: "←→ or a/d move",
+    tickMs: 45,
+    colors: { "▀": "#e06c75", "▄": "#d19a66", "▬": "#61afef", "●": "#e5c07b" },
+    create(w, h, seed = Date.now()) {
+        const s = {
+            w, h, paddle: Math.floor((w - PAD) / 2), bx: 0, by: 0, vx: 0, vy: 0,
+            bricks: Array.from({ length: BRICK_ROWS }, () => Array(Math.floor(w / 3)).fill(true)), lives: 3, score: 0, random: rng(seed),
+        };
+        return launch(s);
+    },
+    tick(s, inputs) {
+        if (s.lives <= 0 || s.bricks.every((r) => r.every((b) => !b)))
+            return s;
+        let paddle = s.paddle;
+        for (const i of inputs)
+            paddle += i === "left" ? -2 : i === "right" ? 2 : 0;
+        paddle = clamp(paddle, 0, s.w - PAD);
+        let { bx, by, vx, vy } = s;
+        bx += vx;
+        by += vy;
+        if (bx < 0 || bx > s.w - 1)
+            [bx, vx] = [clamp(bx, 0, s.w - 1), -vx];
+        if (by < 0)
+            [by, vy] = [0, -vy];
+        // Bricks are three columns wide, on rows 1.. so there's a gap at the top.
+        const bricks = s.bricks.map((r) => [...r]);
+        let score = s.score;
+        const row = Math.floor(by) - 1;
+        const col = Math.floor(bx / 3);
+        if (row >= 0 && row < BRICK_ROWS && bricks[row]?.[col]) {
+            bricks[row][col] = false;
+            score += (BRICK_ROWS - row) * 10;
+            vy = -vy;
+        }
+        // The paddle sits on the last row; where the ball lands on it sets the angle.
+        if (vy > 0 && by >= s.h - 2 && by < s.h - 1 && bx >= paddle - 0.5 && bx <= paddle + PAD - 0.5) {
+            vy = -Math.abs(vy);
+            vx = clamp((bx - (paddle + PAD / 2 - 0.5)) * 0.25, -1, 1) || 0.3;
+            by = s.h - 2;
+        }
+        const next = { ...s, paddle, bx, by, vx, vy, bricks, score };
+        if (by > s.h - 1) {
+            const lives = s.lives - 1;
+            return lives > 0 ? launch({ ...next, lives }) : { ...next, lives };
+        }
+        return next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        s.bricks.forEach((r, y) => r.forEach((alive, x) => {
+            if (alive)
+                for (let k = 0; k < 3; k++)
+                    if (x * 3 + k < s.w - 0)
+                        grid[y + 1][x * 3 + k] = y % 2 ? "▄" : "▀";
+        }));
+        for (let k = 0; k < PAD; k++)
+            grid[s.h - 1][s.paddle + k] = "▬";
+        const bx = Math.round(s.bx);
+        const by = Math.round(s.by);
+        if (s.lives > 0 && grid[by]?.[bx] !== undefined)
+            grid[by][bx] = "●";
+        const cleared = s.bricks.every((r) => r.every((b) => !b));
+        return {
+            lines: grid.map((r) => r.join("")),
+            status: `score ${s.score} · lives ${"♥".repeat(Math.max(0, s.lives))}`,
+            ...(cleared ? { over: `Cleared! ${s.score} points ✦` } : s.lives <= 0 ? { over: `Game over: ${s.score} points.` } : {}),
+        };
+    },
+};
+/** Every game Nou has, in the order settings lists them. */
+export const GAMES = [pong, snake, breakout];
+export const gameById = (id) => GAMES.find((g) => g.id === id);

package/dist/src/mcp/import.js

@@ -0,0 +1,106 @@
+import { readFileSync } from "fs";
+import os from "os";
+import path from "path";
+function json(file) {
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Keeps the fields Nou uses, from a server entry in any of these formats. */
+function normalize(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const out = {};
+    if (typeof raw.command === "string")
+        out.command = raw.command;
+    if (Array.isArray(raw.args))
+        out.args = raw.args.map(String);
+    if (raw.env && typeof raw.env === "object")
+        out.env = Object.fromEntries(Object.entries(raw.env).map(([k, v]) => [k, String(v)]));
+    if (typeof raw.cwd === "string")
+        out.cwd = raw.cwd;
+    const url = raw.url ?? raw.serverUrl ?? raw.httpUrl;
+    if (typeof url === "string")
+        out.url = url;
+    if (raw.headers && typeof raw.headers === "object")
+        out.headers = Object.fromEntries(Object.entries(raw.headers).map(([k, v]) => [k, String(v)]));
+    if (raw.disabled === true)
+        out.disabled = true;
+    return out.command || out.url ? out : null;
+}
+/** The [mcp_servers.<name>] tables of a Codex config.toml (just the keys MCP servers use). */
+export function codexServers(toml) {
+    const out = {};
+    let current = null;
+    let sub = null;
+    const value = (v) => {
+        v = v.trim();
+        if (v.startsWith("\"") || v.startsWith("'"))
+            return v.slice(1, v.lastIndexOf(v[0])).replace(/\\"/g, "\"");
+        if (v.startsWith("["))
+            return [...v.matchAll(/"((?:\\.|[^"\\])*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2]);
+        if (v.startsWith("{"))
+            return Object.fromEntries([...v.matchAll(/([\w-]+)\s*=\s*"((?:\\.|[^"\\])*)"/g)].map((m) => [m[1], m[2]]));
+        if (v === "true" || v === "false")
+            return v === "true";
+        return v;
+    };
+    for (const raw of toml.split(/\r?\n/)) {
+        const line = raw.replace(/\s+#.*$/, "").trim();
+        const table = line.match(/^\[mcp_servers\.("?)([^"\].]+)\1(?:\.(\w+))?\]$/);
+        if (table) {
+            out[table[2]] ??= {};
+            current = out[table[2]];
+            sub = table[3] ?? null;
+            if (sub)
+                current[sub] ??= {};
+            continue;
+        }
+        if (line.startsWith("[")) {
+            current = null;
+            continue;
+        }
+        const kv = line.match(/^([\w-]+)\s*=\s*(.+)$/);
+        if (current && kv)
+            (sub ? current[sub] : current)[kv[1]] = value(kv[2]);
+    }
+    return Object.fromEntries(Object.entries(out).map(([k, v]) => [k, normalize({ ...v, disabled: v.enabled === false })]).filter(([, v]) => v));
+}
+/** Every MCP server set up in the other tools on this machine (and in this project), first source wins per name. */
+export function findOtherMcpServers(home = os.homedir(), cwd = process.cwd()) {
+    const appData = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+    const claudeDesktop = process.platform === "darwin"
+        ? path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+        : process.platform === "win32" ? path.join(appData, "Claude", "claude_desktop_config.json") : path.join(home, ".config", "Claude", "claude_desktop_config.json");
+    const claudeCode = json(path.join(home, ".claude.json"));
+    const sources = [
+        { from: "Claude Code", servers: claudeCode?.mcpServers },
+        { from: "Claude Code (this project)", servers: claudeCode?.projects?.[cwd]?.mcpServers },
+        { from: "Claude Desktop", servers: json(claudeDesktop)?.mcpServers },
+        { from: "Cursor", servers: json(path.join(home, ".cursor", "mcp.json"))?.mcpServers },
+        { from: "Cursor (this project)", servers: json(path.join(cwd, ".cursor", "mcp.json"))?.mcpServers },
+        { from: "Windsurf", servers: json(path.join(home, ".codeium", "windsurf", "mcp_config.json"))?.mcpServers },
+        { from: "VS Code (this project)", servers: json(path.join(cwd, ".vscode", "mcp.json"))?.servers },
+        { from: "Gemini CLI", servers: json(path.join(home, ".gemini", "settings.json"))?.mcpServers },
+    ];
+    try {
+        sources.push({ from: "Codex", servers: codexServers(readFileSync(path.join(home, ".codex", "config.toml"), "utf-8")) });
+    }
+    catch {
+        // no Codex config
+    }
+    const found = [];
+    for (const { from, servers } of sources) {
+        if (!servers || typeof servers !== "object")
+            continue;
+        for (const [name, raw] of Object.entries(servers)) {
+            const config = normalize(raw);
+            if (config && !found.some((f) => f.name === name))
+                found.push({ name, config, from });
+        }
+    }
+    return found;
+}

package/dist/src/mcp/index.js

@@ -0,0 +1,184 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { NOU_HOME } from "../config/index.js";
+export const USER_MCP_FILE = path.join(NOU_HOME, "mcp.json");
+/** Project MCP files (only read in a folder you trust: they start programs). */
+const PROJECT_MCP_FILES = [".mcp.json", path.join(".nou", "mcp.json")];
+/** Ready-made servers: `/mcp add browser` and so on. */
+export const MCP_PRESETS = {
+    browser: { config: { command: "npx", args: ["-y", "@playwright/mcp@latest"] }, about: "control a browser: open pages, click, type, read them, take screenshots (Playwright)" },
+    fetch: { config: { command: "uvx", args: ["mcp-server-fetch"] }, about: "fetch web pages as text (needs uv)" },
+};
+function readServers(file) {
+    try {
+        const json = JSON.parse(readFileSync(file, "utf-8"));
+        const servers = json?.mcpServers ?? json?.servers ?? {};
+        return typeof servers === "object" && servers ? servers : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Every configured server: yours (~/.nou/mcp.json) and, in a trusted folder, the project's. */
+export function loadMcpServers(trusted) {
+    const out = [];
+    for (const [name, config] of Object.entries(readServers(USER_MCP_FILE)))
+        out.push({ name, config, scope: "user", file: USER_MCP_FILE });
+    if (trusted) {
+        for (const rel of PROJECT_MCP_FILES) {
+            const file = path.resolve(rel);
+            for (const [name, config] of Object.entries(readServers(file))) {
+                if (!out.some((e) => e.name === name))
+                    out.push({ name, config, scope: "project", file });
+            }
+        }
+    }
+    return out.filter((e) => e.config && (e.config.command || e.config.url));
+}
+/** Adds (or replaces) servers in ~/.nou/mcp.json. */
+export function saveUserServers(servers) {
+    let json = {};
+    try {
+        json = JSON.parse(readFileSync(USER_MCP_FILE, "utf-8"));
+    }
+    catch {
+        // a new file
+    }
+    json.mcpServers = { ...(json.mcpServers ?? {}), ...servers };
+    if (!existsSync(NOU_HOME))
+        mkdirSync(NOU_HOME, { recursive: true });
+    writeFileSync(USER_MCP_FILE, JSON.stringify(json, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(USER_MCP_FILE, 0o600); // it can hold tokens
+    }
+    catch {
+        // Windows ignores it
+    }
+}
+export function removeUserServer(name) {
+    try {
+        const json = JSON.parse(readFileSync(USER_MCP_FILE, "utf-8"));
+        if (!json.mcpServers?.[name])
+            return false;
+        delete json.mcpServers[name];
+        writeFileSync(USER_MCP_FILE, JSON.stringify(json, null, 2), { mode: 0o600 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Tool names the model sees: mcp__server__tool, in the characters every provider accepts. */
+const toolName = (server, tool) => `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64);
+/** Keeps the end of a server's stderr, to say why it failed (it never reaches the screen). */
+function tailOf(stream) {
+    let text = "";
+    stream?.on("data", (chunk) => {
+        text = (text + String(chunk)).slice(-2000);
+    });
+    return () => text.trim().split("\n").slice(-3).join(" ").slice(0, 300);
+}
+/**
+ * Connects to the MCP servers and turns their tools into tools for Nou's engine. A server's output goes to
+ * a buffer, never the terminal, so it can't scribble over Nou's screen; tools that change things ask
+ * first, like Nou's own.
+ */
+export class McpManager {
+    onChange;
+    servers = new Map();
+    constructor(onChange) {
+        this.onChange = onChange;
+    }
+    status() {
+        return [...this.servers.values()].map((s) => s.status);
+    }
+    /** Connects to every enabled server in `entries` (already connected ones are kept). */
+    async connect(entries) {
+        const wanted = new Set(entries.map((e) => e.name));
+        for (const [name, s] of this.servers) {
+            if (!wanted.has(name)) {
+                void s.client?.close().catch(() => { });
+                this.servers.delete(name);
+            }
+        }
+        await Promise.all(entries.filter((e) => !this.servers.has(e.name)).map((e) => this.start(e)));
+    }
+    async start(entry) {
+        const status = { name: entry.name, scope: entry.scope, state: entry.config.disabled ? "off" : "connecting", tools: 0 };
+        const slot = { status, tools: [] };
+        this.servers.set(entry.name, slot);
+        this.onChange();
+        if (entry.config.disabled)
+            return;
+        let stderr = () => "";
+        try {
+            const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+            const client = new Client({ name: "nou", version: "1" });
+            let transport;
+            if (entry.config.url) {
+                const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+                transport = new StreamableHTTPClientTransport(new URL(entry.config.url), entry.config.headers ? { requestInit: { headers: entry.config.headers } } : undefined);
+            }
+            else {
+                const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+                transport = new StdioClientTransport({
+                    command: entry.config.command,
+                    args: entry.config.args ?? [],
+                    // The SDK adds a safe base (PATH, HOME...) to these: your API keys aren't passed to every server.
+                    ...(entry.config.env ? { env: entry.config.env } : {}),
+                    cwd: entry.config.cwd ?? process.cwd(),
+                    stderr: "pipe",
+                });
+                stderr = tailOf(transport.stderr);
+            }
+            await withTimeout(client.connect(transport), 30_000, "didn't answer within 30 seconds");
+            const { tools } = await withTimeout(client.listTools(), 15_000, "didn't list its tools");
+            Object.assign(slot, { client, transport, tools });
+            slot.status = { ...status, state: "ready", tools: tools.length };
+        }
+        catch (error) {
+            const why = stderr();
+            slot.status = { ...status, state: "failed", error: `${error?.message ?? error}${why ? ` (${why})` : ""}` };
+        }
+        this.onChange();
+    }
+    /** The connected servers' tools, ready for the engine. */
+    tools() {
+        const out = [];
+        for (const [server, s] of this.servers) {
+            if (s.status.state !== "ready")
+                continue;
+            for (const tool of s.tools) {
+                const schema = tool.inputSchema && typeof tool.inputSchema === "object" ? tool.inputSchema : {};
+                out.push({
+                    definition: {
+                        name: toolName(server, tool.name),
+                        description: `[${server}] ${tool.description ?? tool.name}`.slice(0, 1000),
+                        parameters: { ...schema, type: "object", properties: schema.properties ?? {}, required: Array.isArray(schema.required) ? schema.required : [] },
+                    },
+                    // Only tools that say they don't change anything run without asking.
+                    readOnly: tool.annotations?.readOnlyHint === true,
+                    source: `mcp:${server}`,
+                    run: async (args) => {
+                        const result = await s.client.callTool({ name: tool.name, arguments: args }, undefined, { timeout: 180_000 });
+                        const parts = (result.content ?? []).map((c) => (c.type === "text" ? c.text : c.type === "resource" ? c.resource?.text ?? "" : `[${c.type}]`));
+                        const text = parts.join("\n").trim() || "(no output)";
+                        return result.isError ? `Error: ${text}` : text;
+                    },
+                });
+            }
+        }
+        return out;
+    }
+    close() {
+        for (const s of this.servers.values())
+            void s.client?.close().catch(() => { });
+        this.servers.clear();
+    }
+}
+function withTimeout(promise, ms, why) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(why)), ms);
+        promise.then((v) => (clearTimeout(timer), resolve(v)), (e) => (clearTimeout(timer), reject(e)));
+    });
+}

package/dist/src/providers/anthropic.js

@@ -37,6 +37,21 @@ function toAnthropic(messages) {
     }
     return out;
 }
+/**
+ * Marks the end of the conversation for prompt caching, so the next request (every tool step of a turn)
+ * reads all of it from the cache instead of paying for it again: cached input costs a tenth or less.
+ */
+function withCacheBreakpoint(params) {
+    const last = params[params.length - 1];
+    if (!last)
+        return params;
+    const content = typeof last.content === "string" ? [{ type: "text", text: last.content }] : [...last.content];
+    const end = content[content.length - 1];
+    if (!end || end.type === "thinking" || end.type === "redacted_thinking")
+        return params;
+    content[content.length - 1] = { ...end, cache_control: { type: "ephemeral" } };
+    return [...params.slice(0, -1), { ...last, content }];
+}
 function hasCredentials() {
     return !!(process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_PROFILE)
         || existsSync(path.join(os.homedir(), ".config", "anthropic"));
@@ -46,8 +61,9 @@ export function anthropicProvider() {
     let client = null;
     const getClient = () => {
         const auth = `${process.env.ANTHROPIC_API_KEY}|${process.env.ANTHROPIC_AUTH_TOKEN}|${process.env.ANTHROPIC_BASE_URL}`;
+        // No retries here: the agent retries failed requests itself (with backoff), and both would multiply.
         if (client?.auth !== auth)
-            client = { auth, api: new Anthropic() };
+            client = { auth, api: new Anthropic({ maxRetries: 0 }) };
         return client.api;
     };
     return {
@@ -72,7 +88,7 @@ export function anthropicProvider() {
                 model,
                 max_tokens: 64000,
                 system: [{ type: "text", text: system, cache_control: { type: "ephemeral" } }],
-                messages: toAnthropic(messages),
+                messages: withCacheBreakpoint(toAnthropic(messages)),
                 tools: tools.map((t) => ({
                     name: t.name,
                     description: t.description,
@@ -80,6 +96,8 @@ export function anthropicProvider() {
                     eager_input_streaming: true,
                 })),
                 stream: true,
+                // Current models think between tool calls; summarized, that shows what they're doing instead of a silence.
+                ...(EFFORT_MODELS.test(model) ? { thinking: { type: "adaptive", display: "summarized" } } : {}),
                 ...(effort ? { output_config: { effort: effort } } : {}),
                 ...(fallbacks ? { betas: ["server-side-fallback-2026-07-01"], fallbacks: "default" } : {}),
             };
@@ -87,7 +105,20 @@ export function anthropicProvider() {
                 let text = "";
                 try {
                     const stream = getClient().beta.messages.stream(body, signal ? { signal } : {});
+                    // Thinking streams as a quote above the reply (the chat shows quotes dimmed); only the reply is kept.
+                    let thinking = false;
+                    stream.on("thinking", (delta) => {
+                        const piece = `${thinking ? "" : "> "}${delta.replace(/\n/g, "\n> ")}`;
+                        thinking = true;
+                        text += piece;
+                        onText(piece);
+                    });
                     stream.on("text", (delta) => {
+                        if (thinking) {
+                            thinking = false;
+                            text += "\n\n";
+                            onText("\n\n");
+                        }
                         text += delta;
                         onText(delta);
                     });

package/dist/src/providers/index.js

@@ -27,6 +27,19 @@ export function resolveModel(spec) {
 export const describe = (choice) => `${choice.provider.id}:${choice.model}`;
 /** Whether a provider error means the API key is wrong (rather than, say, the server being down). */
 export const rejectedKey = (error) => /\b(401|403)\b|api key|unauthori[sz]ed|authentication/i.test(error);
+/**
+ * Whether an error is the provider's setup rather than the request: a rejected key, a URL that doesn't
+ * answer, or a model it doesn't have. Each has a place in settings to fix it.
+ */
+export function setupProblem(provider, error) {
+    if (rejectedKey(error) && provider.connect?.some((f) => f.secret))
+        return "key";
+    if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|getaddrinfo|fetch failed|Connection error|Invalid URL|connect ETIMEDOUT/i.test(error) && provider.connect?.some((f) => !f.secret))
+        return "url";
+    if (/model\b[^.]*\b(not found|does not exist|not exist|invalid|unknown|not available|not supported)|(invalid|unknown|no such) model|model_not_found/i.test(error))
+        return "model";
+    return null;
+}
 /**
  * For an error that says the key was rejected: which key, where it was set, and how to fix it.
  * The usual cause is a project's .env holding a key for the app rather than for Nou.

package/dist/src/providers/openai.js

@@ -52,7 +52,7 @@ export function openAICompatibleProvider(preset) {
         const url = baseURL();
         const key = apiKey();
         if (client?.url !== url || client.key !== key)
-            client = { url, key, api: new OpenAI({ baseURL: url, apiKey: key }) };
+            client = { url, key, api: new OpenAI({ baseURL: url, apiKey: key, maxRetries: 0 }) };
         return client.api;
     };
     const connect = [
@@ -73,9 +73,13 @@ export function openAICompatibleProvider(preset) {
                 return `set ${preset.keyEnv}`;
             return null;
         },
-        async chat({ model, system, messages, tools, onText, signal }) {
+        async chat({ model, system, messages, tools, onText, signal, effort }) {
+            // OpenAI's reasoning models take an effort too (named in the model id, through a gateway too). Nou's
+            // default, high, is their default, medium; xhigh and max are their high.
+            const reasoning = effort && /(^|\/)(gpt-5|o\d)/.test(model) && !/-chat|o1-(preview|mini)/.test(model) ? { low: "low", medium: "low", high: "medium" }[effort] ?? "high" : null;
             const stream = await getClient().chat.completions.create({
                 model,
+                ...(reasoning ? { reasoning_effort: reasoning } : {}),
                 messages: toOpenAI(system, messages),
                 ...(tools.length ? { tools: tools.map((t) => ({ type: "function", function: t })) } : {}),
                 stream: true,