teapot-coding-agent 0.23.0 → 0.24.1

package/dist/index.js

@@ -6,8 +6,35 @@
  * First run (no config file): boot anyway and finish setup in the web UI.
  */
 import { existsSync } from "node:fs";
+import { createServer } from "node:net";
 import { loadConfig, resolveConfigPath, Master } from "./master.js";
 import { buildApp, serveApp } from "./server/api.js";
+/**
+ * Resolve once nothing is listening on port/host, i.e. the previous server has
+ * released it. Used only by the live-update handover: binding while the old
+ * process still holds the socket fails with EADDRINUSE (#35).
+ *
+ * Returns false on timeout so the caller can warn and try anyway, rather than
+ * hanging a boot forever because of a wedged predecessor.
+ */
+async function waitForPortFree(port, host, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    // 0.0.0.0 / :: means "all interfaces" — probe the loopback the old process
+    // was actually reachable on.
+    const probeHost = !host || host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+    while (Date.now() < deadline) {
+        const free = await new Promise((resolve) => {
+            const s = createServer();
+            s.once("error", () => resolve(false)); // still in use
+            s.once("listening", () => s.close(() => resolve(true)));
+            s.listen(port, probeHost);
+        });
+        if (free)
+            return true;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    return false;
+}
 async function main() {
     // CLI: teapot [--port N] [-p N] [--config file] [-c file] [config.json]
     let cfgArg;
@@ -28,36 +55,10 @@ async function main() {
     if (process.argv.includes("--help") || process.argv.includes("-h")) {
         console.log("teapot [--port N] [--host addr] [--config file.json] [config.json]");
         console.log("  --host 127.0.0.1 (default) · 0.0.0.0 exposes the UI to your network");
+        console.log("  --acp  speak the Agent Client Protocol on stdio instead of serving HTTP (#15)");
         console.log("  env: TEAPOT_PORT, TEAPOT_HOST, TEAPOT_CONFIG_DIR, TEAPOT_DATA_DIR, TEAPOT_API_TOKEN");
         return;
     }
-    // Handle restart-from-old-process: if we're the new process spawned by a
-    // live update, wait for the old process to release the port and exit.
-    const restartFromPid = process.env.TEAPOT_RESTART_FROM
-        ? parseInt(process.env.TEAPOT_RESTART_FROM, 10)
-        : null;
-    if (restartFromPid && !Number.isNaN(restartFromPid)) {
-        // Give the old process time to gracefully shut down and release the port
-        console.log(`[teapot] restart: waiting for old process ${restartFromPid} to exit...`);
-        try {
-            // Send SIGTERM to old process (it handles graceful shutdown)
-            process.kill(restartFromPid, "SIGTERM");
-            // Wait for it to exit (max 5 seconds)
-            for (let i = 0; i < 50; i++) {
-                try {
-                    process.kill(restartFromPid, 0); // check if alive
-                    await new Promise((r) => setTimeout(r, 100));
-                }
-                catch {
-                    // Process no longer exists
-                    break;
-                }
-            }
-        }
-        catch {
-            // Old process might already be gone
-        }
-    }
     const configPath = resolveConfigPath(cfgArg);
     const configExisted = existsSync(configPath);
     const config = loadConfig(configPath);
@@ -66,6 +67,33 @@ async function main() {
     if (hostOverride)
         config.host = hostOverride;
     console.log(`[teapot] config: ${configPath}${configExisted ? "" : " (not found — first run)"}`);
+    // Live update: the process we replace still holds the port. Ask it to release
+    // it, then WAIT until the port is genuinely free before binding. Binding
+    // into a live socket died with EADDRINUSE, and because index.ts swallows
+    // uncaught exceptions ("the master survived") that left two processes running
+    // while neither served anything — the port then answered nothing at all
+    // (measured: 1150/1237 probes refused during handover) (#35).
+    const fromPid = process.env.TEAPOT_RESTART_FROM
+        ? parseInt(process.env.TEAPOT_RESTART_FROM, 10)
+        : NaN;
+    if (!Number.isNaN(fromPid) && fromPid !== process.pid) {
+        console.log(`[teapot] restart: releasing port from old process ${fromPid}...`);
+        try {
+            // Flush the old process's agents and let it release the socket. It does
+            // NOT wait for us (that would deadlock against our bind below) — it
+            // lingers only long enough for its own HTTP response to flush, then exits.
+            process.kill(fromPid, "SIGTERM");
+        }
+        catch {
+            /* already gone */
+        }
+        // Wait until the socket is genuinely free. Binding while the old process
+        // still holds it fails with EADDRINUSE, and because index.ts swallows
+        // uncaught exceptions that left two processes running while neither served
+        // anything (#35).
+        if (!(await waitForPortFree(config.port, config.host, 30_000)))
+            console.warn(`[teapot] warning: could not confirm ${config.host}:${config.port} is free — binding anyway`);
+    }
     const hasProviders = Object.keys(config.providers ?? {}).length > 0;
     if (!config.llm.apiKey && !hasProviders)
         console.warn("[teapot] warning: no API key configured — finish setup in the web UI");
@@ -74,6 +102,17 @@ async function main() {
     const master = new Master(config, configPath);
     master.configFileExists = configExisted;
     await master.start();
+    // ACP mode (#15): JSON-RPC over stdio, no HTTP server. Deliberately placed
+    // AFTER the master is up (so config is resolved and agents work) but BEFORE
+    // serveApp, so an editor launching `teapot --acp` never binds a port.
+    if (process.argv.includes("--acp")) {
+        const { AcpAdapter } = await import("./acp/adapter.js");
+        const acp = new AcpAdapter({ master });
+        // nothing else may write to stdout — it carries the protocol
+        console.error("[teapot] ACP mode: JSON-RPC over stdio");
+        await acp.listen();
+        return;
+    }
     const app = buildApp(master);
     serveApp(app, config.port, config.host);
     // agent crash isolation: an agent error never escapes its own loop; here we
@@ -91,6 +130,14 @@ async function main() {
         shuttingDown = true;
         console.log(`\n[teapot] shutting down${signal ? ` (${signal})` : ""}...`);
         await Promise.allSettled([...master.agents.values()].map((a) => a.dispose()));
+        // During a live update the replacement SIGTERMs us to take the port. Linger
+        // so our own in-flight HTTP responses flush first — notably
+        // /api/update/restart, whose answer the browser is still waiting on; the
+        // socket is released the moment we exit, which is what lets the replacement
+        // bind. We must NOT wait for the replacement to come up: it is itself
+        // waiting for this port to free, so that would deadlock the handover (#35).
+        if (process.env.TEAPOT_RESTART_FROM)
+            await new Promise((r) => setTimeout(r, 1_500));
         process.exit(0);
     };
     process.on("SIGINT", () => void shutdown("SIGINT"));

package/dist/log/events.js

@@ -112,6 +112,20 @@ export class EventLog {
     lastEventId(branch) {
         return this.lastByBranch.get(branch) ?? null;
     }
+    /**
+     * Seed the parent link for a brand-new branch so its first event chains to
+     * the event that created it.
+     *
+     * `lastByBranch` is per branch, so without this a new branch's first event
+     * got `parent: null` — severing the chain. lineageOf() walks parents from the
+     * newest event, so the entire pre-fork history became unreachable and a
+     * restart rebuilt the conversation with none of it (#38).
+     */
+    seedBranch(branch, parentEventId) {
+        if (!branch)
+            return;
+        this.lastByBranch.set(branch, parentEventId ?? "");
+    }
     async close() {
         await this.chain.catch(() => { });
         if (!this.stream)
@@ -142,3 +156,85 @@ export async function readEvents(filePath) {
         return [];
     }
 }
+/** Default floor for a tail read, so a small `limit` cannot cause a tiny read. */
+const TAIL_MIN_BYTES = 64 * 1024;
+/**
+ * Read only the LAST `limit` events from an append-only JSONL log.
+ *
+ * #59: the web UI polls this endpoint every ~120 ms for the selected agent, and
+ * the full re-parse cost 348 ms on a 57 MB / 200 000-event log. The mtime cache
+ * could not help — a RUNNING agent appends constantly, so `size` and `mtimeMs`
+ * change on every single request and the cache only ever helped stopped agents.
+ *
+ * The log is strictly append-only: `EventLog.append` is the only writer and
+ * always writes a whole `JSON.stringify(evt) + "\n"` under a serialized chain,
+ * so an append never rewrites earlier bytes. That makes a tail read safe, and
+ * makes byte-offset caching legitimate.
+ *
+ * Anchored to the tail deliberately. The read starts at a byte offset chosen for
+ * the file's current size, so the FIRST line it sees is usually a fragment —
+ * dropped. `bytesScanned` is reported so callers (and tests) can assert the read
+ * really was partial rather than trusting a wall-clock number.
+ */
+export async function readEventsTail(filePath, limit) {
+    const empty = { events: [], total: 0, bytesScanned: 0, truncated: false };
+    if (limit <= 0)
+        return empty;
+    let fh = null;
+    try {
+        const fsp = await import("node:fs/promises");
+        fh = await fsp.open(filePath, "r");
+        const st = await fh.stat();
+        if (st.size === 0)
+            return empty;
+        // grow the window until it holds `limit` whole lines. Start at a floor so a
+        // small limit still reads a sensible block, then double — bounded by the
+        // file size, because a pathological file must not make us read forever.
+        let want = Math.min(st.size, Math.max(TAIL_MIN_BYTES, limit * 512));
+        for (;;) {
+            const r = await readWindow(fh, st.size, want);
+            if (r.events.length >= limit || want >= st.size) {
+                return {
+                    events: r.events.slice(-limit),
+                    // `total` is an APPROXIMATE count: only the window was parsed, so this
+                    // is "at least this many". /events uses it for the "load older" hint,
+                    // where approximate is fine — an exact count would mean reading the
+                    // entire file, which is the cost this function exists to avoid.
+                    total: r.events.length,
+                    bytesScanned: r.bytes,
+                    truncated: r.bytes < st.size,
+                };
+            }
+            want = Math.min(st.size, want * 4);
+        }
+    }
+    catch {
+        return empty;
+    }
+    finally {
+        await fh?.close().catch(() => { });
+    }
+}
+/** read the last `bytes` of the file, dropping the leading partial line */
+async function readWindow(fh, size, bytes) {
+    const start = Math.max(0, size - bytes);
+    const buf = Buffer.alloc(size - start);
+    if (buf.length)
+        await fh.read(buf, 0, buf.length, start);
+    const text = buf.toString("utf8");
+    const nl = text.indexOf("\n");
+    // the first line is a fragment unless we started at 0
+    const body = start > 0 ? (nl === -1 ? "" : text.slice(nl + 1)) : text;
+    const events = [];
+    for (const line of body.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch {
+            /* torn or corrupt line: skip it, never return a fragment */
+        }
+    }
+    return { events, bytes: buf.length };
+}

package/dist/master.js

@@ -12,7 +12,7 @@ import { spawn } from "node:child_process";
 import { Agent } from "./agent/agent.js";
 import { parseSchedule, matches, nextFireAt } from "./scheduler/cron.js";
 import { bus } from "./bus.js";
-import { fetchModelList, contextLengthFor } from "./model-meta.js";
+import { fetchModelList, contextLengthFor, isReasoningEffort } from "./model-meta.js";
 /** how deep sub-agent spawning may nest (parent=0, its subs=1, …) */
 const MAX_SPAWN_DEPTH = 3;
 /**
@@ -21,6 +21,54 @@ const MAX_SPAWN_DEPTH = 3;
  * checkout alike. Lowest-priority skill root (workspace > global > bundled).
  */
 const BUNDLED_SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../skills");
+/**
+ * Application version, read from package.json next to this module.
+ *
+ * Walks up from `dist/master.js` / `src/master.ts` to the package root so it
+ * resolves in every layout (repo checkout, global install, npx cache). Falls
+ * back to `"0.0.0"` rather than throwing: a missing/unreadable package.json
+ * must never stop the server from booting.
+ */
+function readAppVersion() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 6; i++) {
+            const pkg = path.join(dir, "package.json");
+            if (existsSync(pkg)) {
+                const v = JSON.parse(readFileSync(pkg, "utf8")).version;
+                if (typeof v === "string" && v)
+                    return v;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        /* fall through to the sentinel below */
+    }
+    return "0.0.0";
+}
+/**
+ * Turn a user-supplied workspace path into an absolute one.
+ *
+ * A relative path used to be resolved against `process.cwd()`, so a config
+ * entry like `"workspace": "workspaces/alpha"` (the form shipped in
+ * teapot.config.example.json) silently pointed at whatever directory the
+ * daemon happened to be started from — and the agent's bash tool then ran in
+ * the wrong directory (#34). Relative workspaces are now anchored to the
+ * config file's own directory, which is what "the workspace" means inside a
+ * config file.
+ *
+ * `~` is expanded for both forms; absolute paths pass through untouched.
+ */
+export function resolveWorkspace(input, base) {
+    const expanded = input.trim().replace(/^~(?=$|\/|\\)/, process.env.HOME ?? "~");
+    if (path.isAbsolute(expanded))
+        return path.normalize(expanded);
+    return path.resolve(base, expanded);
+}
 /** default sub-agent personas — mentionable from the composer (@name) and
  *  usable by agents via spawn_agent({persona}) */
 export const SUB_PERSONAS = {
@@ -324,7 +372,7 @@ export class Master {
         }
         let agentId;
         if (body.workspace?.trim()) {
-            const ws = path.resolve(body.workspace.replace(/^~/, process.env.HOME ?? "~"));
+            const ws = resolveWorkspace(body.workspace, path.dirname(this.configPath));
             await mkdirSync(ws, { recursive: true });
             const name = (body.agentName?.trim() || path.basename(ws))
                 .replace(/[^\w.-]/g, "-")
@@ -379,6 +427,11 @@ export class Master {
             ]);
             void listPromise.catch(() => []);
         }
+        // catalogue entry for this model — gates reasoning_effort support (#47)
+        const modelMeta = (await Promise.race([
+            fetchModelList(llm.baseUrl, llm.apiKey),
+            new Promise((r) => setTimeout(() => r(undefined), 1_500)),
+        ]))?.find((m) => m.id === llm.model);
         const sessionDir = this.resolveSessionDir(ac.id, opts.fresh === true);
         await mkdirSync(sessionDir, { recursive: true });
         // every session dir this master hands out carries an ownership manifest —
@@ -386,7 +439,7 @@ export class Master {
         this.writeSessionManifest(sessionDir, ac.id);
         const agent = new Agent({
             id: ac.id,
-            workspace: path.resolve(ac.workspace),
+            workspace: resolveWorkspace(ac.workspace, path.dirname(this.configPath)),
             llm,
             sessionDir,
             progressIntervalMs: this.config.progressIntervalMs,
@@ -410,6 +463,12 @@ export class Master {
             ...(ac.readOnly ? { readOnlyTools: true } : {}),
             ...(ac.parent ? { parent: ac.parent } : {}),
             ...(ac.chatFn ? { chatFn: ac.chatFn } : {}),
+            // #47: reasoning effort is a per-agent choice; the catalogue decides
+            // whether it can actually be sent (see effortForRequest)
+            ...(ac.reasoningEffort ? { reasoningEffort: ac.reasoningEffort } : {}),
+            ...(modelMeta?.supportedParameters
+                ? { supportedParameters: modelMeta.supportedParameters }
+                : {}),
         });
         // pricing metadata (USD/token) for the runtime cost estimate — best
         // effort: providers without pricing in /models simply show no cost
@@ -451,8 +510,24 @@ export class Master {
             this.config.agents.push(ac);
             this.saveConfig();
         }
+        // Remember which session this agent is bound to, so a restart reattaches
+        // deterministically instead of re-guessing from directory mtimes (#39).
+        // Done for EVERY agent (persisted or spawned): a spawned child is re-created
+        // on boot too, and guessing there is the same resurrection bug.
+        this.recordSession(ac, path.basename(sessionDir));
         return agent;
     }
+    /** Persist an agent's current session id into the config, if it changed. */
+    recordSession(ac, sessionId) {
+        if (!sessionId || ac.session === sessionId)
+            return;
+        ac.session = sessionId;
+        const entry = this.config.agents.find((a) => a.id === ac.id);
+        if (!entry)
+            return; // not a configured agent — nothing to persist yet
+        entry.session = sessionId;
+        this.saveConfig();
+    }
     /** spawn-tree depth of an agent (0 = top level); unknown → 0 */
     depthOf(id, seen = new Set()) {
         const cap = this.maxSpawnDepth();
@@ -837,6 +912,21 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
                 }
             }
         }
+        // Prefer the recorded session: the config says exactly which timeline this
+        // agent was on. Guessing by mtime let a stale-or-deleted dir whose
+        // chat.jsonl happened to be newer win, handing the agent a timeline the
+        // operator had moved off — the "deleted session comes back" report (#39).
+        const recorded = this.config.agents.find((a) => a.id === agentId)?.session;
+        if (!fresh && recorded) {
+            const dir = path.join(root, recorded);
+            // only trust it when it is really THIS agent's dir (ownership comes from
+            // the manifest; a renamed/reused dir must not resurrect a ghost)
+            const owner = this.readSessionOwner(recorded);
+            if (existsSync(dir) && (owner === null || owner === agentId))
+                return dir;
+            // the recorded dir is gone (deleted) — fall through and mint a new one
+            console.log(`[teapot] session ${recorded} for ${agentId} is gone; starting a new one`);
+        }
         // Prefer the LATEST session directory that actually carries history.
         // This handles the case where a bare-name directory (e.g. from legacy
         // migration) would otherwise shadow a newer UUID-suffixed incarnation
@@ -952,7 +1042,7 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
      * Without: keep the current endpoint, swap only the model name.
      * The choice is persisted on the agent config so it survives restarts.
      */
-    async setAgentModel(id, providerName, model, contextWindowTokens) {
+    async setAgentModel(id, providerName, model, contextWindowTokens, reasoningEffort) {
         const agent = this.agents.get(id);
         if (!agent)
             throw new Error(`no such agent: ${id}`);
@@ -976,6 +1066,20 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             const ac = this.config.agents.find((a) => a.id === id);
             effectiveProvider = ac?.provider ?? this.config.defaultProvider ?? "";
         }
+        // #47: re-resolve the catalogue for the (possibly new) model so the
+        // effort gate reflects THIS model's advertised capabilities
+        const effortList = await fetchModelList(llm.baseUrl, llm.apiKey).catch(() => []);
+        const meta = effortList.find((m) => m.id === (model || llm.model));
+        const opts = agent;
+        if (reasoningEffort !== undefined) {
+            // validated here so an unsupported value never reaches the request body;
+            // "" or an unrecognised level clears it (provider default)
+            opts.opts.reasoningEffort = isReasoningEffort(reasoningEffort) ? reasoningEffort : "";
+            const cfgEntry = this.config.agents.find((a) => a.id === id);
+            if (cfgEntry)
+                cfgEntry.reasoningEffort = opts.opts.reasoningEffort || undefined;
+        }
+        opts.opts.supportedParameters = meta?.supportedParameters ?? [];
         if (!llm.model)
             throw new Error("no model resolved (pass model or set one on the provider)");
         if (!llm.baseUrl)
@@ -1089,8 +1193,16 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             })),
         };
     }
-    /** Current application version (injected at build time via package.json). */
-    static VERSION = "__APP_VERSION__";
+    /**
+     * Current application version.
+     *
+     * Read from package.json at runtime rather than via a `"__APP_VERSION__"`
+     * literal: `__APP_VERSION__` is substituted by *vite* only, so the tsc-built
+     * backend used to ship the raw placeholder and the settings panel rendered
+     * "current version: __APP_VERSION__" (#33). A runtime read is correct in the
+     * built app, in `pnpm dev` and under `node --test`, which never run vite.
+     */
+    static VERSION = readAppVersion();
     /** Return the current server version. */
     getVersion() {
         return Master.VERSION;
@@ -1128,14 +1240,24 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         const env = { ...process.env };
         // Tell the new process it's a restart (it will read the version from the old one)
         env.TEAPOT_RESTART_FROM = String(process.pid);
+        // Mark OURSELVES as a live-update predecessor too. Our own SIGTERM handler
+        // (src/index.ts) lingers when this var is set, so /api/update/restart's
+        // response still reaches the browser before we exit — otherwise the new
+        // process SIGTERMs us the instant it binds the port and the browser sees a
+        // dropped connection instead of {ok:true} (#35).
+        process.env.TEAPOT_RESTART_FROM = String(process.pid);
         const child = spawn(execPath, args, {
-            detached: true,
-            stdio: "ignore",
+            // NOT detached, and NOT stdio:"ignore" (#35). Both made the live update
+            // silently daemonize: the replacement inherited nothing from this
+            // process, so its console.log output vanished — you could not see what it
+            // was doing — and it outlived the terminal, so Ctrl-C and a closing
+            // shell could no longer stop it. Inheriting stdio keeps the logs on the
+            // same console and, without `detached`, the child stays in this process
+            // group so it receives the same Ctrl-C.
+            stdio: "inherit",
             env,
         });
-        child.unref(); // Let the parent exit when ready
-        // Give the new process time to start and bind the port
-        // This process will exit when the new one takes over (SIGTERM handled in index.ts)
-        await new Promise((r) => setTimeout(r, 1_000));
+        await new Promise((r) => setTimeout(r, 1_500));
+        void child; // deliberately not unref()'d — see above
     }
 }

package/dist/model-meta.js

@@ -6,6 +6,7 @@
 import fs from "node:fs";
 import { providerHeaders } from "./agent/llm.js";
 const cache = new Map();
+const inFlight = new Map();
 const TTL = 10 * 60_000;
 /** Fetch GET /models from an OpenAI-compatible endpoint (cached ~10 min). */
 export async function fetchModelList(baseUrl, apiKey) {
@@ -13,49 +14,108 @@ export async function fetchModelList(baseUrl, apiKey) {
     const hit = cache.get(root);
     if (hit && Date.now() - hit.at < TTL)
         return hit.list;
+    // An in-flight lookup is SHARED: without this, two callers racing for the
+    // same endpoint each paid the full timeout, and `newSession` in ACP mode
+    // blocked on it before it could even reply to the editor (#15).
+    const inflight = inFlight.get(root);
+    if (inflight)
+        return inflight;
+    const p = (async () => {
+        try {
+            const res = await fetch(`${root}/models`, {
+                headers: {
+                    ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
+                    ...providerHeaders(baseUrl), // OpenRouter app attribution
+                },
+                // boot-time calls happen per agent; a slow/unroutable endpoint used to
+                // stall startup for up to 15s PER AGENT before this was tightened
+                signal: AbortSignal.timeout(3_000),
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const j = (await res.json());
+            const list = (j.data ?? [])
+                .map((m) => ({
+                id: typeof m.id === "string" ? m.id : "",
+                contextLength: typeof m.context_length === "number" ? m.context_length : undefined,
+                // OpenRouter-style USD per token (e.g. "0.000003") — powers the
+                // runtime cost estimate. Providers without pricing stay undefined.
+                pricing: m.pricing && (m.pricing.prompt !== undefined || m.pricing.completion !== undefined)
+                    ? {
+                        prompt: Number(m.pricing.prompt ?? 0),
+                        completion: Number(m.pricing.completion ?? 0),
+                    }
+                    : undefined,
+                modalities: Array.isArray(m.architecture?.input_modalities) && m.architecture.input_modalities.length
+                    ? {
+                        input: m.architecture.input_modalities,
+                        output: m.architecture.output_modalities ?? ["text"],
+                    }
+                    : undefined,
+                // OpenRouter advertises per-model capabilities; other endpoints omit
+                // the field entirely, which leaves support "unknown" rather than false.
+                supportedParameters: Array.isArray(m.supported_parameters)
+                    ? m.supported_parameters.filter((p) => typeof p === "string")
+                    : undefined,
+            }))
+                .filter((m) => m.id);
+            cache.set(root, { at: Date.now(), list });
+            return list;
+        }
+        catch {
+            return []; // unreachable provider — caller treats as "unknown"
+        }
+    })();
+    inFlight.set(root, p);
     try {
-        const res = await fetch(`${root}/models`, {
-            headers: {
-                ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
-                ...providerHeaders(baseUrl), // OpenRouter app attribution
-            },
-            // boot-time calls happen per agent; a slow/unroutable endpoint used to
-            // stall startup for up to 15s PER AGENT before this was tightened
-            signal: AbortSignal.timeout(3_000),
-        });
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status}`);
-        const j = (await res.json());
-        const list = (j.data ?? [])
-            .map((m) => ({
-            id: typeof m.id === "string" ? m.id : "",
-            contextLength: typeof m.context_length === "number" ? m.context_length : undefined,
-            // OpenRouter-style USD per token (e.g. "0.000003") — powers the
-            // runtime cost estimate. Providers without pricing stay undefined.
-            pricing: m.pricing && (m.pricing.prompt !== undefined || m.pricing.completion !== undefined)
-                ? {
-                    prompt: Number(m.pricing.prompt ?? 0),
-                    completion: Number(m.pricing.completion ?? 0),
-                }
-                : undefined,
-            modalities: Array.isArray(m.architecture?.input_modalities) && m.architecture.input_modalities.length
-                ? {
-                    input: m.architecture.input_modalities,
-                    output: m.architecture.output_modalities ?? ["text"],
-                }
-                : undefined,
-        }))
-            .filter((m) => m.id);
-        cache.set(root, { at: Date.now(), list });
-        return list;
+        return await p;
     }
-    catch {
-        return []; // unreachable provider — caller treats as "unknown"
+    finally {
+        inFlight.delete(root);
     }
 }
 export function contextLengthFor(list, model) {
     return list.find((m) => m.id === model)?.contextLength;
 }
+/** Reasoning-effort levels OpenRouter accepts (`reasoning_effort`). */
+export const REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
+export function isReasoningEffort(v) {
+    return typeof v === "string" && REASONING_EFFORTS.includes(v);
+}
+/** True when the endpoint is OpenRouter (the only one that documents effort). */
+export function isOpenRouter(baseUrl) {
+    try {
+        return /(^|\.)openrouter\.ai$/i.test(new URL(String(baseUrl ?? "")).host);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The `reasoning_effort` value to actually SEND, or undefined to omit it.
+ *
+ * Verified against the live OpenRouter /models endpoint (462 models): 196
+ * advertise `reasoning_effort`, 331 the broader `reasoning`, and NONE a bare
+ * top-level `effort`. Support is therefore far from universal, and sending the
+ * parameter to a model that does not advertise it is how a request gets
+ * rejected or a setting silently ignored (#47) — so it is sent only when the
+ * endpoint is OpenRouter AND the model advertises it. Off by default: an absent
+ * setting means "let the provider apply its own default".
+ */
+export function resolveReasoningEffort(opts) {
+    if (!isReasoningEffort(opts.effort))
+        return undefined;
+    if (!isOpenRouter(opts.baseUrl))
+        return undefined;
+    const meta = opts.list?.find((m) => m.id === opts.model);
+    // No catalogue for this endpoint: we cannot verify support, so do not send.
+    // A wrong body field is worse than an unset one.
+    if (!meta?.supportedParameters)
+        return undefined;
+    if (!meta.supportedParameters.includes("reasoning_effort"))
+        return undefined;
+    return opts.effort;
+}
 /** test hook */
 export function clearModelListCache() {
     cache.clear();