teapot-coding-agent 0.37.59 → 0.37.61

package/dist/migrations/index.js

@@ -1,40 +1,3 @@
-/**
- * Ordered, one-way migrations for on-disk state.
- *
- * ## Why order and idempotency matter more than the transformations
- *
- * A single upgrade path is easy. The hard case is a machine that skips several releases: an
- * operator on v0.20 upgrading straight to v0.40 runs EVERY migration in between at once. Two
- * migrations that each look correct can then be wrong together — the canonical example is a future
- * `config.json` split combined with today's "store the session title in `agents[]`":
- *
- *   split first   → titles land in the new config directory, then the old file is read again and
- *                   the titles are written a second time, or to the wrong file;
- *   titles first  → the split then has to carry a field it never knew about.
- *
- * So each migration here:
- *
- *   - is **idempotent** — running it twice is a no-op, because a crash mid-upgrade must be
- *     resumable and a re-run must not double-apply;
- *   - declares an **order** — `order` is ascending, and a later step may assume every earlier one
- *     has run;
- *   - never deletes data it does not fully replace (a rename, not a delete-then-write);
- *   - reports what it did, so a boot log shows which steps actually ran.
- *
- * ## What this module is NOT
- *
- * It does not decide WHICH migrations exist — each one lives in its own file and is registered in
- * `index.ts`. Keeping them out of `master.ts` is the point: they were spread across the boot path,
- * where an ordering mistake is invisible.
- */
-/**
- * Run every registered migration in `order`, skipping nothing.
- *
- * There is no "already ran" gate on purpose: each step is idempotent, so the cheapest correct
- * policy is to always run them. A recorded version would have to be validated against a config the
- * operator may have hand-edited or restored from backup, and a wrong version claim is how a
- * migration silently does not run.
- */
 export async function runMigrations(migrations, ctx) {
     const applied = [];
     for (const m of [...migrations].sort((a, b) => a.order - b.order)) {
@@ -45,26 +8,8 @@ export async function runMigrations(migrations, ctx) {
             }
         }
         catch (err) {
-            // One broken step must not block the boot: the session data is still readable, and refusing
-            // to start would be worse than starting with one conversion unmade.
             ctx.log(`migration ${m.id} FAILED (${err.message}) — continuing without it`);
         }
     }
     return { applied };
 }
-/**
- * ## What is deliberately NOT here
- *
- * Two migrations stay in `src/agent/agent.ts` because they are per-SESSION filesystem moves that
- * need the agent's own paths, and they already satisfy the rules above:
- *
- *   - `migrateGoalFromWorkspace` — `<workspace>/GOAL.md` → the session's goal store. Deletes the
- *     legacy file only after a successful write, so a failure re-runs.
- *   - `migrateMemoryToAgentScope` — a session's `memory.md` → the agent-wide one. APPENDS (the
- *     agent-wide file may already hold other sessions' notes), then removes the source. A missing
- *     write leaves the session copy in place.
- *
- * Moving them here would mean handing this module session paths it has no business knowing. What
- * matters is that they obey the same contract: idempotent, no data destroyed that was not
- * replaced, and ordered after the config-level steps (they run at agent start, which is later).
- */

package/dist/migrations/providers.js

@@ -1,15 +1,4 @@
 import { migrateProviderKeys } from "../master.js";
-/**
- * Fold a legacy single `apiKey` into an `apiKeys` array.
- *
- * `apiKey` is KEPT in step with `apiKeys[0]` rather than deleted: other readers still expect it (the
- * setup wizard, `/api/providers`, hand-edited files), and a migration that removes a field the
- * operator can see is one they will report as data loss.
- *
- * Idempotent because `apiKeys` is AUTHORITATIVE once present: re-running on a migrated entry
- * produces the same list. The single `apiKey` only SEEDS the pool when there is no list — appending
- * it as well would resurrect a credential the operator had already replaced.
- */
 export const providerKeys = {
     order: 10,
     id: "providers-api-keys",
@@ -25,8 +14,6 @@ export const providerKeys = {
                 continue;
             const p = entry;
             const before = JSON.stringify(p);
-            // ONE implementation of the folding rule, shared with the runtime normaliser — a second copy
-            // here is how the two drift and disagree about which key is authoritative.
             const next = migrateProviderKeys(p);
             for (const k of Object.keys(p))
                 delete p[k];

package/dist/migrations/registry.js

@@ -1,14 +1,5 @@
 import { providerKeys } from "./providers.js";
 import { flatSessionLayout } from "./sessions.js";
 import { sessionTitles } from "./session-titles.js";
-/**
- * Every migration, in application order.
- *
- * Add new ones with a HIGHER `order` than everything here, and never renumber an existing one — a
- * machine that already ran it would skip it under the new number.
- *
- * Ordering rule: a migration may assume every lower `order` has run. That is what makes a
- * multi-release jump safe. If two migrations must not be reordered later, say so in both files.
- */
 export const MIGRATIONS = [providerKeys, flatSessionLayout, sessionTitles];
 export { runMigrations } from "./index.js";

package/dist/migrations/session-titles.js

@@ -1,20 +1,5 @@
 import { closeSync, openSync, readSync } from "node:fs";
 import path from "node:path";
-/**
- * Derive each agent's session title ONCE and store it in `config.agents[].sessionTitle`.
- *
- * Titles used to be recomputed on every `allSessions()` — opening up to 830 session logs and
- * allocating a 16KB buffer for each, MEASURED at 83.8ms, 8.1MB read and ~38MB of short-lived
- * garbage per scan, on every `/api/sessions`. Storing it makes listing a config lookup.
- *
- * Runs ONCE PER SESSION rather than once per process: the check is `sessionTitle` on the agent's
- * CURRENT session, so a machine that has already been through this does no file I/O at all. That
- * is what makes it idempotent — and why it must come AFTER any step that could change `agents[]`.
- *
- * A session whose first prompt is a HARNESS prompt yields no title: sub-agent sessions receive only
- * those and are labelled from their id, so inventing one would name a child after its parent's
- * instruction.
- */
 export const sessionTitles = {
     order: 30,
     id: "agents-session-title",
@@ -27,21 +12,11 @@ export const sessionTitles = {
             const session = typeof a.session === "string" ? a.session : "";
             if (!session)
                 continue;
-            // already stored (possibly hand-edited — a chosen name must never be overwritten)
             if (typeof a.sessionTitle === "string" && a.sessionTitle.trim())
                 continue;
             if (session.includes("/") || session.includes(".."))
-                continue; // never a path segment
+                continue;
             const title = firstUserPromptText(path.join(ctx.dataDir, "sessions", session, "chat.jsonl"));
-            /**
-             * The SESSION ID is the fallback, not a marker.
-             *
-             * A sub-agent session receives only harness prompts, so no title can ever be derived from it —
-             * and a session id does not change either, so there is nothing to retry for. Writing the id
-             * makes the field ALWAYS present, which is what makes the pass idempotent without an extra
-             * flag: the next boot sees a title and skips. The sidebar already shows the id in this case,
-             * so nothing visible changes.
-             */
             a.sessionTitle = title ?? session;
             changed = true;
         }
@@ -50,19 +25,6 @@ export const sessionTitles = {
         return changed;
     },
 };
-/**
- * The first USER prompt in a log, trimmed to a title. `null` when there is none.
- *
- * Bounded (256KB) and stops at the first prompt, so one enormous log cannot dominate boot. A torn
- * final line at a chunk boundary is skipped rather than aborting the read.
- */
-/**
- * ONE reusable read buffer for the whole pass.
- *
- * `Buffer.alloc` per session is what made the first boot spike: 830 sessions x 16KB of short-lived
- * buffer, MEASURED as heap 28.2MB → 108.5MB during `start()` (33.4MB after GC). The scan is a
- * single-threaded loop, so sharing one buffer is safe and removes the churn entirely.
- */
 let scanBuffer;
 function firstUserPromptText(file) {
     let fd;
@@ -89,12 +51,12 @@ function firstUserPromptText(file) {
                     e = JSON.parse(l);
                 }
                 catch {
-                    continue; // torn line at a chunk boundary
+                    continue;
                 }
                 if (e.type !== "prompt")
                     continue;
                 if (e.data?.source !== "user")
-                    return null; // a harness prompt is not a label
+                    return null;
                 return titleOf(typeof e.data.text === "string" ? e.data.text : null);
             }
         }
@@ -109,12 +71,10 @@ function firstUserPromptText(file) {
                 closeSync(fd);
             }
             catch {
-                /* already closed */
             }
         }
     }
 }
-/** the first usable line of a prompt, clipped — the sidebar shows one short label */
 function titleOf(text) {
     const line = (text ?? "")
         .split("\n")

package/dist/migrations/sessions.js

@@ -1,28 +1,10 @@
 import { existsSync, mkdirSync, readdirSync, renameSync } from "node:fs";
 import path from "node:path";
-/**
- * Move sessions from the ≤0.5.0 flat layout (`<dataDir>/<id>.jsonl`) into
- * `<dataDir>/sessions/<id>/chat.jsonl`.
- *
- * A RENAME, not a copy-then-delete: a crash between the two would otherwise leave the history in
- * neither place. `rename` within one filesystem is atomic, so a re-run either finds the legacy file
- * (and moves it) or finds it already moved.
- *
- * Order 20: it must run before anything reads a session directory.
- */
 export const flatSessionLayout = {
     order: 20,
     id: "sessions-flat-layout",
     summary: "sessions/<id>.jsonl → sessions/<id>/chat.jsonl",
     run(ctx) {
-        /**
-         * Scan the DATA DIR, not `config.agents`.
-         *
-         * A legacy log can exist for an agent that is no longer in the config (archived, removed, or a
-         * config that failed to load) — and those are exactly the histories worth rescuing. Iterating
-         * the config also made this a no-op whenever the config listed no agents, which is how a test
-         * with an empty agent list silently stopped exercising it.
-         */
         let names;
         try {
             names = readdirSync(ctx.dataDir);
@@ -37,11 +19,11 @@ export const flatSessionLayout = {
                 continue;
             const id = name.slice(0, -".jsonl".length);
             if (!id || id.includes("/") || id.includes(".."))
-                continue; // never a path segment
+                continue;
             const legacy = path.join(ctx.dataDir, name);
             const target = path.join(root, id);
             if (existsSync(target))
-                continue; // already migrated; the legacy file is a leftover
+                continue;
             mkdirSync(target, { recursive: true });
             renameSync(legacy, path.join(target, "chat.jsonl"));
             ctx.log(`${name} → sessions/${id}/chat.jsonl`);

package/dist/model-meta.js

@@ -1,180 +1,204 @@
 /**
- * Provider model metadata (context window sizes) with a small TTL cache.
- * Used to auto-populate contextWindowTokens so compaction budgets derive
- * from the real window instead of the safe default.
+ * Model capabilities, from models.dev.
+ *
+ * WHY models.dev and not the provider's own `/models`: MEASURED against the operator's four
+ * configured providers, only OpenRouter publishes anything about capabilities. Command Code (93
+ * models), Google (38) and orcarouter all return just an id, a name and a context length — no
+ * `modalities`, no `reasoning`, no `supported_parameters`. That is why this file used to conclude
+ * "cannot be known", which was WRONG: models.dev carries the same information for 232 providers,
+ * including `commandcode` (71 models) and `opencode` (130), keyed by the provider's own API host.
+ *
+ * The shape mirrors what Pi (and its forks) do — models.dev is the authority, `reasoning_options`
+ * becomes the selectable effort list, `modalities.input` becomes the accepted input kinds. Keeping a
+ * second parser for each provider's ad-hoc `/models` JSON was the "wasteful and a source of bugs"
+ * the operator called out, so it is gone.
  */
 import { providerHeaders } from "./agent/provider-headers.js";
-const cache = new Map();
-const inFlight = new Map();
-const TTL = 10 * 60_000;
+const DB_URL = "https://models.dev/api.json";
+/** the whole DB is ~6MB; it changes on the order of days, so an hour is generous and cheap. */
+const TTL = 60 * 60_000;
+/** a failed fetch must not re-run per agent (15s × every agent at boot was the old bug) */
+const NEGATIVE_TTL = 5 * 60_000;
+let db;
+let inFlight;
+const hostOf = (baseUrl) => {
+    try {
+        return new URL(String(baseUrl ?? "")).host.toLowerCase();
+    }
+    catch {
+        return "";
+    }
+};
+const fresh = (s) => !!s && Date.now() - s.at < (s.negative ? NEGATIVE_TTL : TTL);
 /**
- * How long a FAILED lookup is remembered.
+ * Find the models.dev provider for a baseUrl.
  *
- * A failure used to be dropped on the floor (the `catch` returned `[]` without
- * caching), so a dead, unauthorised, or simply slow endpoint was re-fetched for
- * EVERY agent pointed at it. `addAgent` awaits this twice per agent and races it
- * against a 1.5 s timeout, so with 493 agents across a handful of providers the
- * same failing request — and its timeout — repeated hundreds of times. MEASURED
- * at boot: 1883 ms of the 4.6 s was idle, waiting on exactly this.
+ * HOST FIRST, then the path as a tie-break, because both are needed:
  *
- * Negative results expire much sooner than positive ones: a provider coming back
- * up should be usable within a minute, not locked out for ten.
- */
-const NEGATIVE_TTL = 30_000;
-/** is this cached entry still valid? (failures expire sooner) */
-function fresh(entry) {
-    return Date.now() - entry.at < (entry.negative ? NEGATIVE_TTL : TTL);
-}
-/**
- * The catalogue if it is ALREADY known, without starting a fetch (#143).
+ *   - a host match is what makes `commandcode` work: FIVE config entries share
+ *     `api.commandcode.ai`, and models.dev lists that host once;
+ *   - a host match alone is ambiguous for `opencode.ai`, which models.dev splits into `opencode`
+ *     (130 models, `/inference/openai/v1`) and `opencode-go` (37, `/inference/go/openai/v1`).
+ *     MEASURED: host-only picked whichever came first and resolved the session's provider to the
+ *     wrong catalog — 37 models, and its model not found.
  *
- * Boot uses this so it never waits for metadata it can do without: the context
- * window only tunes the compaction budget, and `supportedParameters` only gates
- * the reasoning-effort controls (#47). `prefetchModelLists()` starts the real
- * lookups in parallel, so an endpoint that answers quickly is usually warm by the
- * time its first agent is created, and a slow or dead one costs no boot time.
+ * The operator's `https://opencode.ai/zen/v1` matches NEITHER path exactly, so the path only
+ * disambiguates when it actually agrees; otherwise the host match stands.
  */
-export function peekModelList(baseUrl) {
-    const root = baseUrl.replace(/\/+$/, "");
-    const hit = cache.get(root);
-    if (!hit)
-        return undefined;
-    if (!fresh(hit))
+export function providerFor(dbProviders, baseUrl) {
+    const host = hostOf(baseUrl);
+    if (!host)
         return undefined;
-    return hit.negative ? [] : hit.list;
+    const sameHost = [...dbProviders.values()].filter((p) => hostOf(p.api ?? undefined) === host);
+    if (sameHost.length <= 1)
+        return sameHost[0];
+    const path = (() => {
+        try {
+            return new URL(String(baseUrl ?? "")).pathname;
+        }
+        catch {
+            return "";
+        }
+    })();
+    // prefer the entry whose path is a prefix/suffix relation with ours, longest overlap wins
+    const scored = sameHost
+        .map((p) => {
+        const apiPath = (() => {
+            try {
+                return new URL(String(p.api ?? "")).pathname;
+            }
+            catch {
+                return "";
+            }
+        })();
+        let common = 0;
+        for (let i = 0; i < Math.min(apiPath.length, path.length) && apiPath[i] === path[i]; i++)
+            common++;
+        /**
+         * When the shared prefix is only the leading `/`, the paths disagree entirely — `zen/v1` is
+         * neither `inference/openai/v1` nor `inference/go/openai/v1`. In that case prefer the entry
+         * with MORE models: a real provider catalog is the general one, and the narrower variant is a
+         * strict subset (opencode: 130 vs opencode-go: 37, MEASURED).
+         */
+        const models = Object.keys(p.models ?? {}).length;
+        return { p, common, models };
+    })
+        .sort((a, b) => b.common - a.common || b.models - a.models);
+    return scored[0]?.p ?? sameHost[0];
 }
-/** Fetch GET /models from an OpenAI-compatible endpoint (cached ~10 min). */
-export async function fetchModelList(baseUrl, apiKey) {
-    const root = baseUrl.replace(/\/+$/, "");
-    const hit = cache.get(root);
-    if (hit && fresh(hit))
-        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;
+async function loadDb() {
+    if (fresh(db))
+        return db;
+    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),
+            const res = await fetch(DB_URL, {
+                headers: providerHeaders(DB_URL),
+                signal: AbortSignal.timeout(8_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` is only known when the provider PUBLISHES it — in practice OpenRouter's
-                 * `architecture.input_modalities`.
-                 *
-                 * Every other endpoint omits the field, so this stays `undefined` and the UI must treat it as
-                 * UNKNOWN rather than as "text only". Reported as "Command Code GOATのモデルカタログが
-                 * input/outputのフォーマットを適切に提供していない? OpenRouterしかちゃんと対応できてない可能性は
-                 * ある" — which is exactly right, and the code was right not to invent a value.
-                 *
-                 * The consequence to know about: without a modality list nothing can decide "this model
-                 * accepts an image", so an operator's screenshot reaches the model as a FILE PATH and an agent
-                 * that tries `read_file` gets bytes. The guard for that lives in `read_file` (it refuses a
-                 * binary file by name instead of returning mojibake), so the failure is at least legible.
-                 */
-                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,
-                // per-model reasoning levels when published (OpenRouter): the UI offers
-                // exactly these, and the request is clamped into them — offering a level the
-                // model does not have is a control that does nothing (#150)
-                supportedEfforts: Array.isArray(m.reasoning?.supported_efforts)
-                    ? m.reasoning.supported_efforts.filter((e) => typeof e === "string")
-                    : undefined,
-                ...(typeof m.reasoning?.default_effort === "string"
-                    ? { defaultEffort: m.reasoning.default_effort }
-                    : {}),
-                ...(m.reasoning?.mandatory === true ? { reasoningMandatory: true } : {}),
-            }))
-                .filter((m) => m.id);
-            cache.set(root, { at: Date.now(), list });
-            return list;
+            const providers = new Map();
+            for (const [key, value] of Object.entries(j)) {
+                if (value && typeof value === "object")
+                    providers.set(key, value);
+            }
+            const snap = { at: Date.now(), providers };
+            db = snap;
+            return snap;
         }
         catch {
-            // Remember the FAILURE (briefly). Dropping it meant every agent on this
-            // endpoint paid the fetch — and up to the 1.5 s race timeout — again.
-            cache.set(root, { at: Date.now(), list: [], negative: true });
-            return []; // unreachable provider — caller treats as "unknown"
+            /**
+             * Remember the FAILURE briefly, and always return a usable snapshot.
+             *
+             * Without the negative cache every agent paid an 8s timeout at boot — the same shape as the
+             * old per-endpoint fetch. An empty map is not an error to the caller: it means "no data", and
+             * every consumer treats absent metadata as UNKNOWN rather than as "unsupported".
+             */
+            const snap = { at: Date.now(), providers: new Map(), negative: true };
+            db = snap;
+            return snap;
         }
     })();
-    inFlight.set(root, p);
+    inFlight = p;
     try {
         return await p;
     }
     finally {
-        inFlight.delete(root);
+        inFlight = undefined;
     }
 }
+/** the effort levels a models.dev record publishes, flattened out of `reasoning_options` */
+export function effortsFrom(m) {
+    const values = (m?.reasoning_options ?? [])
+        .filter((o) => o?.type === "effort")
+        .flatMap((o) => (Array.isArray(o.values) ? o.values : []))
+        .filter((v) => typeof v === "string");
+    return values.length ? [...new Set(values)] : undefined;
+}
+const strings = (v) => {
+    const out = (Array.isArray(v) ? v : []).filter((x) => typeof x === "string");
+    return out.length ? out : undefined;
+};
+/** one models.dev record → our shape; unknown fields stay absent, never invented */
+export function metaFrom(m) {
+    const input = strings(m.modalities?.input);
+    const output = strings(m.modalities?.output);
+    const efforts = effortsFrom(m);
+    return {
+        id: String(m.id ?? ""),
+        ...(typeof m.name === "string" ? { name: m.name } : {}),
+        ...(typeof m.limit?.context === "number" ? { contextLength: m.limit.context } : {}),
+        ...(m.cost && (typeof m.cost.input === "number" || typeof m.cost.output === "number")
+            ? { pricing: { prompt: Number(m.cost.input ?? 0), completion: Number(m.cost.output ?? 0) } }
+            : {}),
+        ...(input ? { modalities: { input, output: output ?? ["text"] } } : {}),
+        ...(efforts ? { supportedEfforts: efforts } : {}),
+        ...(m.reasoning === true ? { reasoning: true } : {}),
+    };
+}
+/** every model models.dev lists for this baseUrl's provider, or [] when the provider is unknown */
+export async function fetchModelList(baseUrl, _apiKey) {
+    const snap = await loadDb();
+    const provider = providerFor(snap.providers, baseUrl);
+    if (!provider?.models)
+        return [];
+    return Object.values(provider.models).map(metaFrom).filter((m) => m.id);
+}
+export function peekModelList(baseUrl) {
+    if (!fresh(db))
+        return undefined;
+    const provider = providerFor(db.providers, baseUrl);
+    if (!provider?.models)
+        return undefined;
+    return Object.values(provider.models).map(metaFrom).filter((m) => m.id);
+}
 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.
+ * Should the UI offer a reasoning-effort control for this model?
  *
- * 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".
+ * THREE answers, not two. `true` when models.dev says the model reasons; `false` when it says it
+ * does not; and TRUE when the model is simply not in the database — because the previous rule
+ * ("only OpenRouter") hid the control for every other provider even though the request would have
+ * worked. A wire that rejects `reasoning_effort` is recovered from at runtime
+ * (`isEffortUnsupported`), so an optimistic default costs one retry at worst, while a pessimistic one
+ * silently removes a feature the model does have.
  */
-export function resolveReasoningEffort(opts) {
-    if (!isReasoningEffort(opts.effort))
-        return undefined;
-    if (!isOpenRouter(opts.baseUrl))
-        return undefined;
+export function effortSupportedFor(opts) {
     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;
+    if (!meta)
+        return true; // not in models.dev → unknown, not "unsupported"
+    return meta.reasoning === true || !!meta.supportedEfforts?.length;
+}
+/** the effort levels to offer, or undefined to let the caller use its default ladder */
+export function effortsFor(opts) {
+    return opts.list?.find((m) => m.id === opts.model)?.supportedEfforts;
 }

package/dist/scheduler/cron.js

@@ -1,20 +1,13 @@
-/**
- * Minimal 5-field cron matcher (minute hour day-of-month month day-of-week).
- * Also supports shorthand "every <n>s|m|h".
- * The master ticks once every 15s; matching is a handful of integer compares.
- */
 const BOUNDS = [
     [0, 59],
     [0, 23],
     [1, 31],
     [1, 12],
-    [0, 7], // 0 and 7 are both Sunday
+    [0, 7],
 ];
 function parseField(part, min, max) {
     const out = new Set();
     const clampOrThrow = (v) => {
-        // accepting an out-of-range value produces a set that never matches, i.e. a
-        // cron that silently never fires ("99 * * * *")
         if (!Number.isInteger(v) || v < min || v > max)
             throw new Error(`bad cron field: ${part} (${min}-${max} expected)`);
         return v;
@@ -73,12 +66,10 @@ export function parseSchedule(spec) {
         fields: parts.map((p, i) => parseField(p, BOUNDS[i][0], BOUNDS[i][1])),
     };
 }
-/** Does this schedule fire at the given Date? */
 export function matches(schedule, d) {
     const values = [d.getMinutes(), d.getHours(), d.getDate(), d.getMonth() + 1, d.getDay()];
     for (let i = 0; i < 5; i++) {
         if (!schedule.fields[i].has(values[i])) {
-            // Sunday alias: field 5 with 7 should also match day=0
             if (i === 4 && values[i] === 0 && schedule.fields[i].has(7))
                 continue;
             return false;
@@ -86,14 +77,8 @@ export function matches(schedule, d) {
     }
     return true;
 }
-/**
- * Next fire time after `from`, scanning minute by minute (cheap: a handful of
- * integer compares per minute). The horizon is a year so an annual cron (a
- * December date seen in August) still resolves; a Feb-29-only cron can
- * legitimately report null most of the year.
- */
 export function nextFireAt(schedule, from = new Date()) {
-    const startMinute = Math.floor(from.getTime() / 60_000) + 1; // next whole minute
+    const startMinute = Math.floor(from.getTime() / 60_000) + 1;
     const horizon = 60 * 24 * 366;
     for (let i = 0; i < horizon; i++) {
         const d = new Date((startMinute + i) * 60_000);