teapot-coding-agent 0.37.60 → 0.37.62

package/dist/agent/agent.js

@@ -749,9 +749,39 @@ export class Agent {
         });
         return { ran };
     }
-    async editPromptAt(eventId, text, tail) {
+    /**
+     * Rewrite an earlier prompt and fork from there.
+     *
+     * The events after the edited prompt are DISCARDED, never summarized. A `summarize` mode used to
+     * call the model before forking, which made the edit block on a full round trip (the reported lag)
+     * and left `stopRequested` unset for the whole of it — so a second edit submitted while the first
+     * was summarizing read the same lineage and collided. Neither Pi nor OpenCode summarizes here, and
+     * the operator never used it, so the mode is gone rather than made asynchronous.
+     */
+    async editPromptAt(eventId, text) {
         if (this.status === "running" || this.parkedByTool || this.pendingPrompts.length)
             throw new Error("agent is running — stop it before editing history");
+        /**
+         * A LATCH, because the status check above cannot see a second call.
+         *
+         * `readEvents` and the log writes are awaits, so two requests arriving together both passed the
+         * check, both read the same lineage, and both forked — MEASURED in tyb2-9-8155867c while a
+         * `summarize` was in flight, and reachable without it by double-submitting the dialog. The latch
+         * is released in `finally`, so a failed edit does not wedge the agent.
+         */
+        if (this.editingHistory)
+            throw new Error("an edit is already in progress — wait for it to finish");
+        this.editingHistory = true;
+        try {
+            return await this.editPromptAtInner(eventId, text);
+        }
+        finally {
+            this.editingHistory = false;
+        }
+    }
+    /** true while an `editPromptAt` call owns the log; see the latch in the public method */
+    editingHistory = false;
+    async editPromptAtInner(eventId, text) {
         const all = await readEvents(this.log.filePath);
         const target = all.find((e) => e.id === eventId);
         if (!target || target.type !== "prompt")
@@ -763,23 +793,6 @@ export class Agent {
         const kept = lineage.slice(0, tIdx);
         const dropped = lineage.slice(tIdx);
         const msgs = rebuildMessagesFrom(kept);
-        if (tail === "summarize" && dropped.length > 0) {
-            try {
-                const droppedMsgs = rebuildMessagesFrom(dropped);
-                if (droppedMsgs.length) {
-                    const summary = await this.summarize(droppedMsgs);
-                    if (summary.trim()) {
-                        msgs.push({
-                            role: "user",
-                            content: "[harness] The conversation continued past this point on another timeline. " +
-                                `Notes from what happened there:\n\n${summary}`,
-                        });
-                    }
-                }
-            }
-            catch {
-            }
-        }
         msgs.push({ role: "user", content: text });
         const newBranch = `br${this.branchCount()}${Date.now().toString(36).slice(-4)}`;
         await this.quiesceForHistoryEdit();
@@ -790,7 +803,6 @@ export class Agent {
             newBranch,
             reason: "prompt-edited",
             droppedEvents: dropped.length,
-            tailMode: tail,
         });
         const cutPoint = kept.at(-1)?.id ?? null;
         this.log.seedBranch(newBranch, cutPoint);
@@ -1001,7 +1013,15 @@ export class Agent {
             model: this.opts.llm.model,
             provider: this.opts.provider,
             ...(this.opts.reasoningEffort ? { reasoningEffort: this.opts.reasoningEffort } : {}),
-            effortSupported: effortChoosable(this.opts.supportedParameters),
+            /**
+             * Offer the control unless the catalog SAYS the model cannot reason.
+             *
+             * `effortChoosable(undefined)` is `true` on purpose: a model missing from models.dev is
+             * UNKNOWN, not unsupported, and the wire recovers from a rejected `reasoning_effort`
+             * (`isEffortUnsupported`). The previous rule gated this on OpenRouter alone, which hid the
+             * control for every other provider whose model did support it.
+             */
+            effortSupported: this.opts.supportedEfforts?.length ? true : effortChoosable(undefined),
             ...(this.opts.supportedEfforts?.length ? { effortOptions: this.opts.supportedEfforts } : {}),
             sessionDir: this.opts.sessionDir,
             ctx: {

package/dist/agent/llm.js

@@ -34,7 +34,7 @@ export function effortChoosable(supported) {
         return true;
     return supported.includes("reasoning_effort");
 }
-function isOpenRouterEndpoint(baseUrl) {
+export function isOpenRouterEndpoint(baseUrl) {
     try {
         return /(^|\.)openrouter\.ai$/i.test(new URL(String(baseUrl ?? "")).host);
     }

package/dist/master.js

@@ -659,9 +659,6 @@ export class Master {
             ...(ac.parent ? { parent: ac.parent } : {}),
             ...(ac.chatFn ? { chatFn: ac.chatFn } : {}),
             ...(ac.reasoningEffort ? { reasoningEffort: ac.reasoningEffort } : {}),
-            ...(modelMeta?.supportedParameters
-                ? { supportedParameters: modelMeta.supportedParameters }
-                : {}),
             ...(modelMeta?.supportedEfforts?.length ? { supportedEfforts: modelMeta.supportedEfforts } : {}),
         });
         void fetchModelList(llm.baseUrl, llm.apiKey)
@@ -1390,7 +1387,6 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             if (cfgEntry)
                 cfgEntry.reasoningEffort = opts.opts.reasoningEffort || undefined;
         }
-        opts.opts.supportedParameters = meta?.supportedParameters;
         opts.opts.supportedEfforts = meta?.supportedEfforts;
         if (!llm.model)
             throw new Error("no model resolved (pass model or set one on the provider)");

package/dist/model-meta.js

@@ -1,84 +1,180 @@
+/**
+ * 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 NEGATIVE_TTL = 30_000;
-function fresh(entry) {
-    return Date.now() - entry.at < (entry.negative ? NEGATIVE_TTL : TTL);
-}
-export function peekModelList(baseUrl) {
-    const root = baseUrl.replace(/\/+$/, "");
-    const hit = cache.get(root);
-    if (!hit)
-        return undefined;
-    if (!fresh(hit))
+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);
+/**
+ * Find the models.dev provider for a baseUrl.
+ *
+ * HOST FIRST, then the path as a tie-break, because both are needed:
+ *
+ *   - 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.
+ *
+ * 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 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];
 }
-export async function fetchModelList(baseUrl, apiKey) {
-    const root = baseUrl.replace(/\/+$/, "");
-    const hit = cache.get(root);
-    if (hit && fresh(hit))
-        return hit.list;
-    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),
-                },
-                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,
-                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,
-                supportedParameters: Array.isArray(m.supported_parameters)
-                    ? m.supported_parameters.filter((p) => typeof p === "string")
-                    : undefined,
-                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 {
-            cache.set(root, { at: Date.now(), list: [], negative: true });
-            return [];
+            /**
+             * 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;
 }
@@ -86,23 +182,23 @@ export const REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
 export function isReasoningEffort(v) {
     return typeof v === "string" && REASONING_EFFORTS.includes(v);
 }
-export function isOpenRouter(baseUrl) {
-    try {
-        return /(^|\.)openrouter\.ai$/i.test(new URL(String(baseUrl ?? "")).host);
-    }
-    catch {
-        return false;
-    }
-}
-export function resolveReasoningEffort(opts) {
-    if (!isReasoningEffort(opts.effort))
-        return undefined;
-    if (!isOpenRouter(opts.baseUrl))
-        return undefined;
+/**
+ * Should the UI offer a reasoning-effort control for this model?
+ *
+ * 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 effortSupportedFor(opts) {
     const meta = opts.list?.find((m) => m.id === opts.model);
-    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/server/api.js

@@ -1152,7 +1152,9 @@ export function buildApp(master) {
         if (!body?.eventId || !body.text?.trim())
             return c.json({ error: "eventId and text required" }, 400);
         try {
-            const r = await a.editPromptAt(body.eventId, body.text, body.tail === "summarize" ? "summarize" : "discard");
+            // a `tail` in the body is ignored on purpose: the events after the edit are discarded, so an
+            // older client still sending `tail: "summarize"` gets the fast path rather than an error
+            const r = await a.editPromptAt(body.eventId, body.text);
             a.start("edited prompt resent");
             return c.json({ ok: true, ...r });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.37.60",
+  "version": "0.37.62",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",