agentsw 0.9.1 → 0.10.0

package/dist/menu.js

@@ -9,8 +9,9 @@ import { cmdRemoveProvider, cmdRename } from "./provider-actions.js";
 import { listRemovableProviders } from "./remove.js";
 import { providerIdFromBaseUrl } from "./slug.js";
 import { targets } from "./targets/index.js";
+import { ActionCancelled, out, setInMenu } from "./ui.js";
 function bye() {
-    console.log(pc.dim(`\n${t("menu.bye")}`));
+    out(pc.dim(`\n${t("menu.bye")}`));
     process.exit(0);
 }
 const cancel = { onCancel: () => bye() };
@@ -34,14 +35,14 @@ async function chooseLanguage() {
     const store = loadStore();
     store.language = language;
     saveStore(store);
-    console.log(pc.green(t("language.saved")));
+    out(pc.green(t("language.saved")));
 }
 /** select an existing provider; prints a hint and returns undefined when none configured */
 async function pickProvider(message) {
     const store = loadStore();
     const ids = Object.keys(store.providers);
     if (ids.length === 0) {
-        console.log(pc.yellow(t("menu.noProvidersHint")));
+        out(pc.yellow(t("menu.noProvidersHint")));
         return undefined;
     }
     const { id } = await prompts({
@@ -49,15 +50,18 @@ async function pickProvider(message) {
         name: "id",
         message,
         hint: t("menu.selectInstructions"),
-        choices: ids.map((pid) => {
-            const p = store.providers[pid];
-            return {
-                title: `${pid} · ${p.protocol} · ${t("menu.defaultModel")} ${p.defaultModel}${store.active === pid ? `  (${t("menu.active")})` : ""}`,
-                value: pid,
-            };
-        }),
+        choices: [
+            { title: t("menu.back"), value: "__back__" },
+            ...ids.map((pid) => {
+                const p = store.providers[pid];
+                return {
+                    title: `${pid} · ${p.protocol} · ${t("menu.defaultModel")} ${p.defaultModel}${store.active === pid ? `  (${t("menu.active")})` : ""}`,
+                    value: pid,
+                };
+            }),
+        ],
     }, cancel);
-    if (!id)
+    if (!id || id === "__back__")
         return undefined;
     const p = store.providers[id];
     return { id, defaultModel: p.defaultModel, models: p.models.map((m) => m.id) };
@@ -151,7 +155,7 @@ async function removeFromMenu() {
         ? listRemovableProviders(app)
         : Object.values(loadStore().providers).map((provider) => ({ id: provider.id, name: provider.name }));
     if (!entries.length) {
-        console.log(pc.dim(t("menu.noRemovable")));
+        out(pc.dim(t("menu.noRemovable")));
         return;
     }
     const { selected } = await prompts({
@@ -159,10 +163,13 @@ async function removeFromMenu() {
         name: "selected",
         message: t("menu.removeProvider"),
         hint: t("menu.selectInstructions"),
-        choices: entries.map((entry, index) => ({
-            title: `${entry.id} · ${entry.app ?? "agentsw"}${entry.name && entry.name !== entry.id ? ` · ${entry.name}` : ""}`,
-            value: index,
-        })),
+        choices: [
+            { title: t("menu.back"), value: "__back__" },
+            ...entries.map((entry, index) => ({
+                title: `${entry.id} · ${entry.app ?? "agentsw"}${entry.name && entry.name !== entry.id ? ` · ${entry.name}` : ""}`,
+                value: index,
+            })),
+        ],
     }, cancel);
     const picked = entries[selected];
     if (!picked)
@@ -179,16 +186,19 @@ async function removeFromMenu() {
     }
 }
 export async function cmdMenu() {
-    if (!loadStore().language)
+    let store = loadStore();
+    if (!store.language) {
         await chooseLanguage();
-    console.log(pc.bold("agentsw") + pc.dim(t("menu.title")));
-    if (Object.keys(loadStore().providers).length === 0) {
-        console.log(pc.yellow(t("menu.noProviders")));
+        store = loadStore(); // chooseLanguage persists the preference, so re-read before trusting the rest
+    }
+    out(pc.bold("agentsw") + pc.dim(t("menu.title")));
+    if (Object.keys(store.providers).length === 0) {
+        out(pc.yellow(t("menu.noProviders")));
         if (await askToggle(t("menu.firstScan"), true))
             await cmdImport({});
     }
     for (;;) {
-        console.log("");
+        out("");
         const { action } = await prompts({
             type: "select",
             name: "action",
@@ -214,114 +224,124 @@ export async function cmdMenu() {
         }, cancel);
         if (action === undefined || action === "quit")
             return;
-        if (action === "quickAdd") {
-            await cmdQuickAdd({});
-        }
-        else if (action === "add") {
-            const { src } = await prompts({
-                type: "select",
-                name: "src",
-                message: t("menu.modelSource"),
-                hint: t("menu.selectInstructions"),
-                choices: [
-                    { title: t("menu.modelDiscover"), value: "discover" },
-                    { title: t("menu.modelManual"), value: "manual" },
-                ],
-            }, cancel);
-            await cmdAdd({ discover: src === "discover" });
-        }
-        else if (action === "import") {
-            await cmdImport({});
-        }
-        else if (action === "use") {
-            const picked = await pickProvider(t("menu.pickProvider"));
-            if (!picked)
-                continue;
-            const apps = await pickApps(t("menu.pickApps"));
-            const { model } = await prompts({
-                type: picked.models.length > 1 ? "select" : null,
-                name: "model",
-                message: t("menu.defaultModel"),
-                hint: t("menu.selectInstructions"),
-                choices: [
-                    { title: t("menu.keepDefault", { model: picked.defaultModel }), value: "" },
-                    ...picked.models.filter((m) => m !== picked.defaultModel).map((m) => ({ title: m, value: m })),
-                ],
-            }, cancel);
-            await cmdUse(picked.id, { model: model || undefined, apps });
-        }
-        else if (action === "status") {
-            cmdStatus();
-        }
-        else if (action === "list") {
-            cmdList();
-        }
-        else if (action === "sync") {
-            await cmdSync({ apps: await pickApps(t("menu.pickApps")) });
-        }
-        else if (action === "discover") {
-            const picked = await pickProvider(t("menu.discoverFor"));
-            if (!picked)
-                continue;
-            const sync = await askToggle(t("menu.pushRefresh"));
-            await cmdDiscover(picked.id, { sync, apps: sync ? await pickApps(t("menu.pickApps")) : undefined });
-        }
-        else if (action === "metadata") {
-            const picked = await pickProvider(t("menu.metadataProvider"));
-            if (!picked)
-                continue;
-            const current = loadStore().providers[picked.id];
-            const { metadataMode } = await prompts({
-                type: "select",
-                name: "metadataMode",
-                message: t("menu.metadataMode"),
-                hint: t("menu.selectInstructions"),
-                initial: ["auto", "on", "off"].indexOf(getMetadataMode(current)),
-                choices: [
-                    { title: t("menu.metadataAuto"), description: t("menu.metadataAutoHelp"), value: "auto" },
-                    { title: t("menu.metadataOn"), description: t("menu.metadataOnHelp"), value: "on" },
-                    { title: t("menu.metadataOff"), description: t("menu.metadataOffHelp"), value: "off" },
-                ],
-            }, cancel);
-            await cmdRefreshMeta({ provider: picked.id, metadataMode });
-        }
-        else if (action === "rename" || action === "remove") {
-            try {
+        // One guard for every action: a cancelled prompt unwinds to here, and any other failure reports itself
+        // and returns to the menu instead of ending the session.
+        setInMenu(true);
+        try {
+            if (action === "quickAdd") {
+                await cmdQuickAdd({});
+            }
+            else if (action === "add") {
+                const { src } = await prompts({
+                    type: "select",
+                    name: "src",
+                    message: t("menu.modelSource"),
+                    hint: t("menu.selectInstructions"),
+                    choices: [
+                        { title: t("menu.modelDiscover"), value: "discover" },
+                        { title: t("menu.modelManual"), value: "manual" },
+                    ],
+                }, cancel);
+                await cmdAdd({ discover: src === "discover" });
+            }
+            else if (action === "import") {
+                await cmdImport({});
+            }
+            else if (action === "use") {
+                const picked = await pickProvider(t("menu.pickProvider"));
+                if (!picked)
+                    continue;
+                const apps = await pickApps(t("menu.pickApps"));
+                const { model } = await prompts({
+                    type: picked.models.length > 1 ? "select" : null,
+                    name: "model",
+                    message: t("menu.defaultModel"),
+                    hint: t("menu.selectInstructions"),
+                    choices: [
+                        { title: t("menu.keepDefault", { model: picked.defaultModel }), value: "" },
+                        ...picked.models.filter((m) => m !== picked.defaultModel).map((m) => ({ title: m, value: m })),
+                    ],
+                }, cancel);
+                await cmdUse(picked.id, { model: model || undefined, apps });
+            }
+            else if (action === "status") {
+                cmdStatus();
+            }
+            else if (action === "list") {
+                cmdList();
+            }
+            else if (action === "sync") {
+                await cmdSync({ apps: await pickApps(t("menu.pickApps")) });
+            }
+            else if (action === "discover") {
+                const picked = await pickProvider(t("menu.discoverFor"));
+                if (!picked)
+                    continue;
+                const sync = await askToggle(t("menu.pushRefresh"));
+                await cmdDiscover(picked.id, { sync, apps: sync ? await pickApps(t("menu.pickApps")) : undefined });
+            }
+            else if (action === "metadata") {
+                const picked = await pickProvider(t("menu.metadataProvider"));
+                if (!picked)
+                    continue;
+                const current = loadStore().providers[picked.id];
+                const { metadataMode } = await prompts({
+                    type: "select",
+                    name: "metadataMode",
+                    message: t("menu.metadataMode"),
+                    hint: t("menu.selectInstructions"),
+                    initial: ["auto", "on", "off"].indexOf(getMetadataMode(current)),
+                    choices: [
+                        { title: t("menu.metadataAuto"), description: t("menu.metadataAutoHelp"), value: "auto" },
+                        { title: t("menu.metadataOn"), description: t("menu.metadataOnHelp"), value: "on" },
+                        { title: t("menu.metadataOff"), description: t("menu.metadataOffHelp"), value: "off" },
+                    ],
+                }, cancel);
+                await cmdRefreshMeta({ provider: picked.id, metadataMode });
+            }
+            else if (action === "rename" || action === "remove") {
                 if (action === "rename")
                     await renameFromMenu();
                 else
                     await removeFromMenu();
             }
-            catch (error) {
-                console.error(pc.red(error instanceof Error ? error.message : String(error)));
+            else if (action === "apps") {
+                await cmdApps();
+                if (await askToggle(t("menu.upgrade")))
+                    await cmdUpgrade([]);
             }
-        }
-        else if (action === "apps") {
-            await cmdApps();
-            if (await askToggle(t("menu.upgrade")))
-                await cmdUpgrade([]);
-        }
-        else if (action === "install") {
-            const installable = appPackages
-                .filter((a) => !installedVersion(a) && appCommand(a, "install"))
-                .map((a) => ({ title: `${a.id} · ${a.name}`, value: a.id }));
-            if (installable.length === 0) {
-                console.log(pc.dim(t("menu.allInstalled")));
-                continue;
+            else if (action === "install") {
+                const installable = appPackages
+                    .filter((a) => !installedVersion(a) && appCommand(a, "install"))
+                    .map((a) => ({ title: `${a.id} · ${a.name}`, value: a.id }));
+                if (installable.length === 0) {
+                    out(pc.dim(t("menu.allInstalled")));
+                    continue;
+                }
+                const { appId } = await prompts({
+                    type: "select",
+                    name: "appId",
+                    message: t("menu.pickApp"),
+                    hint: t("menu.selectInstructions"),
+                    choices: installable,
+                }, cancel);
+                if (!appId)
+                    continue;
+                await cmdInstall(appId);
             }
-            const { appId } = await prompts({
-                type: "select",
-                name: "appId",
-                message: t("menu.pickApp"),
-                hint: t("menu.selectInstructions"),
-                choices: installable,
-            }, cancel);
-            if (!appId)
-                continue;
-            await cmdInstall(appId);
+            else if (action === "language") {
+                await chooseLanguage();
+            }
+        }
+        catch (error) {
+            // Ctrl-C inside a sub-prompt means "abandon this action", not "quit the app".
+            if (error instanceof ActionCancelled)
+                out(pc.dim(t("menu.cancelledAction")));
+            else
+                console.error(pc.red(error instanceof Error ? error.message : String(error)));
         }
-        else if (action === "language") {
-            await chooseLanguage();
+        finally {
+            setInMenu(false);
         }
     }
 }

package/dist/metadata.js

@@ -105,25 +105,42 @@ function equalValue(a, b) {
 function indexCatalog(catalog) {
     const exact = new Map();
     const canonical = new Map();
+    const identities = new Map();
+    const push = (map, key, entry) => {
+        const matches = map.get(key);
+        if (matches)
+            matches.push(entry);
+        else
+            map.set(key, [entry]);
+    };
     for (const provider of Object.values(catalog)) {
         for (const [key, model] of Object.entries(provider.models)) {
             const modelId = model.id.includes("/") ? model.id : `${provider.id}/${model.id}`;
-            const entry = { provider: provider.id, modelId, model };
-            for (const id of new Set([key, model.id])) {
-                const matches = exact.get(id);
-                if (matches)
-                    matches.push(entry);
-                else
-                    exact.set(id, [entry]);
-            }
-            const matches = canonical.get(modelId);
-            if (matches)
-                matches.push(entry);
-            else
-                canonical.set(modelId, [entry]);
+            const entry = { provider: provider.id, modelId, identity: model.canonical_model_id ?? modelId, model };
+            for (const id of new Set([key, model.id]))
+                push(exact, id, entry);
+            push(canonical, modelId, entry);
+            push(identities, entry.identity, entry);
         }
     }
-    return { exact, canonical };
+    return { exact, canonical, identities };
+}
+/** Creator identity of a catalog model id, or undefined when its rows disagree. */
+function catalogIdentity(index, modelId) {
+    const identities = new Set(index?.canonical.get(modelId)?.map((entry) => entry.identity));
+    return identities?.size === 1 ? [...identities][0] : undefined;
+}
+/**
+ * The creator's own listing for an identity, when models.dev carries one.
+ * Gateways also key their rows by the canonical id, and those rows carry the
+ * gateway's own limits and prices, so only a row from the creator's own
+ * namespace counts as authoritative.
+ */
+function creatorEntry(index, identity) {
+    const slash = identity.indexOf("/");
+    if (slash < 1)
+        return undefined;
+    return index?.identities.get(identity)?.find((entry) => entry.modelId === identity && entry.provider === identity.slice(0, slash));
 }
 function indexGatewayBareIds(gateway) {
     const result = new Map();
@@ -147,10 +164,15 @@ function selectExact(index, id, hint, aliases, gateway, gatewayBareIds) {
             const candidate = gatewayBareIds?.get(id);
             const evidence = index?.exact.get(id);
             const hintedEvidence = hint ? evidence?.filter((entry) => entry.provider === hint) : undefined;
-            const identities = new Set((hintedEvidence?.length ? hintedEvidence : evidence)?.map((entry) => entry.modelId));
+            const identities = new Set((hintedEvidence?.length ? hintedEvidence : evidence)?.map((entry) => entry.identity));
+            // Gateway names the creator while models.dev names the listing provider, so
+            // the two agree only once both are reduced to a creator identity. A gateway
+            // id the catalog has no row for stands for itself.
+            const candidateIdentity = candidate ? catalogIdentity(index, candidate) ?? candidate : undefined;
             // A unique exact basename is safe only with absent or agreeing primary evidence.
             // Explicit provider hints can resolve primary ambiguity, but never Gateway ambiguity.
-            if (candidate && (identities.size === 0 || (identities.size === 1 && identities.has(candidate))))
+            if (candidate && candidateIdentity !== undefined
+                && (identities.size === 0 || (identities.size === 1 && identities.has(candidateIdentity))))
                 gatewayId = candidate;
         }
     }
@@ -159,10 +181,10 @@ function selectExact(index, id, hint, aliases, gateway, gatewayBareIds) {
         : (bare && hint ? index?.canonical.get(`${hint}/${id}`) : undefined)
             ?? index?.canonical.get(id) ?? index?.exact.get(id);
     const hinted = candidates?.find((entry) => entry.provider === hint);
-    const identities = new Set(candidates?.map((entry) => entry.modelId));
-    const primary = hinted ?? (identities.size === 1
-        ? candidates?.find((entry) => entry.modelId.startsWith(`${entry.provider}/`)) ?? candidates?.[0]
-        : undefined);
+    const identities = new Set(candidates?.map((entry) => entry.identity));
+    // Reseller rows for one model share an identity but disagree on limits and
+    // prices, so only the creator's own row is authoritative.
+    const primary = hinted ?? (identities.size === 1 ? creatorEntry(index, [...identities][0]) : undefined);
     return { primary, gatewayId, alias };
 }
 function legacyPrimary(catalog, id, hint) {
@@ -398,3 +420,30 @@ export async function enrichProviderModels(catalog, ids, settings, options = {})
     // bounds must be resolved with the supplement against the original values.
     return gateway ? enrich(gateway) : primaryOnly ?? enrich();
 }
+/**
+ * Why a model id stayed bare after enrichment, so callers can tell the user
+ * what is worth acting on: "ambiguous" ids are listed under more than one
+ * creator and an explicit mapping resolves them; "unknown" ids no creator
+ * lists at all, so no mapping helps; "noCreatorRow" ids have one unambiguous
+ * creator but models.dev carries no authoritative row for it, so only Gateway
+ * can fill them.
+ */
+export function classifyUnresolved(catalog, ids, hint) {
+    const ambiguous = [];
+    const unknown = [];
+    const noCreatorRow = [];
+    if (!catalog)
+        return { ambiguous, unknown: [...ids], noCreatorRow };
+    const index = indexCatalog(catalog);
+    for (const id of ids) {
+        const hinted = hint ? index.canonical.get(`${hint}/${id}`) : undefined;
+        const candidates = hinted ?? index.canonical.get(id) ?? index.exact.get(id);
+        if (!candidates?.length)
+            unknown.push(id);
+        else if (new Set(candidates.map((entry) => entry.identity)).size > 1)
+            ambiguous.push(id);
+        else if (!creatorEntry(index, [...new Set(candidates.map((entry) => entry.identity))][0]))
+            noCreatorRow.push(id);
+    }
+    return { ambiguous, unknown, noCreatorRow };
+}

package/dist/modelsdev.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import fs from "node:fs";
 import { configDir } from "./store.js";
 import { readJsonIfExists, writeFileAtomic } from "./fsutil.js";
+import { warn } from "./ui.js";
 const API_URL = "https://models.dev/api.json";
 const CACHE_FILE = path.join(configDir, "models-dev.json");
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
@@ -10,29 +11,56 @@ const catalogFetchedAt = new WeakMap();
 export function getCatalogFetchedAt(catalog) {
     return catalogFetchedAt.get(catalog);
 }
+/**
+ * models.dev maps provider ids to providers, each carrying a model dictionary.
+ * A 200 response that is not shaped like a catalog (an error document from a proxy
+ * or mirror, say) must never be cached: later runs would then re-read the broken
+ * file on every load, long after the network recovered.
+ */
+function isCatalog(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return Object.values(value).every((provider) => {
+        if (!provider || typeof provider !== "object" || Array.isArray(provider))
+            return false;
+        const models = provider.models;
+        return !!models && typeof models === "object" && !Array.isArray(models);
+    });
+}
+/** A cache file that is missing, unreadable or malformed is simply not a catalog. */
 function readCachedCatalog() {
-    const catalog = readJsonIfExists(CACHE_FILE);
-    if (catalog) {
-        try {
-            catalogFetchedAt.set(catalog, fs.statSync(CACHE_FILE).mtime.toISOString());
-        }
-        catch {
-            // A concurrently removed cache still supplies useful metadata without a fetch time.
-        }
+    let parsed;
+    try {
+        parsed = readJsonIfExists(CACHE_FILE);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isCatalog(parsed))
+        return undefined;
+    const catalog = parsed;
+    try {
+        catalogFetchedAt.set(catalog, fs.statSync(CACHE_FILE).mtime.toISOString());
+    }
+    catch {
+        // A concurrently removed cache still supplies useful metadata without a fetch time.
     }
     return catalog;
 }
+function cacheIsFresh() {
+    try {
+        return Date.now() - fs.statSync(CACHE_FILE).mtimeMs < CACHE_TTL_MS;
+    }
+    catch {
+        return false;
+    }
+}
 export async function loadCatalog(opts = {}) {
     if (!opts.refresh) {
-        try {
-            const stat = fs.statSync(CACHE_FILE);
-            const fresh = Date.now() - stat.mtimeMs < CACHE_TTL_MS;
-            if (fresh || opts.offline)
-                return readCachedCatalog();
-        }
-        catch {
-            /* no cache */
-        }
+        const cached = readCachedCatalog();
+        // A malformed cache falls through to a fetch rather than failing the command.
+        if (cached && (opts.offline || cacheIsFresh()))
+            return cached;
     }
     if (opts.offline)
         return readCachedCatalog();
@@ -41,17 +69,19 @@ export async function loadCatalog(opts = {}) {
         if (!res.ok)
             throw new Error(`models.dev responded ${res.status}`);
         const text = await res.text();
-        const catalog = JSON.parse(text); // validate before caching
+        const parsed = JSON.parse(text);
+        if (!isCatalog(parsed))
+            throw new Error("models.dev returned an unexpected catalog shape");
         writeFileAtomic(CACHE_FILE, text);
-        catalogFetchedAt.set(catalog, new Date().toISOString());
-        return catalog;
+        catalogFetchedAt.set(parsed, new Date().toISOString());
+        return parsed;
     }
     catch (err) {
         // network failure: fall back to stale cache if present
         const cached = readCachedCatalog();
         if (cached)
             return cached;
-        process.stderr.write(`warning: could not fetch models.dev catalog: ${err.message}\n`);
+        warn(`could not fetch models.dev catalog: ${err.message}`);
         return undefined;
     }
 }