agentsw 0.11.0 → 0.11.1

package/README.md

@@ -35,7 +35,9 @@ without touching the settings you hand-tuned.
 - **Model metadata, not just an id list.** Reseller `/v1/models` endpoints return bare ids.
   agentsw enriches them from [models.dev](https://models.dev), automatically fills meaningful gaps from AI Gateway when needed, and writes what each app
   actually reads: `thinkingLevelMap` for pi/prime, `limit`/`attachment` for opencode,
-  `contextWindow`/`maxTokens` for omp, `reasoningEfforts`/`input` for dsh.
+  `contextWindow`/`maxTokens` for omp, `reasoningEfforts`/`input` for dsh. Limits the endpoint declares for
+  its own models outrank the catalogs, so one model cannot end up with two different context windows
+  depending on which provider lists it.
 - **Adopts what you already have** — including [cc-switch](https://github.com/farion1231/cc-switch).
   `import` scans every installed agent *and* cc-switch's own store, merges duplicates
   (same protocol + normalized endpoint + credentials), and never writes back to either.
@@ -204,8 +206,9 @@ use `--all` explicitly in scripts. Model discovery may update the local metadata
 
 ## Model discovery filters
 
-`--discover` lists model ids from the provider's `/v1/models`, then enriches each id from
-models.dev first, with automatic AI Gateway supplementation when needed. Reseller lists are noisy,
+`--discover` lists model ids from the provider's `/v1/models`, then enriches each id from models.dev first,
+with automatic AI Gateway supplementation when needed. Limits the provider declares for its own models in
+that same listing win over what a catalog claims for them; ids it lists bare are enriched as before. Reseller lists are noisy,
 so filters are persisted per provider and re-applied on every `discover`:
 
 ```bash
@@ -277,9 +280,12 @@ Without `--provider`, `refresh` applies to all providers, including any supplied
 `--gateway-models` replaces the whole alias map (`{}` clears it); aliases do not change the saved mode or override `off`.
 Import still skips already configured accounts.
 
-- **Field-level priority:** manual values > models.dev > Gateway gap filling. Tracked automatic values may
-  refresh; subsequent manual edits are retained. Legacy values without provenance are conservatively treated
-  as manual overrides. Unmodeled extension fields survive enrichment too.
+- **Field-level priority:** manual values > the endpoint's own declaration > models.dev > Gateway gap filling.
+  An endpoint that advertises `context_window_tokens`/`maximum_output_tokens`
+  (or their `context_length`/`max_output_tokens` spellings) for its own list is authoritative for its own
+  route, so those limits are written instead of a catalog's estimate for the same model. Tracked automatic
+  values may refresh; subsequent manual edits are retained. Legacy values without provenance are conservatively
+  treated as manual overrides. Unmodeled extension fields survive enrichment too.
 - **Exact identities:** automatic lookup can map a bare, case-sensitive ID (no `/`) to a unique Gateway
   `creator/model` identity when models.dev evidence is absent or agrees. Ambiguous creator evidence in either
   catalog is rejected; custom or ambiguous names need explicit aliases. Qualified IDs never have their prefixes

package/README.zh-CN.md

@@ -33,7 +33,7 @@
 - **写的是元数据，不只是模型 id。** 转售商 `/v1/models` 只返回裸 id；agentsw 从
   [models.dev](https://models.dev) 优先补全，并在有实际缺口时自动查询 AI Gateway，按各应用真正读取的字段下发：pi/prime 的
   `thinkingLevelMap`、opencode 的 `limit`/`attachment`、omp 的 `contextWindow`/`maxTokens`、
-  dsh 的 `reasoningEfforts`/`input`。
+  dsh 的 `reasoningEfforts`/`input`。端点自己声明的上下文/输出上限优先于目录，避免同一模型在不同供应商下被写成不同窗口。
 - **接管你已有的配置——包括 [cc-switch](https://github.com/farion1231/cc-switch)。**
   `import` 会扫描所有已安装的智能体**以及 cc-switch 自己的存储**，合并重复项
   （相同协议 + 归一化端点 + 凭据），并且对两者都只读不写。
@@ -191,6 +191,7 @@ imported zhipu-glm · anthropic · https://open.bigmodel.cn/api/anthropic · 1 m
 ## 模型发现过滤
 
 `--discover` 从供应商 `/v1/models` 拉取模型 id，优先从 models.dev 补全元数据，必要时自动查询 AI Gateway。
+同一份列表里供应商为自家模型声明的上下文/输出上限优先于目录的估算，只给出裸 id 的模型仍按原逻辑补全。
 转售商列表噪音大，过滤规则持久化在供应商上，每次 `discover` 自动复用：
 
 ```bash
@@ -260,7 +261,9 @@ asw sync --provider myproxy,backup-proxy
 `--gateway-models` 替换整个映射，传 `{}` 清空；映射不会更改保存的模式，也不会覆盖 `off`。
 导入仍跳过已经配置的账号。
 
-- **按字段合并：** 用户手动值优先，其次 models.dev，最后 Gateway 补缺。已记录来源的自动值可以刷新，
+- **按字段合并：** 用户手动值优先，其次端点自己声明的值，然后 models.dev，最后 Gateway 补缺。
+  端点在 `/v1/models` 中为自家模型声明了 `context_window_tokens`/`maximum_output_tokens`（或
+  `context_length`/`max_output_tokens` 写法）时，以它为准而不是目录对同一模型的估算。已记录来源的自动值可以刷新，
   手动修改后会保留；旧版本中没有来源记录的已有值保守视为手动值，不强制覆盖。未知扩展字段也保留。
 - **精确匹配：** 不含 `/` 的裸 ID 可按大小写精确匹配唯一的 Gateway `creator/model` 身份，
   前提是 models.dev 没有身份线索或线索一致。任一目录中的创建者身份有歧义时拒绝自动匹配；

package/dist/commands.js

@@ -11,9 +11,9 @@ 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";
@@ -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);
@@ -522,11 +530,12 @@ async function runTargets(op, provider, appsFilter, opts = {}) {
                 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 = opts.redactErrors === true && !(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;
         }
     }
@@ -644,20 +653,22 @@ function printFileDiff(file, next, apiKey) {
     if (oldText === newText)
         out(pc.dim(t("preview.onlyRedacted")));
 }
-async function runWithOptionalDryRun(op, provider, apps, dryRun, oneSlot) {
+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, { oneSlot });
+        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, { redactErrors: true, oneSlot });
+        const results = await runTargets(op, provider, apps, { redactErrors: true, oneSlot, applyOptions });
         const writes = drainPendingWrites();
         for (const r of results) {
             if (r.skipped)
@@ -670,7 +681,7 @@ async function runWithOptionalDryRun(op, provider, apps, dryRun, oneSlot) {
         return summarize(results, writes.map((w) => w.file));
     }
     finally {
-        setDryRun(false);
+        setDryRun(wasDryRun);
     }
 }
 export async function cmdUse(id, opts) {
@@ -703,7 +714,18 @@ 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;
     }
 }
 /**
@@ -713,11 +735,11 @@ export async function cmdUse(id, opts) {
  * 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) => discoverProviderModels(provider, {
+    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, provider.modelFilter, pinned);
+    const outcome = applyModelFilter(listed.ids, provider.modelFilter, pinned);
     reportDropped(outcome.dropped);
     const ids = outcome.kept;
     const retained = new Set([...ids, ...pinned]);
@@ -725,12 +747,12 @@ async function refreshProviderModels(store, provider, save = true) {
     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) }));
+    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)
-        saveStore(store);
+        saveRefreshedProvider(store, provider);
     return { ids, added, removed, missing, catalog };
 }
 function printModelRefresh(provider, refresh) {
@@ -817,32 +839,51 @@ function printMultiSummary(count, failed, key) {
         ? pc.yellow(t(key === "sync" ? "sync.summaryFailed" : "discover.summaryFailed", { ok: done, count }))
         : t(key === "sync" ? "sync.summaryOk" : "discover.summaryOk", { count })}`);
 }
-export async function cmdSync(opts) {
-    const selectedTargets = resolveTargets(opts.apps);
-    const store = loadStore();
+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 = [];
-    let failed = 0;
+    const failed = [];
     for (const [index, id] of ids.entries()) {
-        const provider = getProvider(store, id);
+        const provider = structuredClone(getProvider(store, id));
         if (index)
             out("");
         let refresh;
         if (opts.refresh !== false) {
             try {
-                refresh = await refreshProviderModels(store, provider, saveRefresh);
+                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. A single-provider sync has nothing else to do, so it still throws.
-                if (!many)
+                // 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 += 1;
+                failed.push(id);
                 reports.push({ provider: id, refreshFailed: true });
                 continue;
             }
@@ -853,8 +894,10 @@ export async function cmdSync(opts) {
                     note(t("sync.refreshNotSaved"));
             }
         }
-        out(`${t("sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
-        const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun, oneSlot);
+        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 }));
@@ -876,19 +919,21 @@ export async function cmdSync(opts) {
             ...outcome,
         });
     }
+    if (many)
+        printMultiSummary(ids.length, failed.length, "sync");
+    return { reports, failed };
+}
+export async function cmdSync(opts) {
+    const { reports, failed } = await syncProviders(opts);
     if (isJson()) {
-        const first = reports[0] ?? {};
-        emitJson(many
+        emitJson(reports.length > 1
             ? {
                 dryRun: opts.dryRun === true,
                 providers: reports,
                 files: [...new Set(reports.flatMap((report) => report.files ?? []))],
             }
-            : { ...first, dryRun: opts.dryRun === true });
-        return;
+            : { ...(reports[0] ?? {}), dryRun: opts.dryRun === true }, failed.length ? t("sync.failed", { ids: failed.join(", ") }) : undefined);
     }
-    if (many)
-        printMultiSummary(ids.length, failed, "sync");
 }
 export function cmdStatus() {
     const store = loadStore();
@@ -995,7 +1040,9 @@ export async function cmdRefreshMeta(opts = {}) {
         printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
 }
 export async function cmdDiscover(ids, opts) {
-    resolveTargets(opts.apps);
+    if (opts.keepDefault && !opts.sync)
+        fail(t("discover.keepDefaultRequiresSync"));
+    syncTargets(opts);
     const store = loadStore();
     // 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.
@@ -1006,8 +1053,9 @@ export async function cmdDiscover(ids, opts) {
     const many = selected.length > 1;
     const reports = [];
     const refreshed = [];
+    const failed = [];
     for (const [index, id] of selected.entries()) {
-        const provider = getProvider(store, id);
+        const provider = structuredClone(getProvider(store, id));
         if (index)
             out("");
         Object.assign(provider, resolveMetadataOptions(opts, provider));
@@ -1019,14 +1067,28 @@ export async function cmdDiscover(ids, opts) {
             provider.modelFilter = flagFilter;
         let refresh;
         try {
-            refresh = await refreshProviderModels(store, provider);
+            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; a single provider still throws.
-            if (!many)
+            // 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;
         }
@@ -1038,7 +1100,17 @@ export async function cmdDiscover(ids, opts) {
             warn(t("refresh.pinnedMissing", { models: refresh.missing.join(", "), id }));
     }
     if (isJson()) {
-        emitJson(many ? { providers: reports } : (reports[0] ?? {}));
+        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;
     }
     if (many)
@@ -1046,7 +1118,7 @@ export async function cmdDiscover(ids, opts) {
     if (opts.sync && refreshed.length) {
         out("");
         // The lists are already fresh: write them without a second fetch.
-        await cmdSync({ provider: refreshed.join(","), apps: opts.apps, refresh: false });
+        await syncProviders({ provider: refreshed.join(","), apps: opts.apps, refresh: false, keepDefault: opts.keepDefault, dryRun: opts.dryRun }, store);
     }
     else if (!opts.sync) {
         note(`\n${t("discover.next")}`);
@@ -1309,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;
@@ -1334,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] = {

package/dist/discover.js

@@ -13,6 +13,32 @@ function modelListUrl(baseUrl) {
 }
 /** Hard cap on model-list pages; an endpoint emitting endless fresh cursors must not loop forever. */
 export const MAX_MODEL_PAGES = 100;
+/**
+ * Spellings endpoints use for the same limit, in priority order: the first
+ * declared key wins when a row carries several. Providers do not agree on
+ * names — an OpenAI-compatible gateway publishes context_window_tokens /
+ * maximum_output_tokens, OpenRouter publishes context_length /
+ * max_output_tokens — and a row without the canonical name would otherwise
+ * contribute nothing.
+ */
+const contextWindowKeys = ["context_window_tokens", "context_length", "max_context_length"];
+const maxOutputKeys = ["maximum_output_tokens", "max_output_tokens", "max_completion_tokens"];
+function declaredLimit(row, keys) {
+    for (const key of keys) {
+        const value = row[key];
+        if (typeof value === "number" && Number.isFinite(value) && value > 0)
+            return Math.floor(value);
+    }
+    return undefined;
+}
+/** Limits a model row advertises, or undefined when it describes nothing but its id. */
+export function parseEndpointLimits(row) {
+    const contextWindow = declaredLimit(row, contextWindowKeys);
+    const maxOutput = declaredLimit(row, maxOutputKeys);
+    if (contextWindow === undefined && maxOutput === undefined)
+        return undefined;
+    return { ...(contextWindow !== undefined ? { contextWindow } : {}), ...(maxOutput !== undefined ? { maxOutput } : {}) };
+}
 function parseModelPage(body) {
     if (!body || typeof body !== "object")
         throw new Error("invalid model-list response");
@@ -22,25 +48,36 @@ function parseModelPage(body) {
         throw new Error("model-list response has no model array");
     if (page.has_more !== undefined && typeof page.has_more !== "boolean")
         throw new Error("invalid model-list pagination flag");
-    const ids = rows.flatMap((row) => {
+    const ids = [];
+    const limits = new Map();
+    for (const row of rows) {
         if (!row || typeof row !== "object")
-            return [];
+            continue;
         const id = row.id;
-        return typeof id === "string" && id.length > 0 ? [id] : [];
-    });
-    return { ids, hasMore: page.has_more === true, lastId: typeof page.last_id === "string" ? page.last_id : undefined };
+        if (typeof id !== "string" || id.length === 0)
+            continue;
+        ids.push(id);
+        const declared = parseEndpointLimits(row);
+        if (declared)
+            limits.set(id, declared);
+    }
+    return { ids, limits, hasMore: page.has_more === true, lastId: typeof page.last_id === "string" ? page.last_id : undefined };
 }
 /**
- * List model ids from the provider's own /v1/models endpoint.
- * Resellers expose the id list here but no metadata (context, thinking, modalities) —
- * metadata is filled from models.dev afterwards (enrichModels).
+ * List the provider's own /v1/models catalog: model ids plus the limits a row
+ * declares for itself. Plenty of resellers expose bare ids — those ids carry no
+ * entry in `limits` and metadata is filled from models.dev afterwards
+ * (enrichModels). An endpoint that does declare limits is authoritative for its
+ * own route, so those numbers outrank the catalogs instead of being replaced by
+ * whatever a third party lists for the same model.
  */
-export async function discoverProviderModels(opts, hooks = {}) {
+export async function discoverProviderCatalog(opts, hooks = {}) {
     const url = modelListUrl(opts.baseUrl);
     const headers = opts.protocol === "anthropic"
         ? { "x-api-key": opts.apiKey, "anthropic-version": "2023-06-01" }
         : { authorization: `Bearer ${opts.apiKey}` };
     const ids = new Set();
+    const limits = new Map();
     const cursors = new Set();
     const initialCursor = url.searchParams.get("after_id");
     if (initialCursor)
@@ -55,6 +92,9 @@ export async function discoverProviderModels(opts, hooks = {}) {
         const parsed = parseModelPage(await res.json());
         for (const id of parsed.ids)
             ids.add(id);
+        for (const [id, declared] of parsed.limits)
+            if (ids.has(id))
+                limits.set(id, declared);
         hooks.onPage?.({ page, count: ids.size });
         if (!parsed.hasMore)
             break;
@@ -67,7 +107,11 @@ export async function discoverProviderModels(opts, hooks = {}) {
     }
     if (ids.size === 0)
         throw new Error("provider returned no models");
-    return [...ids].sort();
+    return { ids: [...ids].sort(), limits };
+}
+/** The listed ids alone, for callers that only need the model list. */
+export async function discoverProviderModels(opts, hooks = {}) {
+    return (await discoverProviderCatalog(opts, hooks)).ids;
 }
 /**
  * Probe which wire protocols an endpoint supports by hitting /v1/models

package/dist/i18n.js

@@ -63,6 +63,11 @@ const messages = {
     "opt.showProvider": { en: "show models of a configured provider", "zh-CN": "显示已配置供应商的模型" },
     "opt.refresh": { en: "force-refresh models.dev cache", "zh-CN": "强制刷新 models.dev 缓存" },
     "opt.noRefresh": { en: "skip the model-list refresh; write the saved list only", "zh-CN": "跳过模型列表刷新;只写入已保存的列表" },
+    "opt.keepDefault": { en: "sync providers/models only; leave app settings and default selection untouched (pi/prime only; discover requires --sync)", "zh-CN": "仅同步供应商/模型，保持应用设置和默认选择不变（仅 pi/prime；discover 需搭配 --sync）" },
+    "sync.keepDefaultUnsupported": { en: "--keep-default is not supported by: {apps}; select only --apps pi,prime", "zh-CN": "以下应用不支持 --keep-default：{apps}；请仅选择 --apps pi,prime" },
+    "discover.keepDefaultRequiresSync": { en: "discover --keep-default requires --sync", "zh-CN": "discover --keep-default 需搭配 --sync" },
+    "sync.keepDefaultMissing": { en: "{file}: --keep-default stopped: current default {id}/{model} is missing from the synchronized model list; keep this model explicitly pinned or select an available default before retrying. No app files were changed.", "zh-CN": "{file}：--keep-default 已停止：当前默认 {id}/{model} 未出现在同步模型列表中；请明确保留此模型，或先选择可用默认模型再重试。应用文件未修改。" },
+    "sync.syncingKeepDefault": { en: "syncing {id} providers/models; app defaults stay unchanged", "zh-CN": "同步 {id} 的供应商/模型；应用默认选择保持不变" },
     "opt.limit": { en: "maximum results", "zh-CN": "最大结果数" },
     "opt.syncAfter": { en: "push refreshed provider into app configs", "zh-CN": "刷新后推送到应用配置" },
     "opt.appsSync": { en: "apps to sync when --sync is set", "zh-CN": "--sync 时要同步的应用" },
@@ -248,9 +253,12 @@ const messages = {
     "select.noneSelected": { en: "the provider selection is empty; name at least one id", "zh-CN": "未指定任何供应商,至少需要一个 id" },
     "sync.refreshSkipped": { en: "skipping {id}: {message}", "zh-CN": "已跳过 {id}:{message}" },
     "sync.summaryOk": { en: "synced {count} providers", "zh-CN": "已同步 {count} 个供应商" },
-    "sync.summaryFailed": { en: "synced {ok} of {count} providers; the rest were skipped", "zh-CN": "已同步 {count} 个中的 {ok} 个供应商,其余已跳过" },
+    "sync.summaryFailed": { en: "synced {ok} of {count} providers; the rest failed", "zh-CN": "已同步 {count} 个中的 {ok} 个供应商,其余失败" },
     "sync.refreshNotSaved": { en: "dry run: the refreshed model list was not saved", "zh-CN": "试运行:刷新到的模型列表未保存" },
     "sync.refreshFailed": { en: "could not refresh the model list; pass --no-refresh to write the saved list instead", "zh-CN": "无法刷新模型列表;可以加 --no-refresh 只写入已保存的列表" },
+    "sync.failed": { en: "sync failed for providers: {ids}", "zh-CN": "供应商同步失败:{ids}" },
+    "targets.failed": { en: "failed targets: {apps}", "zh-CN": "目标应用失败:{apps}" },
+    "targets.failedSafely": { en: "target operation failed", "zh-CN": "目标应用操作失败" },
     "status.config": { en: "config: {file}", "zh-CN": "配置:{file}" },
     "status.active": { en: "active provider: {id}", "zh-CN": "当前供应商:{id}" },
     "status.none": { en: "(none)", "zh-CN": "(无)" },
@@ -387,6 +395,7 @@ const messages = {
     "upgrade.failed": { en: "{id} upgrade failed: {message}", "zh-CN": "{id} 升级失败:{message}" },
     "discover.summaryOk": { en: "refreshed {count} providers", "zh-CN": "已刷新 {count} 个供应商" },
     "discover.summaryFailed": { en: "refreshed {ok} of {count} providers; the rest were skipped", "zh-CN": "已刷新 {count} 个中的 {ok} 个供应商,其余已跳过" },
+    "discover.failed": { en: "discovery or sync failed for providers: {ids}", "zh-CN": "供应商发现或同步失败:{ids}" },
     "refresh.pinnedMissing": {
         en: "{models} no longer listed by the endpoint; kept as configured — pick a listed model with: agentsw use {id} -m <model>",
         "zh-CN": "{models} 已不在端点的模型列表中;仍按原配置保留 —— 可用 agentsw use {id} -m <model> 换成列表中的模型",

package/dist/index.js

@@ -145,6 +145,7 @@ program
     .option("--all", t("opt.syncAll"))
     .option("-n, --dry-run", t("opt.dryRun"))
     .option("--no-refresh", t("opt.noRefresh"))
+    .option("--keep-default", t("opt.keepDefault"))
     .action(cmdSync);
 program.command("status").description(t("cmd.status")).action(cmdStatus);
 program
@@ -162,6 +163,8 @@ program
     .option("--all", t("opt.refreshAll"))
     .option("-s, --sync", t("opt.syncAfter"))
     .option("-a, --apps <apps>", t("opt.appsSync"))
+    .option("--keep-default", t("opt.keepDefault"))
+    .option("-n, --dry-run", t("opt.dryRun"))
     .option("--include <globs>", t("opt.setInclude"))
     .option("--exclude <globs>", t("opt.setExclude"))
     .option("--dedup", t("opt.dedup"))

package/dist/metadata.js

@@ -70,6 +70,15 @@ const fields = [
     "cost.input", "cost.output", "cost.cacheRead", "cost.cacheWrite",
 ];
 const gatewayFields = fields.filter((field) => !field.startsWith("cost."));
+/** Limits are all an endpoint is trusted for: its listing describes its own wire, not capabilities. */
+const endpointFields = ["contextWindow", "maxOutput"];
+/**
+ * Which source owns a field it proposes. An endpoint that declares its own
+ * limits outranks both catalogs — models.dev describes the model, the public
+ * Gateway describes *that* gateway, and neither is the route serving the
+ * request. models.dev outranks Gateway, which only fills what it is given.
+ */
+const sourceRank = { endpoint: 3, "models.dev": 2, "ai-gateway": 1 };
 const limits = ["maxInput", "maxOutput"];
 const coreFields = ["contextWindow", "maxOutput", "reasoning", "imageInput"];
 function fieldValue(spec, field) {
@@ -244,7 +253,9 @@ function clearStaleIdentity(spec, modelId) {
         return;
     for (const field of fields) {
         const origin = metadata.fields?.[field];
-        if (!origin || origin.modelId === modelId)
+        // Endpoint limits are keyed by the provider's own id, not by a catalog row:
+        // a catalog id that differs says nothing about the route's own numbers.
+        if (!origin || origin.source === "endpoint" || origin.modelId === modelId)
             continue;
         if (equalValue(fieldValue(spec, field), origin.value))
             setField(spec, field, undefined);
@@ -252,12 +263,13 @@ function clearStaleIdentity(spec, modelId) {
     }
     if (metadata.gateway && metadata.gateway.modelId !== modelId)
         delete metadata.gateway;
-    if (metadata.conflicts)
-        metadata.conflicts = metadata.conflicts.filter((conflict) => conflict.modelId === modelId);
+    if (metadata.conflicts) {
+        metadata.conflicts = metadata.conflicts.filter((conflict) => conflict.source === "endpoint" || conflict.modelId === modelId);
+    }
 }
 /** Apply a source as a set of field proposals, checking bounds against retained values first. */
 function mergeSource(spec, incoming, source, modelId, now, fetchedAt, supplementalGateway) {
-    const sourceFields = source === "ai-gateway" ? gatewayFields : fields;
+    const sourceFields = source === "endpoint" ? [...endpointFields] : source === "ai-gateway" ? gatewayFields : fields;
     const proposals = new Map();
     const conflicts = [];
     const conflict = (field, value, keptValue, blockedBy) => {
@@ -272,7 +284,7 @@ function mergeSource(spec, incoming, source, modelId, now, fetchedAt, supplement
             continue;
         const current = fieldValue(spec, field);
         const origin = spec.metadata?.fields?.[field];
-        if (current === undefined || (origin && (source === "models.dev" || origin.source === source))) {
+        if (current === undefined || (origin && sourceRank[source] >= sourceRank[origin.source])) {
             proposals.set(field, value);
         }
         else if (!equalValue(current, value)) {
@@ -293,6 +305,18 @@ function mergeSource(spec, incoming, source, modelId, now, fetchedAt, supplement
             if (!primaryFits && typeof next === "number" && next <= context)
                 retained = next;
             if (typeof retained === "number" && retained > context) {
+                // The endpoint's own window is authoritative for its route: a retained
+                // limit it cannot hold is a catalog estimate that would otherwise pin
+                // the window open, so the limit goes and the window wins. A weaker
+                // source keeps the old outcome — the wider window stays, the proposal
+                // is reported, because nothing here proves the retained limit wrong.
+                if (source === "endpoint") {
+                    conflict(field, retained, context, "contextWindow");
+                    setField(spec, field, undefined);
+                    if (spec.metadata?.fields)
+                        delete spec.metadata.fields[field];
+                    continue;
+                }
                 conflict("contextWindow", context, retained, field);
                 proposals.delete("contextWindow");
                 context = spec.contextWindow;
@@ -361,6 +385,12 @@ export async function enrichProviderModels(catalog, ids, settings, options = {})
                 if (origin && !equalValue(fieldValue(spec, field), origin.value))
                     delete spec.metadata.fields[field];
             }
+            // The endpoint's own numbers go in first so the catalogs can only fill
+            // what it left unsaid; a catalog that disagrees is reported as a conflict
+            // instead of overwriting the limits the route actually enforces.
+            const declared = options.endpointLimits?.get(id);
+            if (declared)
+                mergeSource(spec, { id, ...declared }, "endpoint", id, now);
             let primary;
             let supplement;
             let match;

package/dist/target-transaction.js

@@ -8,8 +8,8 @@ export function transactionalTarget(target) {
     const wrapped = Object.create(Object.getPrototypeOf(target), Object.getOwnPropertyDescriptors(target));
     for (const method of ["apply", "prune"]) {
         const operation = target[method];
-        wrapped[method] = async function (provider) {
-            const staged = await stageFileWrites(() => operation.call(this, provider));
+        wrapped[method] = async function (provider, options) {
+            const staged = await stageFileWrites(() => operation.call(this, provider, options));
             const committed = commitFileChanges(staged.changes, { dryRun: staged.dryRun, reads: staged.reads });
             if (staged.dryRun)
                 recordPendingWrites(staged.changes);

package/dist/targets/pistyle.js

@@ -1,10 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
-import { backupFile, writeFileAtomic } from "../fsutil.js";
+import { backupFile, SafeConfigError, writeFileAtomic } from "../fsutil.js";
 import { piDir, piModelsFile, piSettingsFile } from "../app-paths.js";
 import { editJsoncObject, isJsonObject, readJsoncObject } from "../jsonc.js";
 import { looksLikeEnvName } from "../slug.js";
 import { transactionalTarget } from "../target-transaction.js";
+import { t } from "../i18n.js";
 import { apiValue, applyDeepseekCompat, classifyApi, entryApi, mergeModels, OWNED_MODEL_METADATA_KEYS, ownedModelMetadata, sdkBaseUrl, stripConflictingOverrides, } from "./wire.js";
 /** pi writes the shared metadata plus its own thinking-level map. */
 const OWNED_MODEL_KEYS = [...OWNED_MODEL_METADATA_KEYS, "thinkingLevelMap"];
@@ -55,11 +56,12 @@ export function piStyleTarget(opts) {
         id: opts.id,
         name: opts.name,
         protocols: ["openai", "anthropic"],
+        supportsKeepDefault: true,
         get configPaths() {
             return [piModelsFile(id), piSettingsFile(id)];
         },
         detect: () => fs.existsSync(path.dirname(resolveDir())),
-        async apply(provider) {
+        async apply(provider, options = {}) {
             const dir = resolveDir();
             const modelsFile = path.join(dir, "models.json");
             const settingsFile = path.join(dir, "settings.json");
@@ -67,6 +69,11 @@ export function piStyleTarget(opts) {
             // Validate both files before preparing any writes, including a malformed settings file.
             const modelsDocument = readModels(modelsFile);
             const settingsDocument = readSettings(settingsFile);
+            const current = settingsDocument.value;
+            if (options.keepDefault && current.defaultProvider === provider.id && current.defaultModel &&
+                !provider.models.some((model) => model.id === current.defaultModel)) {
+                throw new SafeConfigError(t("sync.keepDefaultMissing", { file: settingsFile, id: provider.id, model: current.defaultModel }));
+            }
             const modelsConfig = { ...modelsDocument.value };
             const providers = { ...modelsConfig.providers };
             // Keys agentsw does not model (headers, authHeader, oauth, ...) and per-model extras
@@ -98,22 +105,25 @@ export function piStyleTarget(opts) {
                 models,
             };
             modelsConfig.providers = providers;
-            const settings = {
+            const modelsText = editJsoncObject(modelsDocument, modelsConfig);
+            const settingsText = options.keepDefault ? undefined : editJsoncObject(settingsDocument, {
                 ...settingsDocument.value,
                 defaultProvider: provider.id,
                 defaultModel: provider.defaultModel,
-            };
-            const modelsText = editJsoncObject(modelsDocument, modelsConfig);
-            const settingsText = editJsoncObject(settingsDocument, settings);
+            });
+            const changed = [modelsFile];
             const modelsBackup = backupFile(modelsFile);
             if (modelsBackup)
                 notes.push(`backup: ${modelsBackup}`);
             writeFileAtomic(modelsFile, modelsText);
-            const settingsBackup = backupFile(settingsFile);
-            if (settingsBackup)
-                notes.push(`backup: ${settingsBackup}`);
-            writeFileAtomic(settingsFile, settingsText);
-            return { app: opts.id, changed: [modelsFile, settingsFile], notes };
+            if (settingsText !== undefined) {
+                const settingsBackup = backupFile(settingsFile);
+                if (settingsBackup)
+                    notes.push(`backup: ${settingsBackup}`);
+                writeFileAtomic(settingsFile, settingsText);
+                changed.push(settingsFile);
+            }
+            return { app: opts.id, changed, notes };
         },
         async prune(provider) {
             const dir = resolveDir();

package/dist/ui.js

@@ -51,10 +51,12 @@ export function warn(message) {
     process.stderr.write(pc.yellow(`warning: ${message}`) + "\n");
 }
 function emitJsonError(message) {
-    process.stdout.write(JSON.stringify({ ok: false, command, version, error: { message } }) + "\n");
+    emitJson(undefined, message);
 }
-export function emitJson(data) {
-    process.stdout.write(JSON.stringify({ ok: true, command, version, data }) + "\n");
+export function emitJson(data, errorMessage) {
+    process.stdout.write(JSON.stringify({ ok: errorMessage === undefined, command, version, data,
+        ...(errorMessage === undefined ? {} : { error: { message: errorMessage } }),
+    }) + "\n");
 }
 /** Fatal error. In machine mode the failure becomes the single stdout document, so pipes stay parseable. */
 export function error(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsw",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "CLI provider switcher for coding agents: manage OpenAI/Anthropic-protocol providers in one place and sync them, with models.dev metadata, into Claude Code, Codex, omp, pi, prime-agent, opencode, Hermes, WorkBuddy and DeepSeek Harness",
   "type": "module",
   "repository": {