agentsw 0.10.2 → 0.11.0

package/README.md

@@ -27,7 +27,8 @@ without touching the settings you hand-tuned.
   `npx agentsw use myproxy -a codex,omp` is one line in a provisioning script; nine GUI
   clicks are not.
 - **`--dry-run` prints redacted diffs.** Preview changes without writing files or creating
-  backups. Existing configuration files are backed up when actual changes are committed.
+  backups — the provider store included, so a previewed `sync` does not leave its refreshed
+  model list behind. Existing configuration files are backed up when changes are committed.
 - **Non-destructive by design.** Only the fields agentsw owns are rewritten. Provider-level
   keys it does not model — `authHeader`, `headers`, `compat`, `discovery` — per-model extras
   like `thinkingLevelMap`, and YAML comments all survive a re-sync.
@@ -94,9 +95,10 @@ agentsw                   # once installed globally; the short alias `asw` is id
 
 **Run it with no arguments and you get a menu — that is the whole tool.** Every action lives
 there: add a provider (auto-detect or manual setup), import the providers already configured in
-your agents, switch provider and default model, re-sync, update a model list, configure model
-metadata, rename or delete, install/upgrade an agent, change language. On the first run it asks
-for English or 简体中文 and offers to adopt what your agents are already using.
+your agents, switch provider and default model, sync a provider (fetch its current model list,
+then write it to your agents), configure model metadata, rename or delete, install/upgrade an
+agent, change language. On the first run it asks for English or 简体中文 and offers to adopt what
+your agents are already using.
 
 Each menu action has a command equivalent for scripts, CI and headless machines — see
 [Commands](#commands). Examples below are written as `asw`; without a global install, run them
@@ -213,6 +215,10 @@ asw add -y --discover --exclude "*embedding*,*video*" --id myproxy ...
 asw add -y --discover --no-dedup ...            # keep duplicates
 asw discover myproxy --include "gpt-*,glm-*"    # update the persisted filter
 asw discover myproxy --no-filter                # clear it
+
+# Refresh several providers' model lists without writing any agent config.
+asw discover --all
+asw discover myproxy backup-proxy
 ```
 
 Explicit `--models` entries and the default model are never filtered out.
@@ -249,9 +255,16 @@ asw refresh --provider myproxy --metadata-mode off
 # Return an explicitly disabled provider to automatic mode
 asw refresh --provider myproxy --metadata-mode auto
 
-# Preview and apply separately; sync does not query catalogs
+# Preview and apply separately. Sync fetches the model list first;
+# --dry-run still fetches, so the preview matches a real sync, but saves nothing;
+# --no-refresh writes the saved list without touching the network.
 asw sync --provider myproxy --dry-run
 asw sync --provider myproxy
+asw sync --provider myproxy --no-refresh
+
+# Refresh and push several providers in one run.
+asw sync --all
+asw sync --provider myproxy,backup-proxy
 ```
 
 The menu's **Configure and refresh model metadata** action offers **Automatic (recommended)**,
@@ -286,9 +299,28 @@ Import still skips already configured accounts.
   Gateway has a separate 24-hour cache; a failed request is retried once before falling back to stale cached data
   (or skipping supplementation when there is none). `AGENTSW_DEBUG=1` reports why an attempt failed, and
   `AGENTSW_GATEWAY_TIMEOUT_MS` overrides the 15-second whole-request budget.
-- **Automatic lookup is not automatic sync:** enrichment updates saved metadata during add/quick/discover/import/refresh.
-  It does not add an automatic push to agents. Sync behavior is unchanged: ordinary `sync` only writes saved settings
-  and fetches neither model lists nor metadata catalogs.
+- **A model the endpoint dropped is reported, not hidden.** A refresh keeps the default and small
+  model even when the listing stops carrying them — one flaky listing must not delete the model you
+  chose — but being kept also keeps them out of the "removed upstream" line, so they are named in a
+  `warning:` after the apply and in `--json` as `refreshed.missing`. That is what a renamed model
+  looks like from the client side: the agents keep working with an id the endpoint now rejects.
+- **One selection everywhere:** `--all` and a comma-separated `-p a,b` mean the same thing on `sync`, `discover`
+  and `refresh`, and `discover` also takes its ids positionally (`discover alpha beta`). Every id is resolved before
+  the first request, so a typo fails before half the run is on disk. Omitting the selection keeps each command's own
+  default: the active provider for `sync` and `discover`, every provider for `refresh`.
+- **Syncing several providers:** `sync --all` takes every configured provider and `-p a,b` takes a list; each is
+  refreshed and written in turn, finishing with the active provider so whatever "current" pointer an app keeps ends
+  up where the store says it should. An app that names one provider instead of a map — Claude Code's env block — is
+  written once rather than once per provider: it gets the active provider when it can accept it, or the single
+  provider in the run that it can (Claude Code takes anthropic endpoints only, so an openai active provider does not
+  starve it). With several candidates and the active provider not among them the choice is yours, so the app keeps
+  pointing where it already does: syncing is not switching. A provider whose endpoint cannot be reached is reported
+  and skipped, the rest still sync, and the run exits non-zero.
+- **Automatic lookup is not an automatic push:** enrichment updates saved metadata during add/quick/discover/import/refresh
+  and never writes agent configs by itself. `sync` is the push, and it refreshes first: it fetches the provider's model
+  list, re-enriches it from the catalogs, saves the store, then applies it. `sync --dry-run` fetches the same list so
+  the preview is accurate but saves neither it nor the configs. `sync --no-refresh` writes the saved list without
+  fetching, and `discover` stops after the refresh without writing any agent.
 
 ## Commands
 
@@ -301,11 +333,11 @@ Import still skips already configured accounts.
 | `list` / `status` | configured providers / what each agent points at |
 | `list --apps omp,prime` | list agent-local provider IDs, including entries absent from agentsw |
 | `rename <id> <new-id>` | back up and migrate the ID and config references; supports `--dry-run` |
-| `use <id>` | switch every detected agent; `-a codex,omp`, `-m <model>`, `--dry-run` |
-| `sync` | re-apply the active provider (after an agent update, say) |
-| `discover <id> [--sync]` | refresh the model list + metadata from `/v1/models` |
+| `use <id>` | switch every detected agent; `-a codex,omp`, `-m <model>`, `--small-model <id>` / `--no-small-model`, `--dry-run` |
+| `sync` | refresh each provider's model list, then re-apply it to the agent configs; `--all` or `-p a,b` for several, `--no-refresh` writes the saved list |
+| `discover [ids...] [--sync]` | refresh the model list + metadata from `/v1/models`; `--all` or several ids for more than one, no id for the active provider; `--sync` pushes them to the agents |
 | `models [query]` | search the models.dev catalog (`-r` refresh the cache, `-l <n>` limit rows) |
-| `refresh [--provider <id>]` | refresh saved metadata and optionally configure Gateway; keep the model list |
+| `refresh [--provider <ids>]` | refresh saved metadata and optionally configure Gateway; keep the model list; every provider unless `-p a,b` narrows it |
 | `models --provider <id> --metadata` | inspect field sources, conflicts and reference pricing as JSON |
 | `prune <id>` / `remove <id> [--prune]` | remove from app configs / from the store |
 | `remove <id> --apps omp` | delete only the selected app's entry; supports `--dry-run` |

package/README.zh-CN.md

@@ -25,8 +25,8 @@
 
 - **它能去桌面应用去不了的地方。** 无头服务器、容器、devcontainer、CI。
   `npx agentsw use myproxy -a codex,omp` 在开机脚本里是一行；GUI 点九次不是。
-- **`--dry-run` 输出脱敏 diff。** 写盘前先预览；预览不写文件、不创建备份。
-  正式提交变更时，已有配置文件才会先备份。
+- **`--dry-run` 输出脱敏 diff。** 写盘前先预览；预览不写文件、不创建备份，供应商 store 也一样——
+  预览 `sync` 不会把刷新到的模型列表留在配置里。正式提交变更时，已有配置文件才会先备份。
 - **默认不破坏现有配置。** 只覆盖 agentsw 自己管理的字段：它不建模的供应商级键
   （`authHeader`、`headers`、`compat`、`discovery`）、`thinkingLevelMap` 之类的模型级字段、
   以及 YAML 注释，都会在重新同步后原样保留。
@@ -87,7 +87,7 @@ agentsw                   # 全局安装后可用；短名 `asw` 完全等价
 ```
 
 **不带参数运行就是一个菜单——整个工具都在里面。** 添加供应商（自动识别或手动设置）、导入各智能体
-已有的供应商、切换供应商和默认模型、重新同步、更新模型列表、设置模型参数补充源、重命名或删除、
+已有的供应商、切换供应商和默认模型、同步供应商（重新获取模型列表再写入）、设置模型参数补充源、重命名或删除、
 安装/升级智能体、切换语言。首次运行会先问你要 English 还是简体中文，并提议接管你各智能体已经在用的配置。
 
 菜单里的每项操作都有对应的命令，方便脚本、CI 和无头机器——见 [命令](#命令)。
@@ -200,6 +200,10 @@ asw add -y --discover --exclude "*embedding*,*video*" --id myproxy ...
 asw add -y --discover --no-dedup ...            # 保留重复项
 asw discover myproxy --include "gpt-*,glm-*"    # 更新持久化过滤规则
 asw discover myproxy --no-filter                # 清除规则
+
+# 只刷新模型列表、不写任何智能体配置，可一次多个。
+asw discover --all
+asw discover myproxy backup-proxy
 ```
 
 手动 `--models` 指定的 id 和默认模型永不被过滤。
@@ -234,9 +238,16 @@ asw refresh --provider myproxy --metadata-mode off
 # 将显式关闭的供应商恢复为自动模式
 asw refresh --provider myproxy --metadata-mode auto
 
-# 单独预览、同步；sync 不查询目录
+# 单独预览、应用。sync 会先重新获取模型列表；
+# --dry-run 同样会获取，预览因此与真实 sync 一致，但什么都不保存；
+# --no-refresh 则完全不联网，只写入已保存的列表。
 asw sync --provider myproxy --dry-run
 asw sync --provider myproxy
+asw sync --provider myproxy --no-refresh
+
+# 一次刷新并推送多个供应商。
+asw sync --all
+asw sync --provider myproxy,backup-proxy
 ```
 
 交互菜单的“设置并刷新模型参数补充源”提供“自动按需（推荐）”“始终补充”“关闭”，
@@ -266,8 +277,25 @@ asw sync --provider myproxy
   审计信息仅保存在 agentsw，不写入智能体运行配置。Gateway 目录独立缓存 24 小时；请求失败会先重试一次，
   仍失败才使用旧缓存，无缓存时只跳过补充。`AGENTSW_DEBUG=1` 会说明该次尝试失败的原因，
   `AGENTSW_GATEWAY_TIMEOUT_MS` 可覆盖默认 15 秒的整体请求预算。
-- **自动查询不等于自动同步：** 添加、快速添加、发现、导入、刷新时补全保存的元数据，并不新增自动推送。
-  同步行为不变：普通 `sync` 仅写入已保存的设置，既不获取模型列表，也不请求元数据目录。
+- **端点下掉的模型会被明确报出,而不是悄悄保留。** 刷新时即使列表里不再有默认模型和小模型，也会保留它们——
+  一次抖动的列表不该删掉你选定的模型——但「removed upstream」里就不会出现它们了，所以改为在写入之后用
+  `warning:` 点名，`--json` 里对应 `refreshed.missing`。模型被改名时从客户端看到的就是这个现象：
+  配置照旧，而端点已经不认这个 id 了。
+- **选择供应商的方式统一：** `sync`、`discover`、`refresh` 都支持 `--all` 和逗号分隔的 `-p a,b`，
+  `discover` 还可以直接写位置参数（`discover alpha beta`）。所有 id 在第一次请求前就全部解析，
+  写错一个会在任何东西落盘之前失败。不指定时各命令保持自己的默认：`sync` 和 `discover` 取当前供应商，
+  `refresh` 取全部。
+- **一次同步多个供应商：** `sync --all` 取全部已配置的供应商，`-p a,b` 取指定列表；逐个刷新并写入，
+  并把当前供应商放在最后，这样各智能体记录的“当前指向”最终就停在 store 所说的那一个。
+  只记录单个供应商（而非供应商表）的应用——例如 Claude Code 的 env 块——只写一次而不是每个供应商写一遍：
+  能接受当前供应商时就写它，不能接受时（Claude Code 只收 anthropic 端点，当前供应商却可能是 openai 的）
+  就写本次同步里它唯一能接受的那个。若有多个候选且当前供应商不在其中，选择权在你，它保持原有指向：
+  同步不是切换。
+  某个供应商的端点不可达时会被报告并跳过，其余照常同步，整个运行以非零状态结束。
+- **自动查询不等于自动推送：** 添加、快速添加、发现、导入、刷新时补全保存的元数据，永远不会自行写入智能体配置。
+  推送是 `sync`，而且它先刷新：先获取供应商模型列表、按目录补全、保存到 store，再写入各智能体。
+  `sync --dry-run` 会获取同一份列表以保证预览准确，但既不保存列表也不写配置；
+  `sync --no-refresh` 不联网，只写入已保存的列表；`discover` 刷新完就停，不写任何智能体。
 
 ## 命令
 
@@ -280,11 +308,11 @@ asw sync --provider myproxy
 | `list` / `status` | 已配置的供应商 / 各智能体当前指向 |
 | `list --apps omp,prime` | 列出智能体本地供应商 ID，包括未导入 agentsw 的条目 |
 | `rename <id> <new-id>` | 备份并迁移 ID 和配置引用，支持 `--dry-run` |
-| `use <id>` | 切换所有检测到的智能体；`-a codex,omp`、`-m <model>`、`--dry-run` |
-| `sync` | 重新应用当前供应商（比如某个智能体升级之后） |
-| `discover <id> [--sync]` | 从 `/v1/models` 刷新模型列表与元数据 |
+| `use <id>` | 切换所有检测到的智能体；`-a codex,omp`、`-m <model>`、`--small-model <id>` / `--no-small-model`、`--dry-run` |
+| `sync` | 先刷新各供应商的模型列表，再写入各智能体配置；`--all` 或 `-p a,b` 可一次处理多个，`--no-refresh` 只写已保存的列表 |
+| `discover [ids...] [--sync]` | 从 `/v1/models` 刷新模型列表与元数据；`--all` 或多个 id 可一次处理多个，不给 id 则取当前供应商；`--sync` 再推送到各智能体 |
 | `models [query]` | 搜索 models.dev 目录（`-r` 强制刷新缓存，`-l <n>` 限制条数） |
-| `refresh [--provider <id>]` | 刷新已有模型参数，可设置 Gateway 补充源，不改变模型列表 |
+| `refresh [--provider <ids>]` | 刷新已有模型参数，可设置 Gateway 补充源，不改变模型列表；默认全部，`-p a,b` 可缩小范围 |
 | `models --provider <id> --metadata` | 以 JSON 查看字段来源、冲突和参考价格 |
 | `prune <id>` / `remove <id> [--prune]` | 从各应用配置中清除 / 从存储中删除 |
 | `remove <id> --apps omp` | 仅删除指定智能体内的条目，支持 `--dry-run` |

package/dist/commands.js

@@ -17,7 +17,7 @@ import { SafeConfigError, drainPendingWrites, readTextIfExists, setDryRun } from
 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. */
@@ -491,7 +491,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,6 +505,18 @@ 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)` });
@@ -513,7 +525,7 @@ async function runTargets(op, provider, appsFilter, redactErrors = false) {
             results.push(await target[op](provider));
         }
         catch (err) {
-            const safe = redactErrors && !(err instanceof SafeConfigError);
+            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}`) });
             process.exitCode = 1;
         }
@@ -632,20 +644,20 @@ 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) {
     const summarize = (results, files) => ({
         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 });
         reportResults(results);
         return summarize(results, results.flatMap((r) => (r.skipped ? [] : r.changed)));
     }
     setDryRun(true);
     try {
-        const results = await runTargets(op, provider, apps, true);
+        const results = await runTargets(op, provider, apps, { redactErrors: true, oneSlot });
         const writes = drainPendingWrites();
         for (const r of results) {
             if (r.skipped)
@@ -665,12 +677,25 @@ 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);
@@ -681,18 +706,189 @@ export async function cmdUse(id, opts) {
         emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
     }
 }
+/**
+ * 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) => 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;
+    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) }));
+    // 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);
+    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 })}`);
+}
 export async function cmdSync(opts) {
-    resolveTargets(opts.apps);
+    const selectedTargets = 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 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;
+    for (const [index, id] of ids.entries()) {
+        const provider = getProvider(store, id);
+        if (index)
+            out("");
+        let refresh;
+        if (opts.refresh !== false) {
+            try {
+                refresh = await refreshProviderModels(store, provider, saveRefresh);
+            }
+            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)
+                    throw new Error(`${err.message}\n${t("sync.refreshFailed")}`);
+                warn(t("sync.refreshSkipped", { id, message: err.message }));
+                process.exitCode = 1;
+                failed += 1;
+                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("sync.syncing", { id: pc.bold(id), model: provider.defaultModel })}\n`);
+        const outcome = await runWithOptionalDryRun("apply", provider, opts.apps, opts.dryRun, oneSlot);
+        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 (isJson()) {
-        emitJson({ provider: id, model: provider.defaultModel, dryRun: opts.dryRun === true, ...outcome });
+        const first = reports[0] ?? {};
+        emitJson(many
+            ? {
+                dryRun: opts.dryRun === true,
+                providers: reports,
+                files: [...new Set(reports.flatMap((report) => report.files ?? []))],
+            }
+            : { ...first, dryRun: opts.dryRun === true });
+        return;
     }
+    if (many)
+        printMultiSummary(ids.length, failed, "sync");
 }
 export function cmdStatus() {
     const store = loadStore();
@@ -770,7 +966,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 +994,61 @@ export async function cmdRefreshMeta(opts = {}) {
     for (const provider of providers)
         printUncatalogedHint(provider.models, catalog, provider.modelsDevId);
 }
-export async function cmdDiscover(id, opts) {
+export async function cmdDiscover(ids, opts) {
     resolveTargets(opts.apps);
     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 = [];
+    for (const [index, id] of selected.entries()) {
+        const provider = 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 {
+            refresh = await refreshProviderModels(store, provider);
+        }
+        catch (err) {
+            // One unreachable endpoint must not strand the others; a single provider still throws.
+            if (!many)
+                throw err;
+            warn(t("sync.refreshSkipped", { id, message: err.message }));
+            process.exitCode = 1;
+            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 });
+        emitJson(many ? { providers: reports } : (reports[0] ?? {}));
         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 cmdSync({ provider: refreshed.join(","), apps: opts.apps, refresh: false });
     }
-    else {
+    else if (!opts.sync) {
         note(`\n${t("discover.next")}`);
     }
 }

package/dist/i18n.js

@@ -14,10 +14,10 @@ const messages = {
     "cmd.prune": { en: "remove a provider's entries from app configs (keeps it in agentsw)", "zh-CN": "从应用配置移除供应商条目(仍保留在 agentsw)" },
     "cmd.rename": { en: "rename a provider and migrate config references with backups", "zh-CN": "重命名供应商并迁移配置引用（自动备份）" },
     "cmd.use": { en: "set the active provider and write it into app configs", "zh-CN": "设为当前供应商并写入应用配置" },
-    "cmd.sync": { en: "re-apply the active provider (or --provider) to app configs", "zh-CN": "将当前供应商(或 --provider)重新应用到应用配置" },
+    "cmd.sync": { en: "refresh a provider's model list and re-apply it to app configs (--no-refresh writes the saved list)", "zh-CN": "刷新供应商模型列表并重新应用到应用配置(--no-refresh 只写入已保存的列表)" },
     "cmd.status": { en: "show detected apps and what they currently point at", "zh-CN": "显示检测到的应用及当前供应商" },
     "cmd.models": { en: "search models.dev, or show a configured provider's models", "zh-CN": "搜索 models.dev 或显示已配置供应商的模型" },
-    "cmd.discover": { en: "refresh a provider's model list and configured metadata sources", "zh-CN": "获取供应商模型列表，并通过已启用的目录补全参数" },
+    "cmd.discover": { en: "refresh model lists and configured metadata sources for one or more providers", "zh-CN": "刷新一个或多个供应商的模型列表，并通过已启用的目录补全参数" },
     "cmd.import": { en: "scan app configs, preview and dedupe existing custom providers, then import", "zh-CN": "扫描应用配置,预览并去重已有自定义供应商后导入" },
     "cmd.apps": { en: "check installed agents: current version vs latest", "zh-CN": "检查智能体已安装版本与最新版本" },
     "cmd.install": { en: "install an agent CLI", "zh-CN": "安装智能体 CLI" },
@@ -35,6 +35,7 @@ const messages = {
     "opt.models": { en: "comma-separated model ids", "zh-CN": "逗号分隔的模型 id" },
     "opt.defaultModel": { en: "default model (defaults to first)", "zh-CN": "默认模型(默认取第一个)" },
     "opt.smallModel": { en: "small/fast model (Claude Code haiku slot)", "zh-CN": "小型/快速模型(Claude Code haiku 槽位)" },
+    "opt.noSmallModel": { en: "clear the small/fast model so the default model fills that slot", "zh-CN": "清除小型/快速模型,该槽位改用默认模型" },
     "opt.reasoning": { en: "preferred reasoning effort (codex): minimal|low|medium|high", "zh-CN": "Codex 首选推理等级: minimal|low|medium|high" },
     "opt.discover": { en: "list model ids from the provider's /v1/models", "zh-CN": "从供应商 /v1/models 获取模型 id" },
     "opt.include": { en: "keep only models matching comma-separated globs", "zh-CN": "仅保留匹配逗号分隔 glob 的模型" },
@@ -47,7 +48,7 @@ const messages = {
     "opt.noGatewayMetadata": { en: "disable Gateway fetching; keep saved parameters (same as --metadata-mode off)", "zh-CN": "关闭 Gateway 获取，保留已保存参数（等同 --metadata-mode off）" },
     "opt.gatewayModels": { en: 'replace exact aliases as JSON: {"local-id":"creator/model"}; {} clears them', "zh-CN": '用 JSON 替换精确映射：{"本地模型ID":"creator/model"}；{} 清空' },
     "opt.metadataDetails": { en: "show field sources, conflicts and Gateway reference pricing as JSON (requires --provider)", "zh-CN": "以 JSON 查看字段来源、冲突和 Gateway 参考价格（需 --provider）" },
-    "opt.refreshProvider": { en: "refresh/configure only this saved provider (default: all)", "zh-CN": "仅刷新和设置该供应商（默认全部）" },
+    "opt.refreshProvider": { en: "refresh/configure only these saved providers, comma-separated (default: all)", "zh-CN": "仅刷新和设置这些供应商，逗号分隔（默认全部）" },
     "opt.yes": { en: "non-interactive; require all flags", "zh-CN": "非交互模式;要求提供全部参数" },
     "opt.prune": { en: "also remove entries from app configs", "zh-CN": "同时从应用配置中移除条目" },
     "opt.apps": { en: "comma-separated apps or 'all'", "zh-CN": "逗号分隔的应用或 'all'" },
@@ -56,9 +57,12 @@ const messages = {
     "opt.appsDetailed": { en: "comma-separated apps (claude,codex,omp,pi,prime,opencode,hermes,workbuddy,dsh) or 'all'", "zh-CN": "逗号分隔的应用(claude,codex,omp,pi,prime,opencode,hermes,workbuddy,dsh)或 'all'" },
     "opt.model": { en: "override default model while switching", "zh-CN": "切换时覆盖默认模型" },
     "opt.dryRun": { en: "preview config diff without writing", "zh-CN": "仅预览配置差异,不写入" },
-    "opt.provider": { en: "sync this provider instead of the active one", "zh-CN": "同步指定供应商而非当前供应商" },
+    "opt.provider": { en: "sync these providers instead of the active one (comma-separated)", "zh-CN": "同步指定供应商而非当前供应商(逗号分隔)" },
+    "opt.syncAll": { en: "sync every configured provider", "zh-CN": "同步全部已配置的供应商" },
+    "opt.refreshAll": { en: "refresh every configured provider", "zh-CN": "刷新全部已配置的供应商" },
     "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.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 时要同步的应用" },
@@ -80,8 +84,7 @@ const messages = {
     "menu.use": { en: "Switch provider and default model", "zh-CN": "切换供应商和默认模型" },
     "menu.status": { en: "View each agent's current configuration", "zh-CN": "查看各智能体当前配置" },
     "menu.list": { en: "View providers saved in agentsw", "zh-CN": "查看 agentsw 供应商列表" },
-    "menu.sync": { en: "Re-sync the current provider to agents", "zh-CN": "重新同步当前供应商" },
-    "menu.discover": { en: "Update a provider's model list", "zh-CN": "更新供应商模型列表" },
+    "menu.sync": { en: "Sync providers", "zh-CN": "同步供应商" },
     "menu.metadata": { en: "Configure and refresh model metadata", "zh-CN": "设置并刷新模型参数补充源" },
     "menu.metadataHelp": { en: "Keep the model list; choose automatic, always-on or disabled AI Gateway lookup, then refresh saved parameters only.", "zh-CN": "保留模型列表，选择 AI Gateway 自动按需、始终补充或关闭，仅刷新保存的参数。" },
     "menu.metadataProvider": { en: "which provider's metadata settings should be updated?", "zh-CN": "选择要设置模型参数补充源的供应商" },
@@ -128,8 +131,8 @@ const messages = {
     "menu.appsAll": { en: "all {count} detected apps", "zh-CN": "全部 {count} 个检测到的应用" },
     "menu.appNotDetected": { en: "(not detected)", "zh-CN": "(未检测到)" },
     "menu.appsHint": { en: "↑/↓ move · Space toggle · Enter confirm", "zh-CN": "↑/↓ 移动 · 空格切换 · Enter 确认" },
-    "menu.discoverFor": { en: "which provider's model list should be updated?", "zh-CN": "选择要更新模型列表的供应商" },
-    "menu.pushRefresh": { en: "also sync this provider to agent configs after updating its model list?", "zh-CN": "更新模型列表后，是否同时将该供应商同步到智能体配置？" },
+    "menu.syncFor": { en: "which providers should be synced?", "zh-CN": "选择要同步的供应商(可多选)" },
+    "menu.providersAll": { en: "all {count} configured providers", "zh-CN": "全部 {count} 个已配置供应商" },
     "menu.removeProvider": { en: "which provider configuration should be deleted?", "zh-CN": "选择要删除配置的供应商" },
     "menu.upgrade": { en: "upgrade all installed agents that have updates?", "zh-CN": "是否升级所有有新版本的已安装智能体？" },
     "menu.installApp": { en: "Install a new coding agent", "zh-CN": "安装新的智能体" },
@@ -205,8 +208,7 @@ const messages = {
     "menu.useHelp": { en: "Select a provider and default model, then write them to compatible agent configs.", "zh-CN": "选择供应商和默认模型，然后写入支持该协议的智能体配置。" },
     "menu.statusHelp": { en: "Show detected agents, their current providers and config file locations.", "zh-CN": "查看检测到的智能体、所用供应商及配置文件位置。" },
     "menu.listHelp": { en: "Show only the providers, protocols and default models saved in agentsw.", "zh-CN": "只查看 agentsw 已保存的供应商、协议和默认模型。" },
-    "menu.syncHelp": { en: "Write the current agentsw provider to agent configs without fetching a model list or metadata catalogs.", "zh-CN": "将 agentsw 当前供应商写入智能体配置，不重新获取模型列表或元数据目录。" },
-    "menu.discoverHelp": { en: "Fetch models from the provider, fill in model metadata, and optionally sync to agents.", "zh-CN": "从供应商接口重新获取模型并补全模型参数，可选择同步到智能体。" },
+    "menu.syncHelp": { en: "Fetch each selected provider's current model list, fill in saved parameters, then write them to the selected agent configs.", "zh-CN": "依次获取所选供应商的最新模型列表并补全保存的参数，然后写入所选智能体配置。" },
     "menu.renameHelp": { en: "Change the config ID and update references; keep custom display names.", "zh-CN": "修改配置中的标识并更新关联引用，保留自定义显示名称。" },
     "menu.removeHelp": { en: "Choose where to delete: agentsw only, one agent only, or both.", "zh-CN": "先选择删除范围：仅 agentsw、仅某个智能体，或两处一起。" },
     "menu.appsHelp": { en: "Compare installed and latest versions, then choose whether to upgrade.", "zh-CN": "对比已安装版本和最新版本，再选择是否升级。" },
@@ -241,6 +243,14 @@ const messages = {
     "use.switching": { en: "switching to {id} ({protocol}) · default model {model}", "zh-CN": "正在切换到 {id} ({protocol})· 默认模型 {model}" },
     "sync.noActive": { en: "no active provider; run agentsw use <id> first", "zh-CN": "没有当前供应商;请先运行 agentsw use <id>" },
     "sync.syncing": { en: "syncing provider {id} · default model {model}", "zh-CN": "正在同步供应商 {id} · 默认模型 {model}" },
+    "select.allAndProvider": { en: "--all cannot be combined with a provider selection", "zh-CN": "--all 不能与指定的供应商同时使用" },
+    "select.noProviders": { en: "no providers configured; run agentsw add first", "zh-CN": "尚未配置任何供应商;请先运行 agentsw add" },
+    "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.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 只写入已保存的列表" },
     "status.config": { en: "config: {file}", "zh-CN": "配置:{file}" },
     "status.active": { en: "active provider: {id}", "zh-CN": "当前供应商:{id}" },
     "status.none": { en: "(none)", "zh-CN": "(无)" },
@@ -375,9 +385,15 @@ const messages = {
     },
     "upgrade.done": { en: "{id} -> {version}", "zh-CN": "{id} -> {version}" },
     "upgrade.failed": { en: "{id} upgrade failed: {message}", "zh-CN": "{id} 升级失败:{message}" },
-    "discover.defaultMissing": {
-        en: "default model {model} no longer listed; keeping it anyway",
-        "zh-CN": "默认模型 {model} 已不在列表中;仍然保留",
+    "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} 个供应商,其余已跳过" },
+    "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> 换成列表中的模型",
+    },
+    "sync.pinnedMissingWritten": {
+        en: "{models} no longer listed by the endpoint but was written to the agents anyway; pick a listed model with: agentsw use {id} -m <model>",
+        "zh-CN": "{models} 已不在端点的模型列表中,但仍写入了各智能体;可用 agentsw use {id} -m <model> 换成列表中的模型",
     },
     "discover.next": {
         en: "run `agentsw sync` to push into app configs",

package/dist/index.js

@@ -133,14 +133,18 @@ program
     .description(t("cmd.use"))
     .option("-a, --apps <apps>", t("opt.appsDetailed"))
     .option("-m, --model <id>", t("opt.model"))
+    .option("--small-model <id>", t("opt.smallModel"))
+    .option("--no-small-model", t("opt.noSmallModel"))
     .option("-n, --dry-run", t("opt.dryRun"))
     .action(cmdUse);
 program
     .command("sync")
     .description(t("cmd.sync"))
     .option("-a, --apps <apps>", t("opt.apps"))
-    .option("-p, --provider <id>", t("opt.provider"))
+    .option("-p, --provider <ids>", t("opt.provider"))
+    .option("--all", t("opt.syncAll"))
     .option("-n, --dry-run", t("opt.dryRun"))
+    .option("--no-refresh", t("opt.noRefresh"))
     .action(cmdSync);
 program.command("status").description(t("cmd.status")).action(cmdStatus);
 program
@@ -152,8 +156,10 @@ program
     .option("-l, --limit <n>", t("opt.limit"), "30")
     .action(cmdModels);
 program
-    .command("discover <id>")
+    .command("discover [ids...]")
     .description(t("cmd.discover"))
+    .option("-p, --provider <ids>", t("opt.refreshProvider"))
+    .option("--all", t("opt.refreshAll"))
     .option("-s, --sync", t("opt.syncAfter"))
     .option("-a, --apps <apps>", t("opt.appsSync"))
     .option("--include <globs>", t("opt.setInclude"))
@@ -181,7 +187,8 @@ program.command("upgrade [apps...]").description(t("cmd.upgrade")).action(cmdUpg
 program
     .command("refresh")
     .description(t("cmd.refresh"))
-    .option("-p, --provider <id>", t("opt.refreshProvider"))
+    .option("-p, --provider <ids>", t("opt.refreshProvider"))
+    .option("--all", t("opt.refreshAll"))
     .option("--metadata-mode <auto|on|off>", t("opt.metadataMode"))
     .option("--gateway-metadata", t("opt.gatewayMetadata"))
     .option("--no-gateway-metadata", t("opt.noGatewayMetadata"))

package/dist/menu.js

@@ -1,6 +1,6 @@
 import pc from "picocolors";
 import prompts from "prompts";
-import { cmdAdd, cmdQuickAdd, cmdApps, cmdInstall, cmdDiscover, cmdImport, cmdRefreshMeta, cmdList, cmdStatus, cmdSync, cmdUpgrade, cmdUse, } from "./commands.js";
+import { cmdAdd, cmdQuickAdd, cmdApps, cmdInstall, cmdImport, cmdRefreshMeta, cmdList, cmdStatus, cmdSync, cmdUpgrade, cmdUse, } from "./commands.js";
 import { getLocale, setLocale, t } from "./i18n.js";
 import { getMetadataMode } from "./metadata.js";
 import { loadStore, saveStore } from "./store.js";
@@ -66,6 +66,41 @@ async function pickProvider(message) {
     const p = store.providers[id];
     return { id, defaultModel: p.defaultModel, models: p.models.map((m) => m.id) };
 }
+/**
+ * Multi-select providers for one sync. The first row takes every configured provider and maps to
+ * the CLI's `--all`; toggling everything off means "back", not "all", because a sync writes files.
+ */
+async function pickProviders(message) {
+    const store = loadStore();
+    const ids = Object.keys(store.providers);
+    if (ids.length === 0) {
+        out(pc.yellow(t("menu.noProvidersHint")));
+        return undefined;
+    }
+    const { providers } = await prompts({
+        type: "multiselect",
+        name: "providers",
+        message,
+        hint: t("menu.appsHint"),
+        instructions: false,
+        choices: [
+            { title: t("menu.providersAll", { count: ids.length }), value: "__all__" },
+            ...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,
+                    selected: store.active === pid,
+                };
+            }),
+        ],
+    }, cancel);
+    const chosen = Array.isArray(providers) ? providers : [];
+    if (chosen.includes("__all__"))
+        return { all: true, ids };
+    const selected = chosen.filter((value) => value !== "__all__");
+    return selected.length ? { all: false, ids: selected } : undefined;
+}
 /**
  * Multi-select target apps, remembering the previous choice. The first row selects
  * every detected app; picking it (or toggling everything off) returns undefined,
@@ -212,7 +247,6 @@ export async function cmdMenu() {
                 { title: t("menu.status"), description: t("menu.statusHelp"), value: "status" },
                 { title: t("menu.list"), description: t("menu.listHelp"), value: "list" },
                 { title: t("menu.sync"), description: t("menu.syncHelp"), value: "sync" },
-                { title: t("menu.discover"), description: t("menu.discoverHelp"), value: "discover" },
                 { title: t("menu.metadata"), description: t("menu.metadataHelp"), value: "metadata" },
                 { title: t("menu.rename"), description: t("menu.renameHelp"), value: "rename" },
                 { title: t("menu.remove"), description: t("menu.removeHelp"), value: "remove" },
@@ -271,14 +305,11 @@ export async function cmdMenu() {
                 cmdList();
             }
             else if (action === "sync") {
-                await cmdSync({ apps: await pickApps(t("menu.pickApps")) });
-            }
-            else if (action === "discover") {
-                const picked = await pickProvider(t("menu.discoverFor"));
+                const picked = await pickProviders(t("menu.syncFor"));
                 if (!picked)
                     continue;
-                const sync = await askToggle(t("menu.pushRefresh"));
-                await cmdDiscover(picked.id, { sync, apps: sync ? await pickApps(t("menu.pickApps")) : undefined });
+                const apps = await pickApps(t("menu.pickApps"));
+                await cmdSync(picked.all ? { all: true, apps } : { provider: picked.ids.join(","), apps });
             }
             else if (action === "metadata") {
                 const picked = await pickProvider(t("menu.metadataProvider"));

package/dist/targets/claudecode.js

@@ -14,6 +14,8 @@ export const claudecode = transactionalTarget({
     id: "claude",
     name: "Claude Code",
     protocols: ["anthropic"],
+    // The env block names one endpoint: a second provider replaces the first rather than joining it.
+    singleProvider: true,
     get configPaths() {
         return [claudeSettingsFile()];
     },

package/dist/targets/dsh.js

@@ -5,7 +5,7 @@ import { dshCredentialsFile, dshDir, dshSettingsFile } from "../app-paths.js";
 import { isManagedCredentialRef, legacyManagedCredentialRef, managedCredentialRef } from "../provider-identity.js";
 import { transactionalTarget } from "../target-transaction.js";
 import { parseYamlMapping, serializeYamlMapping } from "../yaml.js";
-import { apiValue, classifyApi, entryApi, mergeModels, sdkBaseUrl } from "./wire.js";
+import { apiValue, classifyApi, entryApi, hasModelMetadata, mergeModels, sdkBaseUrl } from "./wire.js";
 /** Layout version of `.credentials.yaml` this build reads and writes. */
 const CREDENTIALS_VERSION = 1;
 /** Thinking levels a `reasoningEfforts` entry may offer (llm-pi-ai THINKING_LEVEL_GATE). */
@@ -29,7 +29,8 @@ function modelEntry(m) {
         ...(m.name ? { name: m.name } : {}),
         ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
         ...(m.maxOutput ? { maxTokens: m.maxOutput } : {}),
-        input: m.imageInput ? ["text", "image"] : ["text"],
+        // `input` is a guess for a spec that says nothing; see hasModelMetadata.
+        ...(hasModelMetadata(m) ? { input: m.imageInput ? ["text", "image"] : ["text"] } : {}),
         ...(m.reasoning === false
             ? { reasoningEfforts: false }
             : m.reasoning && m.reasoningEfforts?.length

package/dist/targets/omp.js

@@ -5,9 +5,7 @@ import { ompAgentDir, ompModelsFiles } from "../app-paths.js";
 import { looksLikeEnvName } from "../slug.js";
 import { transactionalTarget } from "../target-transaction.js";
 import { parseYamlMapping, serializeYamlMapping } from "../yaml.js";
-import { apiValue, classifyApi, entryApi, mergeModels, sdkBaseUrl, stripConflictingOverrides } from "./wire.js";
-/** Per-model keys this adapter writes; one that stops being emitted is cleared, not inherited. */
-const OWNED_MODEL_KEYS = ["id", "name", "reasoning", "input", "contextWindow", "maxTokens", "cost"];
+import { apiValue, applyDeepseekCompat, classifyApi, entryApi, mergeModels, OWNED_MODEL_METADATA_KEYS, ownedModelMetadata, sdkBaseUrl, stripConflictingOverrides, } from "./wire.js";
 /** omp has no directory override; the file set is shared with remove/rename. */
 function modelFiles() {
     const [yml, yaml] = ompModelsFiles();
@@ -43,27 +41,12 @@ export const omp = transactionalTarget({
         const anthropic = provider.protocol === "anthropic";
         const api = apiValue(provider.protocol, provider.openaiApi, prev?.api ?? entryApi(prev ?? {}));
         const baseUrl = sdkBaseUrl(provider.protocol, provider.baseUrl);
-        const models = mergeModels(prev?.models, provider.models.map((m) => ({
-            id: m.id,
-            ...(m.name ? { name: m.name } : {}),
-            ...(m.reasoning !== undefined ? { reasoning: m.reasoning } : {}),
-            input: m.imageInput ? ["text", "image"] : ["text"],
-            ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
-            ...(m.maxOutput ? { maxTokens: m.maxOutput } : {}),
-            ...(m.cost
-                ? {
-                    cost: {
-                        input: m.cost.input ?? 0,
-                        output: m.cost.output ?? 0,
-                        cacheRead: m.cost.cacheRead ?? 0,
-                        cacheWrite: m.cost.cacheWrite ?? 0,
-                    },
-                }
-                : {}),
-        })), OWNED_MODEL_KEYS);
+        const models = mergeModels(prev?.models, provider.models.map(ownedModelMetadata), OWNED_MODEL_METADATA_KEYS);
         const conflicts = stripConflictingOverrides(models, api, baseUrl);
         if (conflicts.length)
             notes.push(`dropped model overrides pointing elsewhere: ${conflicts.join(", ")}`);
+        if (!anthropic)
+            applyDeepseekCompat(models, { requiresReasoningContentForToolCalls: true });
         const entry = {
             baseUrl,
             apiKey: provider.apiKey, // omp treats value as env-var name first, then literal

package/dist/targets/pistyle.js

@@ -5,18 +5,9 @@ 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 { apiValue, classifyApi, entryApi, mergeModels, sdkBaseUrl, stripConflictingOverrides } from "./wire.js";
-/** Per-model keys this adapter writes; one a metadata-bearing entry stops emitting is cleared, not inherited. */
-const OWNED_MODEL_KEYS = [
-    "id",
-    "name",
-    "reasoning",
-    "thinkingLevelMap",
-    "input",
-    "contextWindow",
-    "maxTokens",
-    "cost",
-];
+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"];
 function readModels(file) {
     const document = readJsoncObject(file);
     const providers = document.value.providers;
@@ -84,26 +75,17 @@ export function piStyleTarget(opts) {
             const api = apiValue(provider.protocol, provider.openaiApi, prev.api ?? entryApi(prev));
             const baseUrl = sdkBaseUrl(provider.protocol, provider.baseUrl);
             const models = mergeModels(prev.models, provider.models.map((m) => ({
-                id: m.id,
-                ...(m.name ? { name: m.name } : {}),
-                ...(m.reasoning !== undefined ? { reasoning: m.reasoning } : {}),
+                ...ownedModelMetadata(m),
                 ...(m.reasoning && m.reasoningEfforts?.length
                     ? { thinkingLevelMap: thinkingLevelMap(m.reasoningEfforts) }
                     : {}),
-                input: m.imageInput ? ["text", "image"] : ["text"],
-                ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
-                ...(m.maxOutput ? { maxTokens: m.maxOutput } : {}),
-                ...(m.cost
-                    ? {
-                        cost: {
-                            input: m.cost.input ?? 0,
-                            output: m.cost.output ?? 0,
-                            cacheRead: m.cost.cacheRead ?? 0,
-                            cacheWrite: m.cost.cacheWrite ?? 0,
-                        },
-                    }
-                    : {}),
             })), OWNED_MODEL_KEYS);
+            // pi/prime key their DeepSeek wire rules by provider name, so a gateway
+            // entry never picks them up; the flags below are what their own deepseek
+            // catalog entries carry. Anthropic-wire entries replay differently.
+            if (provider.protocol === "openai") {
+                applyDeepseekCompat(models, { requiresReasoningContentOnAssistantMessages: true, thinkingFormat: "deepseek" });
+            }
             const conflicts = stripConflictingOverrides(models, api, baseUrl);
             if (conflicts.length)
                 notes.push(`dropped model overrides pointing elsewhere: ${conflicts.join(", ")}`);

package/dist/targets/wire.js

@@ -99,6 +99,11 @@ derived = ["input"]) {
         const old = prev.get(m.id);
         if (!old)
             return m;
+        // An entry that carries nothing but its id says nothing about the model: it
+        // is no evidence that the config's metadata went stale, so clearing owned
+        // keys on its behalf would delete what a richer sync or the user put there.
+        if (Object.keys(m).length === 1)
+            return { ...m, ...old };
         const kept = { ...old };
         const known = informative.some((key) => key in m);
         if (known)
@@ -108,6 +113,66 @@ derived = ["input"]) {
         return { ...kept, ...m };
     });
 }
+/** Per-model keys every pi-family adapter owns; see `ownedModelMetadata`. */
+export const OWNED_MODEL_METADATA_KEYS = ["id", "name", "reasoning", "input", "contextWindow", "maxTokens", "cost"];
+const DEEPSEEK_MODEL_ID = /deepseek/i;
+/**
+ * omp/pi/prime key their DeepSeek wire rules by provider name ("deepseek",
+ * "opencode-go", ...), so a gateway or reseller entry matches none of them: its
+ * reasoning replay then breaks and DeepSeek answers 400. Match on the model id
+ * instead and write the adapter's own flags per model; an explicit user value wins.
+ */
+export function applyDeepseekCompat(models, flags) {
+    for (const model of models) {
+        if (!DEEPSEEK_MODEL_ID.test(String(model.id)))
+            continue;
+        const compat = (model.compat ?? {});
+        model.compat = { ...flags, ...compat };
+    }
+}
+/**
+ * Whether a store entry describes the model at all. A bare id is ignorance,
+ * not a catalog statement, so adapters must not clear what the app config
+ * already holds on its behalf.
+ */
+export function hasModelMetadata(m) {
+    return (m.name !== undefined ||
+        m.reasoning !== undefined ||
+        m.reasoningEfforts !== undefined ||
+        m.imageInput !== undefined ||
+        m.contextWindow !== undefined ||
+        m.maxInput !== undefined ||
+        m.maxOutput !== undefined ||
+        m.cost !== undefined);
+}
+/**
+ * The per-model metadata agentsw writes into a pi-family models config. omp and
+ * the pi/prime adapters share the shape; only the extras around it differ, so
+ * keeping one builder is what stops the two from drifting apart.
+ */
+export function ownedModelMetadata(m) {
+    // `input` is a guess for a spec that says nothing; writing it would make the
+    // entry look authoritative to mergeModels and clear the config's own values.
+    const known = hasModelMetadata(m);
+    return {
+        id: m.id,
+        ...(m.name ? { name: m.name } : {}),
+        ...(m.reasoning !== undefined ? { reasoning: m.reasoning } : {}),
+        ...(known ? { input: m.imageInput ? ["text", "image"] : ["text"] } : {}),
+        ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
+        ...(m.maxOutput ? { maxTokens: m.maxOutput } : {}),
+        ...(m.cost
+            ? {
+                cost: {
+                    input: m.cost.input ?? 0,
+                    output: m.cost.output ?? 0,
+                    cacheRead: m.cost.cacheRead ?? 0,
+                    cacheWrite: m.cost.cacheWrite ?? 0,
+                },
+            }
+            : {}),
+    };
+}
 /**
  * Drop per-model `api`/`baseUrl` overrides that contradict the route being
  * written. A model-level override wins over the provider entry in omp and pi,

package/dist/targets/workbuddy.js

@@ -6,6 +6,7 @@ import { workbuddyDir } from "../app-paths.js";
 import { localProviderId } from "../provider-identity.js";
 import { providerIdFromBaseUrl, providerNameFromBaseUrl } from "../slug.js";
 import { transactionalTarget } from "../target-transaction.js";
+import { hasModelMetadata } from "./wire.js";
 function configDir() {
     return workbuddyDir();
 }
@@ -101,12 +102,15 @@ export const workbuddy = transactionalTarget({
         const previous = new Map(owned.map((row) => [row.id, row]));
         const ours = provider.models.map((model) => {
             const custom = { ...previous.get(model.id) };
-            for (const key of OWNED_MODEL_KEYS)
-                delete custom[key];
+            // A bare id says nothing about the model; the row keeps what it already has.
+            const known = hasModelMetadata(model);
+            if (known)
+                for (const key of OWNED_MODEL_KEYS)
+                    delete custom[key];
             return {
                 ...custom,
                 id: model.id,
-                name: model.name ?? model.id,
+                name: model.name ?? (known ? undefined : custom.name) ?? model.id,
                 vendor: provider.name,
                 url,
                 apiKey: provider.apiKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsw",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "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": {