teapot-coding-agent 0.37.76 → 0.37.78

package/dist/migrations/session-titles.js

@@ -1,4 +1,4 @@
-import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs";
+import { closeSync, openSync, readSync } from "node:fs";
 import path from "node:path";
 export const sessionTitles = {
     order: 30,
@@ -7,6 +7,7 @@ export const sessionTitles = {
     run(ctx) {
         const raw = ctx.raw();
         const agents = Array.isArray(raw.agents) ? raw.agents : [];
+        const isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
         let changed = false;
         /**
          * Move the title out of `config.json` and into the session's own `session.json`.
@@ -15,32 +16,27 @@ export const sessionTitles = {
          * and the copy that went stale. A title already present wins over a derived one, so an operator's
          * rename is never replaced by the auto-generated name.
          */
+        /**
+         * Move `agents[].sessionTitle` into the `sessionTitles` MAP, keyed by session id.
+         *
+         * Per-agent was the wrong key: an agent moves between sessions, so the field had to be cleared on
+         * every switch (which reverted a rename), and a session no agent points at could not keep a name.
+         * A map also keeps the left panel to ONE config read instead of a `session.json` per directory —
+         * MEASURED: 838 sessions = 13.2ms of directory reads vs 1.2ms for the config file.
+         */
+        const titles = (raw.sessionTitles = isRecord(raw.sessionTitles) ? raw.sessionTitles : {});
         for (const a of agents) {
             const session = typeof a.session === "string" ? a.session : "";
-            if (!session)
-                continue;
-            if (session.includes("/") || session.includes(".."))
-                continue;
-            const dir = path.join(ctx.dataDir, "sessions", session);
-            const file = path.join(dir, "session.json");
-            let manifest = { v: 1 };
-            try {
-                manifest = JSON.parse(readFileSync(file, "utf8"));
-            }
-            catch {
-            }
-            const already = typeof manifest.title === "string" ? manifest.title.trim() : "";
-            if (!already) {
-                const fromConfig = typeof a.sessionTitle === "string" ? a.sessionTitle.trim() : "";
-                const derived = fromConfig || firstUserPromptText(path.join(dir, "chat.jsonl")) || session;
-                manifest.title = derived;
-                try {
-                    mkdirSync(dir, { recursive: true });
-                    writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+            const legacy = typeof a.sessionTitle === "string" ? a.sessionTitle.trim() : "";
+            if (session && !session.includes("/") && !session.includes("..")) {
+                const already = typeof titles[session] === "string" ? String(titles[session]).trim() : "";
+                if (!already) {
+                    const derived = legacy ||
+                        firstUserPromptText(path.join(ctx.dataDir, "sessions", session, "chat.jsonl")) ||
+                        session;
+                    titles[session] = derived;
+                    changed = true;
                 }
-                catch {
-                }
-                changed = true;
             }
             /**
              * Only report a change when one happened: a migration that claims success every boot rewrites
@@ -51,6 +47,8 @@ export const sessionTitles = {
                 changed = true;
             }
         }
+        if (Object.keys(titles).length === 0 && raw.sessionTitles !== undefined)
+            delete raw.sessionTitles;
         if (changed)
             ctx.touch();
         return changed;

package/dist/model-meta.js

@@ -173,13 +173,87 @@ export function metaFrom(m) {
         ...(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();
+/**
+ * The model list for a provider: the PROVIDER's own catalogue, enriched by models.dev.
+ *
+ * The provider is the authority on which models exist — models.dev lags and omits entries. MEASURED:
+ * `reflection/beam:free` is served by Command Code (94 models) and absent from models.dev's
+ * `commandcode` record (72), so a models.dev-only list silently drops models the operator can
+ * actually call.
+ *
+ * models.dev is still needed for CAPABILITY, because most providers publish none: Command Code's
+ * `/models` returns only `{context_length, created, id, name, object, owned_by, supported_endpoints}`
+ * while OpenRouter publishes `architecture` (modalities) and `supported_parameters`. So:
+ *
+ *   - provider list wins for MEMBERSHIP;
+ *   - a provider field, when present, wins for that field;
+ *   - models.dev fills only what the provider did not say.
+ *
+ * When the provider cannot be reached at all we fall back to the models.dev list rather than showing
+ * nothing.
+ */
+export async function fetchModelList(baseUrl, apiKey) {
+    const [snap, upstream] = await Promise.all([
+        loadDb(),
+        fetchProviderModels(baseUrl, apiKey).catch(() => null),
+    ]);
     const provider = providerFor(snap.providers, baseUrl);
-    if (!provider?.models)
-        return [];
-    return Object.values(provider.models).map(metaFrom).filter((m) => m.id);
+    const dbModels = provider?.models ? Object.values(provider.models).map(metaFrom).filter((m) => m.id) : [];
+    if (!upstream)
+        return dbModels;
+    const byId = new Map(dbModels.map((m) => [m.id, m]));
+    return upstream
+        .map((m) => mergeMeta(m, byId.get(m.id)))
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+/** a provider's own `/models`, normalised, or null when it does not answer usefully */
+async function fetchProviderModels(baseUrl, apiKey) {
+    const url = `${String(baseUrl).replace(/\/+$/, "")}/models`;
+    const res = await fetch(url, {
+        headers: { ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}), ...providerHeaders(baseUrl) },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok)
+        return null;
+    const j = (await res.json());
+    const out = [];
+    for (const m of j.data ?? []) {
+        if (typeof m.id !== "string" || !m.id)
+            continue;
+        const input = strings(m.architecture?.input_modalities);
+        const output = strings(m.architecture?.output_modalities);
+        const ctx = typeof m.context_length === "number" ? m.context_length : undefined;
+        // `reasoning` in supported_parameters means the model accepts a reasoning_effort-style control
+        const params = strings(m.supported_parameters);
+        out.push({
+            id: m.id,
+            ...(typeof m.name === "string" ? { name: m.name } : {}),
+            ...(ctx !== undefined ? { contextLength: ctx } : {}),
+            ...(input ? { modalities: { input, output: output ?? ["text"] } } : {}),
+            ...(params?.some((p) => p === "reasoning" || p === "reasoning_effort") ? { reasoning: true } : {}),
+        });
+    }
+    return out.length ? out : null;
+}
+/** provider fields win; models.dev fills only the gaps */
+function mergeMeta(own, db) {
+    if (!db)
+        return own;
+    return {
+        id: own.id,
+        ...(own.name ?? db.name ? { name: own.name ?? db.name } : {}),
+        ...(own.contextLength ?? db.contextLength ? { contextLength: own.contextLength ?? db.contextLength } : {}),
+        ...(own.modalities ?? db.modalities
+            ? { modalities: own.modalities ?? db.modalities }
+            : {}),
+        /**
+         * Efforts come from models.dev even when the provider listed the model: no provider publishes the
+         * effort LEVELS, only that reasoning exists. `own.reasoning` still wins for the yes/no question.
+         */
+        ...(db.supportedEfforts ? { supportedEfforts: db.supportedEfforts } : {}),
+        ...(own.reasoning ?? db.reasoning ? { reasoning: own.reasoning ?? db.reasoning } : {}),
+        ...(db.pricing ? { pricing: db.pricing } : {}),
+    };
 }
 export function peekModelList(baseUrl) {
     if (!fresh(db))

package/package.json

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