nou-cli 0.2.1 → 0.4.0

package/dist/src/engines/pi.js

@@ -0,0 +1,161 @@
+import { toRelative } from "../commands/index.js";
+import { ExternalEngine, replaceIn } from "./external.js";
+import { loadPackage } from "./index.js";
+import { readFileSync } from "fs";
+import path from "path";
+/** Nou provider id -> pi's id for the same service, where pi has it built in. */
+const PI_PROVIDERS = {
+    anthropic: "anthropic",
+    openai: "openai",
+    gemini: "google",
+    openrouter: "openrouter",
+    groq: "groq",
+    deepseek: "deepseek",
+};
+const THINKING = { low: "low", medium: "medium", high: "high", xhigh: "high", max: "high" };
+/** The file's content after a pi edit or write, or undefined if it can't be worked out in advance. */
+export function piProposedContent(tool, input) {
+    if (tool === "write")
+        return String(input.content ?? "");
+    let text;
+    try {
+        text = readFileSync(path.resolve(process.cwd(), input.path), "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+    // pi matches every oldText against the original file, so apply them to it one at a time.
+    for (const edit of Array.isArray(input.edits) ? input.edits : [])
+        text = text === null ? null : replaceIn(text, edit.oldText, edit.newText);
+    return text ?? undefined;
+}
+/**
+ * pi through its SDK, with the model picked in Nou (pi's built-in provider when it has one, otherwise
+ * Nou's endpoint for it, e.g. Ollama). An inline extension sends pi's edits and commands to Nou's approval.
+ */
+export class PiEngine extends ExternalEngine {
+    id = "pi";
+    piSession = null;
+    constructor(choice, hooks) {
+        super(choice, hooks, "pi");
+    }
+    resetConversation() {
+        this.piSession?.dispose();
+        this.piSession = null;
+    }
+    dispose() {
+        this.resetConversation();
+    }
+    /** The pi model for Nou's current choice. */
+    async model(pi, runtime) {
+        const { provider, model } = this.choice;
+        const builtIn = PI_PROVIDERS[provider.id] && runtime.getModel(PI_PROVIDERS[provider.id], model);
+        if (builtIn)
+            return builtIn;
+        const endpoint = provider.endpoint?.();
+        if (!endpoint)
+            throw new Error(`pi can't use ${provider.label}`);
+        const id = `nou-${provider.id}`;
+        runtime.registerProvider(id, {
+            baseUrl: endpoint.baseURL,
+            apiKey: endpoint.apiKey || "none",
+            api: endpoint.api,
+            // pi needs the full model description; these are safe defaults for a model it doesn't know.
+            models: [{
+                    id: model, name: model, input: ["text"], reasoning: false, contextWindow: 32_768, maxTokens: 8192,
+                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                }],
+        });
+        const found = runtime.getModel(id, model);
+        if (!found)
+            throw new Error(`pi couldn't set up ${provider.id}:${model}`);
+        return found;
+    }
+    async start() {
+        const pi = await loadPackage("@earendil-works/pi-coding-agent");
+        const runtime = await pi.ModelRuntime.create();
+        const cwd = process.cwd();
+        const loader = new pi.DefaultResourceLoader({
+            cwd,
+            agentDir: pi.getAgentDir(),
+            appendSystemPromptOverride: (base) => [...base, ...this.extras],
+            extensionFactories: [(api) => this.connect(api)],
+        });
+        await loader.reload();
+        const { session } = await pi.createAgentSession({
+            cwd,
+            model: await this.model(pi, runtime),
+            modelRuntime: runtime,
+            resourceLoader: loader,
+            sessionManager: pi.SessionManager.inMemory(),
+            ...(this.effort && THINKING[this.effort] ? { thinkingLevel: THINKING[this.effort] } : {}),
+        });
+        return session;
+    }
+    /** Nou's approvals, undo and problem checks, as a pi extension. */
+    connect(api) {
+        api.on("tool_call", async (event) => {
+            const input = event.input ?? {};
+            if ((event.toolName === "edit" || event.toolName === "write") && input.path) {
+                const ok = await this.tracker.approve(input.path, piProposedContent(event.toolName, input), event.toolName);
+                return ok ? undefined : { block: true, reason: "The user rejected this change. Ask them what they would like instead." };
+            }
+            if (event.toolName === "bash" || event.toolName === "powershell") {
+                const ok = await this.hooks.approve({ kind: "command", command: String(input.command ?? "") });
+                if (!ok)
+                    this.hooks.onEntry({ kind: "tool", text: `Denied: ${input.command}` });
+                return ok ? undefined : { block: true, reason: "The user denied permission to run this command." };
+            }
+            if (["read", "grep", "find", "ls"].includes(event.toolName))
+                return undefined;
+            // Tools from pi extensions or packages: ask, like Nou's own plugin tools.
+            const ok = await this.hooks.approve({ kind: "tool", name: event.toolName, args: input });
+            return ok ? undefined : { block: true, reason: "The user denied this." };
+        });
+        api.on("tool_result", async (event) => {
+            const input = event.input ?? {};
+            if ((event.toolName === "edit" || event.toolName === "write") && input.path) {
+                const problems = await this.tracker.applied(input.path);
+                if (problems)
+                    return { content: [...event.content, { type: "text", text: `\n\nThis edit introduced problems; fix them:\n${problems}` }] };
+                return undefined;
+            }
+            if (event.toolName === "read" && input.path)
+                this.hooks.onRead(toRelative(input.path));
+            const target = input.command ?? input.path ?? input.pattern ?? "";
+            this.hooks.onEntry({ kind: "tool", text: event.toolName === "bash" || event.toolName === "powershell" ? `Ran: ${target}` : `${event.toolName} ${target}`.trim() });
+            return undefined;
+        });
+    }
+    async run(prompt, signal) {
+        this.piSession ??= await this.start();
+        const session = this.piSession;
+        let streamed = "";
+        const unsubscribe = session.subscribe((event) => {
+            if (event.type === "message_update" && event.assistantMessageEvent?.type === "text_delta") {
+                streamed += event.assistantMessageEvent.delta;
+                this.hooks.onStream(streamed);
+            }
+            else if (event.type === "message_end" && event.message?.role === "assistant") {
+                streamed = "";
+                this.hooks.onStream("");
+                const text = (event.message.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+                if (text)
+                    this.hooks.onEntry({ kind: "assistant", text });
+                if (event.message.stopReason === "error" && !signal.aborted)
+                    this.hooks.onEntry({ kind: "error", text: `pi: ${event.message.errorMessage ?? "the request failed"}` });
+            }
+        });
+        const onAbort = () => void session.abort();
+        signal.addEventListener("abort", onAbort);
+        try {
+            await session.prompt(prompt);
+        }
+        finally {
+            signal.removeEventListener("abort", onAbort);
+            unsubscribe();
+        }
+        if (signal.aborted)
+            throw new Error("aborted");
+    }
+}

package/dist/src/engines/types.js

@@ -0,0 +1 @@
+export const ENGINE_IDS = ["nou", "claude-code", "codex", "pi"];

package/dist/src/env.js

@@ -1,4 +1,5 @@
 import { existsSync } from "fs";
+import { noteOrigin } from "./config/origins.js";
 // This module must be imported before anything else (index.ts imports it first).
 // npm only warns about an unsupported Node version, so check here, before Ink loads and fails confusingly.
 const [major, minor] = process.versions.node.split(".").map(Number);
@@ -8,5 +9,8 @@ if (major < 22 || (major === 22 && minor < 12)) {
 }
 // Load the project's .env (API keys, base URLs). Providers read their settings when they load,
 // so loading .env later would be too late for them.
-if (existsSync(".env"))
+if (existsSync(".env")) {
+    const before = new Set(Object.keys(process.env));
     process.loadEnvFile(".env");
+    noteOrigin(Object.keys(process.env).filter((name) => !before.has(name)), ".env");
+}

package/dist/src/git/index.js

@@ -1,4 +1,4 @@
-import { execFileSync } from "child_process";
+import { execFile, execFileSync } from "child_process";
 import path from "path";
 function git(args) {
     return execFileSync("git", args, { cwd: process.cwd(), encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 20 * 1024 * 1024 });
@@ -25,11 +25,21 @@ function fromRoot(p) {
 function toRoot(p) {
     return path.relative(repoRoot(), path.resolve(process.cwd(), p)).replace(/\\/g, "/");
 }
+const STATUS_ARGS = ["status", "--porcelain=v1", "-z", "-uall"];
 export function status() {
-    const result = new Map();
+    return isRepo() ? parseStatus(tryGit(STATUS_ARGS)) : new Map();
+}
+/** status() without blocking: for background refreshes, where a large repo can take a while. */
+export function statusAsync() {
     if (!isRepo())
-        return result;
-    const out = tryGit(["status", "--porcelain=v1", "-z", "-uall"]);
+        return Promise.resolve(new Map());
+    return new Promise((resolve) => {
+        execFile("git", STATUS_ARGS, { cwd: process.cwd(), encoding: "utf-8", maxBuffer: 20 * 1024 * 1024 }, (error, out) => resolve(parseStatus(error ? null : out)));
+    });
+}
+export const sameStatus = (a, b) => a.size === b.size && [...a].every(([file, code]) => b.get(file) === code);
+function parseStatus(out) {
+    const result = new Map();
     if (!out)
         return result;
     const parts = out.split("\0");

package/dist/src/history/index.js

@@ -3,6 +3,8 @@ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import { applyPatch, structuredPatch } from "diff";
 import { NOU_HOME } from "../config/index.js";
+/** "<session>:<turn>" -> session id (null for older entries that stored a bare turn number). */
+const sessionOf = (turn) => (typeof turn === "string" && turn.includes(":") ? turn.slice(0, turn.lastIndexOf(":")) : null);
 const MAX_CHECKPOINTS = 300;
 const MAX_FILE_BYTES = 1_000_000;
 function readOrNull(file) {
@@ -19,6 +21,8 @@ export class Timeline {
     items = [];
     nextId = 1;
     file;
+    saveTimer = null;
+    exitHook = null;
     constructor(onUpdate = () => { }) {
         this.onUpdate = onUpdate;
         const key = createHash("sha1").update(process.cwd()).digest("hex").slice(0, 16);
@@ -58,6 +62,37 @@ export class Timeline {
             return [];
         return this.items.filter((c) => c.source === "nou" && !c.undone && c.turn === last.turn).reverse();
     }
+    /** Sessions that changed files, newest first. Older history entries without a session id are skipped. */
+    sessions() {
+        const byId = new Map();
+        for (const c of this.items) {
+            const id = sessionOf(c.turn);
+            if (!id)
+                continue;
+            const s = byId.get(id) ?? { id, start: c.time, end: c.time, files: [] };
+            s.end = c.time;
+            if (!s.files.includes(c.path))
+                s.files.push(c.path);
+            byId.set(id, s);
+        }
+        return [...byId.values()].reverse();
+    }
+    /**
+     * The net change to each file over one session (yours and Nou's, undos included): from the file as it
+     * was before the session's first change to it, to after its last. Files that ended up unchanged are left out.
+     */
+    sessionChanges(session) {
+        const byPath = new Map();
+        for (const c of this.items) {
+            if (sessionOf(c.turn) !== session)
+                continue;
+            const seen = byPath.get(c.path);
+            byPath.set(c.path, { before: seen ? seen.before : c.before, after: c.after });
+        }
+        return [...byPath]
+            .filter(([, { before, after }]) => before !== after)
+            .map(([file, { before, after }]) => ({ path: file, before: before ?? "", after: after ?? "", isNew: before === null }));
+    }
     /**
      * Reverts one checkpoint. If the file changed since, only Nou's part is reversed (patch merge);
      * if that conflicts, nothing is written.
@@ -99,7 +134,25 @@ export class Timeline {
         this.save();
         return { ok: true, path: checkpoint.path, merged };
     }
+    /**
+     * History can hold hundreds of whole files, so it's written shortly after changes stop (an agent turn
+     * makes many in a row) instead of rewriting the file on every edit. flush() writes it now.
+     */
     save() {
+        if (!this.saveTimer) {
+            this.saveTimer = setTimeout(() => this.flush(), 500);
+            this.saveTimer.unref?.();
+            if (!this.exitHook) {
+                this.exitHook = () => this.flush();
+                process.on("exit", this.exitHook);
+            }
+        }
+        this.onUpdate();
+    }
+    flush() {
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.saveTimer = null;
         try {
             if (!existsSync(path.dirname(this.file)))
                 mkdirSync(path.dirname(this.file), { recursive: true });
@@ -108,6 +161,5 @@ export class Timeline {
         catch {
             // history is best effort
         }
-        this.onUpdate();
     }
 }

package/dist/src/plugins/index.js

@@ -1,7 +1,7 @@
 import { createHash } from "crypto";
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import path from "path";
-import { pathToFileURL } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 import { NOU_HOME } from "../config/index.js";
 import { eslintProvider, ruffProvider, typescriptProvider } from "../diagnostics/providers.js";
 import { syntaxProvider } from "../syntax/index.js";
@@ -90,6 +90,27 @@ export const PLUGIN_DIRS = [
     { scope: "user", dir: path.join(NOU_HOME, "plugins") },
 ];
 const EXTENSIONS = [".js", ".mjs", ".ts", ".mts"];
+/** The entry for a plugin file or folder, or undefined if it isn't one. */
+function entryFor(full, scope) {
+    const name = path.basename(full);
+    let file;
+    if (statSync(full).isDirectory()) {
+        file = EXTENSIONS.map((ext) => path.join(full, `index${ext}`)).find(existsSync);
+    }
+    else if (EXTENSIONS.includes(path.extname(name))) {
+        file = full;
+    }
+    if (!file)
+        return undefined;
+    let hash;
+    try {
+        hash = hashPlugin(full);
+    }
+    catch {
+        // unreadable: stays untrusted
+    }
+    return { id: path.basename(name, path.extname(name)), file, root: full, scope, ...(hash ? { hash } : {}) };
+}
 /** Finds plugin files without running them. */
 export function discoverPlugins() {
     const found = [];
@@ -97,29 +118,96 @@ export function discoverPlugins() {
         if (!existsSync(dir))
             continue;
         for (const name of readdirSync(dir)) {
-            const full = path.join(dir, name);
-            let file;
-            if (statSync(full).isDirectory()) {
-                file = EXTENSIONS.map((ext) => path.join(full, `index${ext}`)).find(existsSync);
-            }
-            else if (EXTENSIONS.includes(path.extname(name))) {
-                file = full;
-            }
-            const id = path.basename(name, path.extname(name));
-            if (file && !found.some((p) => p.id === id)) {
-                let hash;
-                try {
-                    hash = hashPlugin(full);
-                }
-                catch {
-                    // unreadable: stays untrusted
-                }
-                found.push({ id, file, root: full, scope, ...(hash ? { hash } : {}) });
-            }
+            const entry = entryFor(path.join(dir, name), scope);
+            if (entry && !found.some((p) => p.id === entry.id))
+                found.push(entry);
         }
     }
     return found;
 }
+/** The plugins/ folder of the Nou package (next to package.json, from source or the installed build). */
+function starterDir() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 5; i++) {
+        if (existsSync(path.join(dir, "package.json")) && existsSync(path.join(dir, "plugins")))
+            return path.join(dir, "plugins");
+        dir = path.dirname(dir);
+    }
+    return undefined;
+}
+/**
+ * Optional plugins that ship with Nou to get you started. They're Nou's own code, so they can be loaded to
+ * show their name and description, but they only run once you add one (see addStarter).
+ */
+export function starterPlugins() {
+    const dir = starterDir();
+    if (!dir)
+        return [];
+    return readdirSync(dir)
+        .filter((name) => EXTENSIONS.includes(path.extname(name)))
+        .sort()
+        .map((name) => ({ id: path.basename(name, path.extname(name)), file: path.join(dir, name), scope: "starter" }));
+}
+/**
+ * Adds a starter plugin: copies it into ~/.nou/plugins/ (keeping any copy already there), where it works like
+ * a plugin you wrote. Returns the new entry; switch it on with trustPatch.
+ */
+export function addStarter(starter) {
+    const dir = PLUGIN_DIRS.find((d) => d.scope === "user").dir;
+    mkdirSync(dir, { recursive: true });
+    const target = path.join(dir, path.basename(starter.file));
+    if (!existsSync(target))
+        copyFileSync(starter.file, target);
+    return entryFor(target, "user");
+}
+const TEMPLATE = (name) => `// Nou plugin. Edit it, then switch it on in /settings → Plugins (edits need switching on again).
+// More: the starter plugins in ~/.nou/plugins/ once added, and the Plugins section of Nou's README.
+
+export default {
+  name: ${JSON.stringify(name)},
+  version: "0.1.0",
+  description: "What this plugin does.",
+
+  // Extra instructions for the model while the plugin is on.
+  // systemPrompt: "Use ${name.replace(/\W/g, "_")}_hello when ...",
+
+  tools: [
+    {
+      readOnly: true, // read-only tools run without asking; leave this out for anything that changes things
+      definition: {
+        name: ${JSON.stringify(`${name.replace(/\W/g, "_")}_hello`)},
+        description: "Say hello (replace with what your tool does)",
+        parameters: { type: "object", properties: { who: { type: "string", description: "Who to greet" } } },
+      },
+      run(args, ctx) {
+        return \`Hello \${args.who ?? "world"} from \${ctx.cwd}\`;
+      },
+    },
+  ],
+
+  commands: [
+    {
+      name: ${JSON.stringify(name)},
+      description: "Try it: /${name} [args]",
+      run(args, ctx) {
+        return \`/${name} ran in \${ctx.cwd} with "\${args}"\`;
+      },
+    },
+  ],
+};
+`;
+/** Creates .nou/plugins/<name>.mjs in this project from a commented template. Returns its path. */
+export function scaffoldPlugin(name) {
+    if (!/^[a-z0-9][a-z0-9-]*$/i.test(name))
+        throw new Error("use letters, numbers and dashes, e.g. /plugins new deploy");
+    const dir = PLUGIN_DIRS.find((d) => d.scope === "project").dir;
+    const file = path.join(dir, `${name}.mjs`);
+    if (existsSync(file))
+        throw new Error(`${path.relative(process.cwd(), file)} already exists`);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(file, TEMPLATE(name));
+    return file;
+}
 export async function loadPlugin(entry) {
     try {
         const mod = await import(pathToFileURL(entry.file).href);

package/dist/src/providers/anthropic.js

@@ -42,14 +42,29 @@ function hasCredentials() {
         || existsSync(path.join(os.homedir(), ".config", "anthropic"));
 }
 export function anthropicProvider() {
+    // Rebuilt when the key or URL changes (they can be entered while Nou runs).
     let client = null;
-    const getClient = () => (client ??= new Anthropic());
+    const getClient = () => {
+        const auth = `${process.env.ANTHROPIC_API_KEY}|${process.env.ANTHROPIC_AUTH_TOKEN}|${process.env.ANTHROPIC_BASE_URL}`;
+        if (client?.auth !== auth)
+            client = { auth, api: new Anthropic() };
+        return client.api;
+    };
     return {
         id: "anthropic",
         label: "Anthropic (Claude)",
         local: false,
         defaultModel: "claude-opus-5-5",
+        connect: [
+            { env: "ANTHROPIC_API_KEY", label: "API key", secret: true, placeholder: "console.anthropic.com/settings/keys" },
+            { env: "ANTHROPIC_BASE_URL", label: "Base URL", optional: true, placeholder: "https://api.anthropic.com" },
+        ],
         unavailable: () => (hasCredentials() ? null : "set ANTHROPIC_API_KEY (or run `ant auth login`)"),
+        endpoint: () => ({
+            baseURL: process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com",
+            apiKey: process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || "",
+            api: "anthropic-messages",
+        }),
         async chat({ model, system, messages, tools, onText, signal, effort: requested }) {
             const fallbacks = FALLBACK_MODELS.test(model);
             const effort = EFFORT_MODELS.test(model) ? process.env.NOU_EFFORT ?? requested ?? "high" : undefined;

package/dist/src/providers/index.js

@@ -1,4 +1,5 @@
 import { loadSettings, saveSettings } from "../config/index.js";
+import { originOf } from "../config/origins.js";
 import { anthropicProvider } from "./anthropic.js";
 import { ollamaProvider } from "./ollama.js";
 import { OPENAI_COMPATIBLE, openAICompatibleProvider } from "./openai.js";
@@ -24,6 +25,21 @@ export function resolveModel(spec) {
     return { provider: providers[0], model: trimmed };
 }
 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);
+/**
+ * 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.
+ */
+export function keyHint(provider, error) {
+    const key = provider.connect?.find((f) => f.secret)?.env;
+    if (!key || !rejectedKey(error))
+        return null;
+    const origin = originOf(key);
+    const others = providers.filter((p) => p !== provider && !p.local && !p.unavailable()).map((p) => p.id);
+    return `The ${key}${origin ? ` from ${origin}` : ""} was rejected. Enter another with /connect ${provider.id}`
+        + (others.length ? `, or switch with /model ${others.join(" · /model ")}.` : ", or connect another provider (e.g. /connect litellm).");
+}
 /** NOU_MODEL wins, then the model saved in settings, then local Ollama. */
 export function initialModel() {
     if (process.env.NOU_MODEL)

package/dist/src/providers/ollama.js

@@ -1,8 +1,44 @@
 import { Ollama } from "ollama";
 import { newCallId } from "./ids.js";
+/** Ollama names without a tag mean ":latest", so "llama3" and "llama3:latest" are the same model. */
+export const sameModel = (a, b) => {
+    const full = (m) => (m.includes(":") ? m : `${m}:latest`);
+    return full(a) === full(b);
+};
+/** Context window to ask for when a model doesn't set its own: enough for the system prompt, files and history. */
+const DEFAULT_NUM_CTX = 32_768;
+/**
+ * Ollama's default context window is small, and it silently drops whatever doesn't fit (often the system
+ * prompt). Ask for a bigger one, capped at what the model supports, unless its Modelfile sets num_ctx.
+ * Returns null to leave Ollama's setting alone.
+ */
+export function pickNumCtx(parameters, modelInfo) {
+    if (/^num_ctx\s/m.test(parameters ?? ""))
+        return null;
+    const max = Object.entries(modelInfo ?? {}).find(([key]) => key.endsWith(".context_length"))?.[1];
+    return typeof max === "number" && max > 0 ? Math.min(DEFAULT_NUM_CTX, max) : DEFAULT_NUM_CTX;
+}
 export function ollamaProvider() {
     const host = process.env.OLLAMA_HOST ?? "http://127.0.0.1:11434";
     const client = new Ollama({ host });
+    const contextSizes = new Map();
+    /** NOU_NUM_CTX wins; otherwise worked out once per model from what Ollama reports about it. */
+    const numCtx = (model, via) => {
+        if (process.env.NOU_NUM_CTX)
+            return Promise.resolve(Number(process.env.NOU_NUM_CTX) || null);
+        let size = contextSizes.get(model);
+        if (!size) {
+            // model_info is typed as a Map but arrives as a plain object.
+            size = via.show({ model })
+                .then((info) => pickNumCtx(info.parameters, info.model_info))
+                .catch(() => {
+                contextSizes.delete(model); // cancelled or failed: ask again next time
+                return null;
+            });
+            contextSizes.set(model, size);
+        }
+        return size;
+    };
     const toOllama = (system, messages) => [
         { role: "system", content: system },
         ...messages.map((m) => {
@@ -23,10 +59,18 @@ export function ollamaProvider() {
         local: true,
         defaultModel: "qwen3:8b",
         unavailable: () => null,
+        endpoint: () => ({ baseURL: `${host.replace(/\/$/, "")}/v1`, apiKey: "ollama", api: "openai-completions" }),
         async chat({ model, system, messages, tools, onText, signal }) {
-            const stream = await client.chat({
+            // The library can only abort once the reply starts streaming, but Ollama first reads the whole prompt
+            // (minutes for a long one on a slow machine). Passing our signal to the requests themselves lets Esc stop that too.
+            const requester = signal
+                ? new Ollama({ host, fetch: (input, init) => fetch(input, { ...init, signal: init?.signal ? AbortSignal.any([init.signal, signal]) : signal }) })
+                : client;
+            const num_ctx = await numCtx(model, requester);
+            const stream = await requester.chat({
                 model,
                 messages: toOllama(system, messages),
+                ...(num_ctx ? { options: { num_ctx } } : {}),
                 tools: tools.map((t) => ({ type: "function", function: t })),
                 stream: true,
             });
@@ -54,5 +98,18 @@ export function ollamaProvider() {
             const { models } = await client.list();
             return models.map((m) => m.name);
         },
+        async pull(model, onProgress, signal) {
+            const stream = await client.pull({ model, stream: true });
+            const onAbort = () => stream.abort();
+            signal?.addEventListener("abort", onAbort);
+            try {
+                for await (const part of stream) {
+                    onProgress(part.status, part.total ? Math.floor((part.completed / part.total) * 100) : null);
+                }
+            }
+            finally {
+                signal?.removeEventListener("abort", onAbort);
+            }
+        },
     };
 }

package/dist/src/providers/openai.js

@@ -2,11 +2,16 @@ import OpenAI from "openai";
 import { newCallId } from "./ids.js";
 /** Everything that speaks the OpenAI chat completions API. */
 export const OPENAI_COMPATIBLE = [
-    { id: "openai", label: "OpenAI", baseURL: "https://api.openai.com/v1", keyEnv: "OPENAI_API_KEY", defaultModel: "gpt-5", local: false },
+    { id: "openai", label: "OpenAI", baseURL: "https://api.openai.com/v1", urlEnv: "OPENAI_BASE_URL", keyEnv: "OPENAI_API_KEY", defaultModel: "gpt-5", local: false },
     { id: "gemini", label: "Google Gemini", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/", keyEnv: "GEMINI_API_KEY", defaultModel: "gemini-2.5-pro", local: false },
     { id: "openrouter", label: "OpenRouter", baseURL: "https://openrouter.ai/api/v1", keyEnv: "OPENROUTER_API_KEY", defaultModel: "anthropic/claude-opus-5-5", local: false },
     { id: "groq", label: "Groq", baseURL: "https://api.groq.com/openai/v1", keyEnv: "GROQ_API_KEY", defaultModel: "llama-3.3-70b-versatile", local: false },
     { id: "deepseek", label: "DeepSeek", baseURL: "https://api.deepseek.com/v1", keyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek-chat", local: false },
+    { id: "fireworks", label: "Fireworks AI", baseURL: "https://api.fireworks.ai/inference/v1", keyEnv: "FIREWORKS_API_KEY", defaultModel: "accounts/fireworks/models/kimi-k2-instruct", local: false, keyHint: "fireworks.ai/account/api-keys" },
+    // A LiteLLM proxy, or any hosted OpenAI-compatible gateway: cloud-sized context, unlike "custom".
+    { id: "litellm", label: "LiteLLM / gateway", baseURL: "", urlEnv: "LITELLM_BASE_URL", keyEnv: "LITELLM_API_KEY", defaultModel: "gpt-5", local: false, keyHint: "your proxy's virtual key or master key",
+        // The names LiteLLM's own SDK uses for a proxy (its litellm_proxy provider).
+        aliases: { url: ["LITELLM_PROXY_API_BASE"], key: ["LITELLM_PROXY_API_KEY"] } },
     { id: "lmstudio", label: "LM Studio", baseURL: "http://localhost:1234/v1", urlEnv: "LMSTUDIO_BASE_URL", defaultModel: "local-model", local: true },
     { id: "llamacpp", label: "llama.cpp server", baseURL: "http://localhost:8080/v1", urlEnv: "LLAMACPP_BASE_URL", defaultModel: "local-model", local: true },
     { id: "custom", label: "Custom OpenAI-compatible", baseURL: "", urlEnv: "NOU_BASE_URL", keyEnv: "NOU_API_KEY", defaultModel: "default", local: true },
@@ -37,19 +42,34 @@ function toOpenAI(system, messages) {
     return out;
 }
 export function openAICompatibleProvider(preset) {
-    const baseURL = (preset.urlEnv && process.env[preset.urlEnv]) || preset.baseURL;
-    const apiKey = (preset.keyEnv && process.env[preset.keyEnv]) || (preset.local ? "not-needed" : "");
+    // Read when used, not when loaded: keys found in other tools' config (see setup/) are added at startup.
+    const first = (names) => names.map((n) => n && process.env[n]).find(Boolean);
+    const baseURL = () => first([preset.urlEnv, ...(preset.aliases?.url ?? [])]) || preset.baseURL;
+    const apiKey = () => first([preset.keyEnv, ...(preset.aliases?.key ?? [])]) || (preset.local ? "not-needed" : "");
+    // Rebuilt when the URL or key changes (they can be entered while Nou runs).
     let client = null;
-    const getClient = () => (client ??= new OpenAI({ baseURL, apiKey }));
+    const getClient = () => {
+        const url = baseURL();
+        const key = apiKey();
+        if (client?.url !== url || client.key !== key)
+            client = { url, key, api: new OpenAI({ baseURL: url, apiKey: key }) };
+        return client.api;
+    };
+    const connect = [
+        ...(preset.urlEnv ? [{ env: preset.urlEnv, label: "Base URL", optional: !!preset.baseURL, placeholder: preset.baseURL || "https://your-proxy.example.com/v1" }] : []),
+        ...(preset.keyEnv ? [{ env: preset.keyEnv, label: "API key", secret: true, optional: preset.local, ...(preset.keyHint ? { placeholder: preset.keyHint } : {}) }] : []),
+    ];
     return {
         id: preset.id,
         label: preset.label,
         local: preset.local,
         defaultModel: preset.defaultModel,
+        ...(connect.length ? { connect } : {}),
+        endpoint: () => ({ baseURL: baseURL(), apiKey: apiKey() || "not-needed", api: "openai-completions" }),
         unavailable() {
-            if (!baseURL)
+            if (!baseURL())
                 return `set ${preset.urlEnv}`;
-            if (!apiKey)
+            if (!apiKey())
                 return `set ${preset.keyEnv}`;
             return null;
         },