agentsw 0.10.2 → 0.11.1

package/dist/commands.js

@@ -11,13 +11,13 @@ import { loadCatalog, searchCatalog } from "./modelsdev.js";
 import { classifyUnresolved, enrichProviderModels, resolveMetadataOptions } from "./metadata.js";
 import { loadGatewayCatalog } from "./gateway.js";
 import { resolveTargets, supportsProtocol, targets } from "./targets/index.js";
-import { discoverProviderModels, probeProtocols } from "./discover.js";
+import { discoverProviderCatalog, probeProtocols } from "./discover.js";
 import { appCommand, appPackages, installedVersion, isNewer, latestVersion, normalizeAppVersion, runShell } from "./apps.js";
-import { SafeConfigError, drainPendingWrites, readTextIfExists, setDryRun } from "./fsutil.js";
+import { SafeConfigError, drainPendingWrites, isDryRun, readTextIfExists, setDryRun } from "./fsutil.js";
 import { applyModelFilter } from "./filter.js";
 import { availableProviderId, providerIdFromBaseUrl, providerNameFromBaseUrl } from "./slug.js";
 import { t } from "./i18n.js";
-import { cancelInteractive, emitJson, error, isJson, note, out, table } from "./ui.js";
+import { cancelInteractive, emitJson, error, isJson, note, out, table, warn } from "./ui.js";
 import { withProgress } from "./progress.js";
 import { appsReport, listReport, modelsQueryReport, providerMetadataReport, providerModelsReport, statusReport, } from "./report.js";
 /** Share successes and failures without fetching until a model actually needs the supplement. */
@@ -202,16 +202,18 @@ export async function cmdAdd(opts) {
     const metadataOptions = resolveMetadataOptions(opts, existing);
     const manualIds = (answers.models ?? "").split(",").map((s) => s.trim()).filter(Boolean);
     let modelIds = manualIds;
+    // Limits the endpoint declares for its own models, kept from the discovery pass.
+    let endpointLimits = new Map();
     const modelFilter = parseFilterOpts(opts, existing?.modelFilter);
     const shouldDiscover = opts.discover || manualIds.length === 0;
     if (shouldDiscover) {
         if (!opts.discover) {
             note(t("add.autoDiscover"));
         }
-        const discover = () => withProgress(t("add.discovering", { url: baseUrl }), (progress) => discoverProviderModels({ baseUrl, apiKey: answers.apiKey, protocol }, {
+        const discover = () => withProgress(t("add.discovering", { url: baseUrl }), (progress) => discoverProviderCatalog({ baseUrl, apiKey: answers.apiKey, protocol }, {
             onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: baseUrl, page, count })),
         }));
-        let discovered = [];
+        let discovered = { ids: [], limits: new Map() };
         for (let attempt = 0;; attempt++) {
             try {
                 discovered = await discover();
@@ -228,9 +230,10 @@ export async function cmdAdd(opts) {
                     break;
             }
         }
-        if (discovered.length)
-            out(t("add.providerLists", { count: discovered.length }));
-        modelIds = [...new Set([...manualIds, ...discovered])];
+        if (discovered.ids.length)
+            out(t("add.providerLists", { count: discovered.ids.length }));
+        modelIds = [...new Set([...manualIds, ...discovered.ids])];
+        endpointLimits = discovered.limits;
     }
     const retained = [opts.defaultModel === undefined ? existing?.defaultModel : undefined, opts.smallModel === undefined ? existing?.smallModel : undefined].filter((id) => !!id);
     modelIds = [...new Set([...modelIds, ...retained])];
@@ -242,7 +245,7 @@ export async function cmdAdd(opts) {
         fail(t("add.atLeastOne"));
     const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
     const hint = opts.modelsDev ?? existing?.modelsDevId ?? guessProviderHint(catalog, answers.baseUrl);
-    const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: existing?.models }));
+    const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: existing?.models }, { endpointLimits }));
     const matched = models.filter((m) => m.contextWindow !== undefined).length;
     const defaultModel = opts.defaultModel ?? existing?.defaultModel ?? modelIds[0];
     if (!modelIds.includes(defaultModel))
@@ -287,7 +290,10 @@ async function createProvider(opts) {
     const metadataOptions = resolveMetadataOptions(opts, opts.existing);
     const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
     const hint = opts.modelsDev ?? opts.existing?.modelsDevId ?? guessProviderHint(catalog, baseUrl);
-    const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: opts.existing?.models }, { gatewayLoader: opts.gatewayLoader }));
+    const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, modelIds, { ...metadataOptions, modelsDevId: hint, models: opts.existing?.models }, {
+        gatewayLoader: opts.gatewayLoader,
+        endpointLimits: opts.endpointLimits,
+    }));
     const matched = models.filter((m) => m.contextWindow !== undefined).length;
     const defaultModel = opts.defaultModel ?? opts.existing?.defaultModel ?? modelIds[0];
     if (!modelIds.includes(defaultModel))
@@ -387,12 +393,12 @@ export async function cmdQuickAdd(opts) {
         const id = byId?.id ?? sameAccount?.id ?? explicitId ?? availableProviderId(providerIdFromBaseUrl(baseUrl, protocol), store.providers);
         const name = opts.name ?? existing?.name ?? (opts.id === undefined ? providerNameFromBaseUrl(baseUrl, protocol) : multi ? `${opts.id} (${protocol})` : opts.id);
         const modelFilter = parseFilterOpts(opts, existing?.modelFilter);
-        const discovered = await withProgress(`${t("add.discovering", { url: baseUrl })} [${protocol}]`, (progress) => discoverProviderModels({ baseUrl, apiKey, protocol }, {
+        const discovered = await withProgress(`${t("add.discovering", { url: baseUrl })} [${protocol}]`, (progress) => discoverProviderCatalog({ baseUrl, apiKey, protocol }, {
             onPage: ({ page, count }) => progress.update(`${t("progress.discoverPage", { url: baseUrl, page, count })} [${protocol}]`),
         }));
-        out(t("add.providerLists", { count: discovered.length }));
+        out(t("add.providerLists", { count: discovered.ids.length }));
         const retained = [opts.defaultModel === undefined ? existing?.defaultModel : undefined, opts.smallModel === undefined ? existing?.smallModel : undefined].filter((id) => !!id);
-        let modelIds = [...new Set([...discovered, ...retained])];
+        let modelIds = [...new Set([...discovered.ids, ...retained])];
         const pinned = [...retained, ...(opts.defaultModel ? [opts.defaultModel] : []), ...(opts.smallModel ? [opts.smallModel] : [])];
         const outcome = applyModelFilter(modelIds, modelFilter, pinned);
         reportDropped(outcome.dropped);
@@ -420,6 +426,7 @@ export async function cmdQuickAdd(opts) {
             gatewayModels: opts.gatewayModels,
             metadataMode: opts.metadataMode,
             gatewayLoader,
+            endpointLimits: discovered.limits,
         });
         createdIds.push(provider.id);
         note(`\n${t("add.next", { id: provider.id })}`);
@@ -466,13 +473,14 @@ export async function cmdPrune(id, opts) {
     out(`${t("remove.pruning", { id: pc.bold(id) })}\n`);
     const results = await runTargets("prune", provider, opts.apps);
     if (isJson()) {
+        const failed = results.filter((r) => r.failed).map((r) => r.app);
         emitJson({
             provider: id,
             op: "prune",
             apps: results.filter((r) => !r.skipped).map((r) => r.app),
             files: results.flatMap((r) => (r.skipped ? [] : r.changed)),
             skipped: results.filter((r) => r.skipped).map((r) => ({ app: r.app, reason: r.skipped })),
-        });
+        }, failed.length ? t("targets.failed", { apps: failed.join(", ") }) : undefined);
         return;
     }
     reportResults(results);
@@ -491,7 +499,7 @@ function reportResults(results) {
             out(`     ${" ".repeat(9)} ${pc.dim(note)}`);
     }
 }
-async function runTargets(op, provider, appsFilter, redactErrors = false) {
+async function runTargets(op, provider, appsFilter, opts = {}) {
     const selected = resolveTargets(appsFilter);
     const explicit = appsFilter !== undefined && appsFilter !== "all";
     const results = [];
@@ -505,16 +513,29 @@ async function runTargets(op, provider, appsFilter, redactErrors = false) {
             });
             continue;
         }
+        if (op === "apply" && opts.oneSlot && target.singleProvider && provider.id !== opts.oneSlot.winners.get(target.id)) {
+            const winner = opts.oneSlot.winners.get(target.id);
+            results.push({
+                app: target.id,
+                changed: [],
+                notes: [],
+                skipped: winner === undefined
+                    ? `${target.name} holds one provider at a time; left as it is because this run does not say which`
+                    : `${target.name} holds one provider at a time; written for ${winner}`,
+            });
+            continue;
+        }
         try {
             if (!explicit && !target.detect()) {
                 results.push({ app: target.id, changed: [], notes: [], skipped: `${target.name} not detected (pass --apps ${target.id} to force)` });
                 continue;
             }
-            results.push(await target[op](provider));
+            results.push(await (op === "apply" ? target.apply(provider, opts.applyOptions) : target.prune(provider)));
         }
         catch (err) {
-            const safe = redactErrors && !(err instanceof SafeConfigError);
-            results.push({ app: target.id, changed: [], notes: [], skipped: pc.red(`failed: ${safe ? t("preview.failedSafely") : err.message}`) });
+            const safe = (opts.redactErrors === true || isJson()) && !(err instanceof SafeConfigError);
+            const message = safe ? t(opts.redactErrors ? "preview.failedSafely" : "targets.failedSafely") : err.message;
+            results.push({ app: target.id, changed: [], notes: [], skipped: pc.red(`failed: ${message}`), failed: true });
             process.exitCode = 1;
         }
     }
@@ -632,20 +653,22 @@ function printFileDiff(file, next, apiKey) {
     if (oldText === newText)
         out(pc.dim(t("preview.onlyRedacted")));
 }
-async function runWithOptionalDryRun(op, provider, apps, dryRun) {
+async function runWithOptionalDryRun(op, provider, apps, dryRun, oneSlot, applyOptions) {
     const summarize = (results, files) => ({
+        ...(results.some((r) => r.failed) ? { failed: results.filter((r) => r.failed).map((r) => r.app) } : {}),
         apps: results.map((r) => r.app),
         files,
         skipped: results.filter((r) => r.skipped).map((r) => ({ app: r.app, reason: r.skipped })),
     });
     if (!dryRun) {
-        const results = await runTargets(op, provider, apps);
+        const results = await runTargets(op, provider, apps, { oneSlot, applyOptions });
         reportResults(results);
         return summarize(results, results.flatMap((r) => (r.skipped ? [] : r.changed)));
     }
+    const wasDryRun = isDryRun();
     setDryRun(true);
     try {
-        const results = await runTargets(op, provider, apps, true);
+        const results = await runTargets(op, provider, apps, { redactErrors: true, oneSlot, applyOptions });
         const writes = drainPendingWrites();
         for (const r of results) {
             if (r.skipped)
@@ -658,19 +681,32 @@ async function runWithOptionalDryRun(op, provider, apps, dryRun) {
         return summarize(results, writes.map((w) => w.file));
     }
     finally {
-        setDryRun(false);
+        setDryRun(wasDryRun);
     }
 }
 export async function cmdUse(id, opts) {
     resolveTargets(opts.apps);
     const store = loadStore();
     const provider = getProvider(store, id);
-    if (opts.model) {
-        if (!provider.models.some((m) => m.id === opts.model)) {
-            fail(t("use.modelMissing", { model: opts.model, id, have: provider.models.map((m) => m.id).join(", ") }));
+    const requireConfigured = (model) => {
+        if (!provider.models.some((m) => m.id === model)) {
+            fail(t("use.modelMissing", { model, id, have: provider.models.map((m) => m.id).join(", ") }));
         }
+    };
+    if (opts.model) {
+        requireConfigured(opts.model);
         provider.defaultModel = opts.model;
     }
+    // The slot agents reach for cheap background work — Claude Code's haiku variables. Leaving it
+    // unset means "same as the default model", so an expensive default silently becomes the
+    // background model too; `--no-small-model` returns the slot to that fallback.
+    if (typeof opts.smallModel === "string") {
+        requireConfigured(opts.smallModel);
+        provider.smallModel = opts.smallModel;
+    }
+    else if (opts.smallModel === false) {
+        delete provider.smallModel;
+    }
     if (!opts.dryRun) {
         store.active = id;
         saveStore(store);
@@ -678,20 +714,225 @@ export async function cmdUse(id, opts) {
     out(`${t("use.switching", { id: pc.bold(id), protocol: provider.protocol, model: provider.defaultModel })}\n`);
     const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun);
     if (isJson()) {
-        emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
+        emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome }, outcome.failed?.length ? t("targets.failed", { apps: outcome.failed.join(", ") }) : undefined);
+    }
+}
+function saveRefreshedProvider(store, provider) {
+    const previous = getProvider(store, provider.id);
+    store.providers[provider.id] = provider;
+    try {
+        saveStore(store);
+    }
+    catch (err) {
+        store.providers[provider.id] = previous;
+        throw err;
+    }
+}
+/**
+ * Shared by `discover` and `sync`: fetch the live model list, re-enrich from the catalog, persist.
+ * `pinned` ids survive a listing that dropped them, so they are not reported as "removed upstream".
+ * `save: false` keeps the refreshed list in memory for the caller to preview: a dry run shows what a
+ * real sync would write without leaving the fetched list behind in the store.
+ */
+async function refreshProviderModels(store, provider, save = true) {
+    const listed = await withProgress(t("add.discovering", { url: provider.baseUrl }), (progress) => discoverProviderCatalog(provider, {
+        onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: provider.baseUrl, page, count })),
+    }));
+    const pinned = [provider.defaultModel, provider.smallModel].filter((model) => !!model);
+    const outcome = applyModelFilter(listed.ids, provider.modelFilter, pinned);
+    reportDropped(outcome.dropped);
+    const ids = outcome.kept;
+    const retained = new Set([...ids, ...pinned]);
+    const known = provider.models.map((m) => m.id);
+    const added = ids.filter((m) => !known.includes(m));
+    const removed = known.filter((m) => !retained.has(m));
+    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
+    provider.models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, [...retained], { ...provider, modelsDevId: provider.modelsDevId ?? guessProviderHint(catalog, provider.baseUrl) }, { endpointLimits: listed.limits }));
+    // Reported by the caller, where it reads after the table or the per-app results instead of
+    // scrolling away above them.
+    const missing = [...new Set(pinned)].filter((model) => !ids.includes(model));
+    if (save)
+        saveRefreshedProvider(store, provider);
+    return { ids, added, removed, missing, catalog };
+}
+function printModelRefresh(provider, refresh) {
+    out(`${pc.bold(provider.id)}: ${refresh.ids.length} models (${pc.green(`+${refresh.added.length}`)} / ${pc.red(`-${refresh.removed.length}`)})` +
+        (refresh.added.length ? `\n  new: ${refresh.added.join(", ")}` : "") +
+        (refresh.removed.length ? `\n  removed upstream: ${refresh.removed.join(", ")}` : ""));
+    out(table(modelRows(provider.models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
+    printUncatalogedHint(provider.models, refresh.catalog, provider.modelsDevId);
+}
+/** Comma-separated ids, the same shape `--apps` takes. Repeats collapse; blanks are ignored. */
+function splitProviderList(value) {
+    return [...new Set(value.split(",").map((id) => id.trim()).filter(Boolean))];
+}
+/**
+ * One provider selection for every command that acts on providers: `--all` takes every configured
+ * one, `--provider` takes a comma-separated list, and `fallback` says what no selection means —
+ * `"active"` for the commands that write (sync), `"all"` for the ones that only read and refresh.
+ * Every id is resolved up front so an unknown one fails before the first network call, never after
+ * half a run has been saved. An empty store is an error only when `--all` asked for it by name; the
+ * implicit all-providers fallback keeps reporting zero, as it did before there was a flag.
+ */
+function resolveProviderIds(store, opts, fallback) {
+    if (opts.all && opts.provider !== undefined)
+        fail(t("select.allAndProvider"));
+    let ids;
+    if (opts.all) {
+        ids = Object.keys(store.providers);
+        if (!ids.length)
+            fail(t("select.noProviders"));
+    }
+    else if (opts.provider !== undefined) {
+        ids = splitProviderList(opts.provider);
+        if (!ids.length)
+            fail(t("select.noneSelected"));
+    }
+    else if (fallback === "all") {
+        ids = Object.keys(store.providers);
+    }
+    else {
+        if (!store.active)
+            fail(t("sync.noActive"));
+        ids = [store.active];
+    }
+    for (const id of ids)
+        getProvider(store, id);
+    return ids;
+}
+/**
+ * Apps that name a single provider are written once (see `RunTargetsOptions.oneSlot`); for the rest
+ * the last writer owns whatever "current" pointer the app keeps, so a multi-provider sync finishes
+ * on the active provider and leaves the agents where the store says they already are.
+ */
+function activeLast(store, ids) {
+    const active = store.active;
+    if (ids.length < 2 || !active || !ids.includes(active))
+        return ids;
+    return [...ids.filter((id) => id !== active), active];
+}
+/**
+ * Which provider each single-slot app should receive. The active provider wins where the app can
+ * accept it; where it cannot — Claude Code takes anthropic endpoints only, and the active provider
+ * may well be an openai one — the single compatible provider in the run wins instead, because
+ * writing the only candidate takes nothing away. With several compatible candidates and no active
+ * provider among them the choice is the user's, so the app is left pointing where it already does.
+ */
+function oneSlotWinners(selected, store, ids) {
+    const winners = new Map();
+    for (const target of selected) {
+        if (!target.singleProvider)
+            continue;
+        const usable = ids.filter((id) => supportsProtocol(target, store.providers[id].protocol));
+        const winner = store.active !== undefined && usable.includes(store.active)
+            ? store.active
+            : usable.length === 1 ? usable[0] : undefined;
+        if (winner !== undefined)
+            winners.set(target.id, winner);
+    }
+    return winners;
+}
+/** Section separator plus the tail line that says how many of several providers came through. */
+function printMultiSummary(count, failed, key) {
+    const done = count - failed;
+    out(`\n${failed
+        ? pc.yellow(t(key === "sync" ? "sync.summaryFailed" : "discover.summaryFailed", { ok: done, count }))
+        : t(key === "sync" ? "sync.summaryOk" : "discover.summaryOk", { count })}`);
+}
+function syncTargets(opts) {
+    const selected = resolveTargets(opts.apps);
+    if (opts.keepDefault) {
+        const unsupported = selected.filter((target) => !target.supportsKeepDefault);
+        if (unsupported.length)
+            fail(t("sync.keepDefaultUnsupported", { apps: unsupported.map((target) => target.id).join(", ") }));
+    }
+    return selected;
+}
+async function syncProviders(opts, sourceStore) {
+    const selectedTargets = syncTargets(opts);
+    const store = sourceStore ?? loadStore();
+    const ids = activeLast(store, resolveProviderIds(store, opts, "active"));
+    const many = ids.length > 1;
+    const oneSlot = many ? { winners: oneSlotWinners(selectedTargets, store, ids) } : undefined;
+    const saveRefresh = opts.dryRun !== true;
+    const reports = [];
+    const failed = [];
+    for (const [index, id] of ids.entries()) {
+        const provider = structuredClone(getProvider(store, id));
+        if (index)
+            out("");
+        let refresh;
+        if (opts.refresh !== false) {
+            try {
+                const wasDryRun = isDryRun();
+                try {
+                    if (opts.dryRun)
+                        setDryRun(true);
+                    refresh = await refreshProviderModels(store, provider, saveRefresh);
+                }
+                finally {
+                    // Metadata cache writes are not target configuration previews.
+                    if (opts.dryRun)
+                        setDryRun(wasDryRun);
+                }
+            }
+            catch (err) {
+                // One unreachable provider must not strand the others: report it, write nothing for it,
+                // and fail the run. Text mode keeps the single-provider exception contract.
+                if (!many && !isJson())
+                    throw new Error(`${err.message}\n${t("sync.refreshFailed")}`);
+                warn(t("sync.refreshSkipped", { id, message: err.message }));
+                process.exitCode = 1;
+                failed.push(id);
+                reports.push({ provider: id, refreshFailed: true });
+                continue;
+            }
+            if (!isJson()) {
+                printModelRefresh(provider, refresh);
+                // --dry-run promises to write nothing, so say the fetched list only lived long enough to preview.
+                if (!saveRefresh)
+                    note(t("sync.refreshNotSaved"));
+            }
+        }
+        out(`${t(opts.keepDefault ? "sync.syncingKeepDefault" : "sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
+        const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun, oneSlot, { keepDefault: opts.keepDefault });
+        if (outcome.failed?.length)
+            failed.push(id);
+        if (refresh?.missing.length) {
+            const models = refresh.missing.join(", ");
+            warn(t(opts.dryRun ? "refresh.pinnedMissing" : "sync.pinnedMissingWritten", { models, id }));
+        }
+        reports.push({
+            provider: id,
+            model: provider.defaultModel,
+            ...(refresh
+                ? {
+                    refreshed: {
+                        models: refresh.ids.length,
+                        added: refresh.added,
+                        removed: refresh.removed,
+                        missing: refresh.missing,
+                        saved: saveRefresh,
+                    },
+                }
+                : {}),
+            ...outcome,
+        });
     }
+    if (many)
+        printMultiSummary(ids.length, failed.length, "sync");
+    return { reports, failed };
 }
 export async function cmdSync(opts) {
-    resolveTargets(opts.apps);
-    const store = loadStore();
-    const id = opts.provider ?? store.active;
-    if (!id)
-        fail(t("sync.noActive"));
-    const provider = getProvider(store, id);
-    out(`${t("sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
-    const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun);
+    const { reports, failed } = await syncProviders(opts);
     if (isJson()) {
-        emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
+        emitJson(reports.length > 1
+            ? {
+                dryRun: opts.dryRun === true,
+                providers: reports,
+                files: [...new Set(reports.flatMap((report) => report.files ?? []))],
+            }
+            : { ...(reports[0] ?? {}), dryRun: opts.dryRun === true }, failed.length ? t("sync.failed", { ids: failed.join(", ") }) : undefined);
     }
 }
 export function cmdStatus() {
@@ -770,7 +1011,8 @@ export async function cmdModels(query, opts) {
 }
 export async function cmdRefreshMeta(opts = {}) {
     const store = loadStore();
-    const providers = opts.provider ? [getProvider(store, opts.provider)] : Object.values(store.providers);
+    // Omitting the selection still means every provider: this command only reads catalogs.
+    const providers = resolveProviderIds(store, opts, "all").map((id) => getProvider(store, id));
     resolveMetadataOptions(opts);
     for (const provider of providers)
         Object.assign(provider, resolveMetadataOptions(opts, provider));
@@ -797,50 +1039,88 @@ export async function cmdRefreshMeta(opts = {}) {
     for (const provider of providers)
         printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
 }
-export async function cmdDiscover(id, opts) {
-    resolveTargets(opts.apps);
+export async function cmdDiscover(ids, opts) {
+    if (opts.keepDefault && !opts.sync)
+        fail(t("discover.keepDefaultRequiresSync"));
+    syncTargets(opts);
     const store = loadStore();
-    const provider = getProvider(store, id);
-    Object.assign(provider, resolveMetadataOptions(opts, provider));
-    // flags override and re-persist the filter; --no-filter clears it
-    const flagFilter = parseFilterOpts(opts, provider.modelFilter);
-    if (opts.filter === false)
-        provider.modelFilter = undefined;
-    else if (flagFilter)
-        provider.modelFilter = flagFilter;
-    const listed = await withProgress(t("add.discovering", { url: provider.baseUrl }), (progress) => discoverProviderModels(provider, {
-        onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: provider.baseUrl, page, count })),
-    }));
-    const pinned = [provider.defaultModel, provider.smallModel].filter((model) => !!model);
-    const outcome = applyModelFilter(listed, provider.modelFilter, pinned);
-    reportDropped(outcome.dropped);
-    const ids = outcome.kept;
-    // Pinned ids survive a listing that dropped them, so they are not "removed upstream".
-    const retainedIds = [...new Set([...ids, ...pinned])];
-    const retained = new Set(retainedIds);
-    const known = provider.models.map((m) => m.id);
-    const added = ids.filter((m) => !known.includes(m));
-    const gone = known.filter((m) => !retained.has(m));
-    const catalog = await withProgress(t("progress.catalog"), () => loadCatalog());
-    provider.models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, retainedIds, { ...provider, modelsDevId: provider.modelsDevId ?? guessProviderHint(catalog, provider.baseUrl) }));
-    if (!ids.includes(provider.defaultModel)) {
-        out(pc.yellow(t("discover.defaultMissing", { model: provider.defaultModel })));
+    // Ids may arrive as positional arguments, as one comma-separated list, or through `-p` for
+    // symmetry with sync; all three say the same thing, so accept them together.
+    const listed = [...(Array.isArray(ids) ? ids : [ids ?? ""]), opts.provider ?? ""].filter(Boolean).join(",");
+    const selected = resolveProviderIds(store, { provider: listed || undefined, all: opts.all }, "active");
+    // Reject bad metadata options once, before the first provider is contacted.
+    resolveMetadataOptions(opts);
+    const many = selected.length > 1;
+    const reports = [];
+    const refreshed = [];
+    const failed = [];
+    for (const [index, id] of selected.entries()) {
+        const provider = structuredClone(getProvider(store, id));
+        if (index)
+            out("");
+        Object.assign(provider, resolveMetadataOptions(opts, provider));
+        // flags override and re-persist the filter; --no-filter clears it
+        const flagFilter = parseFilterOpts(opts, provider.modelFilter);
+        if (opts.filter === false)
+            provider.modelFilter = undefined;
+        else if (flagFilter)
+            provider.modelFilter = flagFilter;
+        let refresh;
+        try {
+            const wasDryRun = isDryRun();
+            try {
+                if (opts.dryRun)
+                    setDryRun(true);
+                refresh = await refreshProviderModels(store, provider, false);
+                if (opts.dryRun)
+                    store.providers[id] = provider;
+                else
+                    saveRefreshedProvider(store, provider);
+            }
+            finally {
+                if (opts.dryRun)
+                    setDryRun(wasDryRun);
+            }
+        }
+        catch (err) {
+            // One unreachable endpoint must not strand the others; text mode still throws for one.
+            if (!many && !isJson())
+                throw err;
+            warn(t("sync.refreshSkipped", { id, message: err.message }));
+            process.exitCode = 1;
+            failed.push(id);
+            reports.push({ provider: id, refreshFailed: true });
+            continue;
+        }
+        refreshed.push(id);
+        reports.push({ provider: id, models: refresh.ids.length, added: refresh.added, removed: refresh.removed, missing: refresh.missing });
+        if (!isJson())
+            printModelRefresh(provider, refresh);
+        if (refresh.missing.length)
+            warn(t("refresh.pinnedMissing", { models: refresh.missing.join(", "), id }));
     }
-    saveStore(store);
     if (isJson()) {
-        emitJson({ provider: id, models: ids.length, added, removed: gone });
+        if (opts.sync && refreshed.length) {
+            // Collect application results without emitting or fetching the discovered lists again.
+            const synced = await syncProviders({ provider: refreshed.join(","), apps: opts.apps, refresh: false, keepDefault: opts.keepDefault, dryRun: opts.dryRun }, store);
+            failed.push(...synced.failed);
+            for (const report of reports)
+                Object.assign(report, synced.reports.find((entry) => entry.provider === report.provider));
+        }
+        const files = [...new Set(reports.flatMap((report) => report.files ?? []))];
+        emitJson(many
+            ? { providers: reports, ...(opts.sync ? { files, dryRun: opts.dryRun === true } : {}) }
+            : { ...(reports[0] ?? {}), ...(opts.sync ? { dryRun: opts.dryRun === true } : {}) }, failed.length ? t("discover.failed", { ids: failed.join(", ") }) : undefined);
         return;
     }
-    out(`${pc.bold(id)}: ${ids.length} models (${pc.green(`+${added.length}`)} / ${pc.red(`-${gone.length}`)})` +
-        (added.length ? `\n  new: ${added.join(", ")}` : "") +
-        (gone.length ? `\n  removed upstream: ${gone.join(", ")}` : ""));
-    out(table(modelRows(provider.models), MODEL_HEADER, MODEL_TABLE_OPTIONS));
-    printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
-    if (opts.sync) {
+    if (many)
+        printMultiSummary(selected.length, selected.length - refreshed.length, "discover");
+    if (opts.sync && refreshed.length) {
         out("");
-        await cmdSync({ provider: id, apps: opts.apps });
+        // The lists are already fresh: write them without a second fetch.
+        await syncProviders({ provider: refreshed.join(","), apps: opts.apps, refresh: false, keepDefault: opts.keepDefault, dryRun: opts.dryRun }, store);
     }
-    else {
+    else if (!opts.sync) {
         note(`\n${t("discover.next")}`);
     }
 }
@@ -1101,8 +1381,9 @@ export async function cmdImport(opts) {
             continue;
         }
         let ids = [...c.models];
+        let endpointLimits = new Map();
         if (ids.length === 0) {
-            const discover = () => withProgress(t("import.discovering", { id: c.id }), (progress) => discoverProviderModels({ baseUrl: c.baseUrl, apiKey: apiKey, protocol: c.protocol }, {
+            const discover = () => withProgress(t("import.discovering", { id: c.id }), (progress) => discoverProviderCatalog({ baseUrl: c.baseUrl, apiKey: apiKey, protocol: c.protocol }, {
                 onPage: ({ page, count }) => progress.update(t("progress.discoverPage", { url: c.baseUrl, page, count })),
             }));
             let listed;
@@ -1126,14 +1407,15 @@ export async function cmdImport(opts) {
                 out(pc.yellow(t("import.skippedAfterFailure", { id: c.id })));
                 continue;
             }
-            ids = listed;
+            ids = listed.ids;
+            endpointLimits = listed.limits;
             ids = applyModelFilter(ids, undefined, []).kept;
         }
         if (ids.length === 0)
             fail(t("import.noModelsImport", { id: c.id }));
         const id = availableProviderId(c.id, store.providers);
         const hint = guessProviderHint(catalog, c.baseUrl);
-        const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, ids, { ...metadataOptions, modelsDevId: hint }, { gatewayLoader }));
+        const models = await withProgress(t("progress.metadata"), () => enrichProviderModels(catalog, ids, { ...metadataOptions, modelsDevId: hint }, { gatewayLoader, endpointLimits }));
         const defaultModel = c.defaultModel && ids.includes(c.defaultModel) ? c.defaultModel : ids[0];
         const existed = store.providers[id] !== undefined;
         store.providers[id] = {