agentsw 0.10.0 → 0.10.1

package/README.md

@@ -115,7 +115,7 @@ dsh       yes    openai+anthropic  myproxy · glm-5.3-flash                 ~/.d
 | [prime-agent](https://github.com/PrimeIntellect-ai/prime-agent) | `~/.prime/agent/models.json` + `settings.json` | both |
 | [opencode](https://opencode.ai) | `~/.config/opencode/opencode.json`, `.jsonc` or `config.json` (the one that exists; comments preserved) | both |
 | [Hermes](https://pypi.org/project/hermes-agent/) | `~/.hermes/config.yaml` + `.env` (comments preserved) | both |
-| WorkBuddy | `~/.workbuddy/models.json` + `settings.json` | openai |
+| WorkBuddy | `~/.workbuddy/models.json` + `settings.json` (`%APPDATA%\workbuddy` on Windows) | openai |
 | [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) | `~/.dsh/settings.yaml` + `.credentials.yaml` | both |
 
 An agent that is not installed is skipped, not guessed at. `--apps codex,omp` narrows a run;
@@ -242,7 +242,9 @@ Import still skips already configured accounts.
   `refresh --provider <id> --metadata-mode on` to request fresh reference prices.
 - **Auditable and optional:** `metadata.fields` records origins, value snapshots and timestamps;
   `metadata.conflicts` records disagreements with retained values. This audit stays in agentsw, never runtime agent configs.
-  Gateway has a separate 24-hour cache; failures use stale cached data or skip supplementation.
+  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.
@@ -352,7 +354,10 @@ are unaffected.
 - A sync overwrites only the fields agentsw owns. Unmodeled provider-level keys and per-model
   extras survive; an owned field that stops applying is cleared rather than left stale, and a
   per-model `api`/`baseUrl` override that contradicts the route is dropped (it would silently
-  win over the entry) and reported.
+  win over the entry) and reported. Clearing needs the entry to say something in the first
+  place: a model the store knows nothing about — an id no catalog row matched — is written as
+  an id and its capabilities alone, and the limits already in the file are kept rather than
+  deleted.
 - YAML configs (omp, Hermes, dsh) keep their comments. `~/.codex/config.toml` does not —
   TOML round-trip drops them, which is why the backup happens first.
 - OpenAI endpoints come in two wires: `/v1/chat/completions` and `/v1/responses`. Imported

package/README.zh-CN.md

@@ -110,7 +110,7 @@ dsh       yes    openai+anthropic  myproxy · glm-5.3-flash                 ~/.d
 | [prime-agent](https://github.com/PrimeIntellect-ai/prime-agent) | `~/.prime/agent/models.json` + `settings.json` | 双协议 |
 | [opencode](https://opencode.ai) | `~/.config/opencode/` 下已存在的 `opencode.json`、`.jsonc` 或 `config.json`（保留注释） | 双协议 |
 | [Hermes](https://pypi.org/project/hermes-agent/) | `~/.hermes/config.yaml` + `.env`（保留注释） | 双协议 |
-| WorkBuddy | `~/.workbuddy/models.json` + `settings.json` | openai |
+| WorkBuddy | `~/.workbuddy/models.json` + `settings.json`(Windows 下为 `%APPDATA%\workbuddy`) | openai |
 | [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh) | `~/.dsh/settings.yaml` + `.credentials.yaml` | 双协议 |
 
 未安装的应用会被跳过，而不是瞎猜。`--apps codex,omp` 只跑指定应用；
@@ -227,7 +227,9 @@ asw sync --provider myproxy
   自动模式不会仅为刷新参考价格而查询：可查看 `metadata.gateway.fetchedAt` 判断快照时间，
   需要重新查询参考价格时使用 `refresh --provider <id> --metadata-mode on`。
 - **可追溯、可降级：** `metadata.fields` 记录来源、原值快照和时间，`metadata.conflicts` 记录保留值与冲突。
-  审计信息仅保存在 agentsw，不写入智能体运行配置。Gateway 目录独立缓存 24 小时；请求失败可使用旧缓存，无缓存时只跳过补充。
+  审计信息仅保存在 agentsw，不写入智能体运行配置。Gateway 目录独立缓存 24 小时；请求失败会先重试一次，
+  仍失败才使用旧缓存，无缓存时只跳过补充。`AGENTSW_DEBUG=1` 会说明该次尝试失败的原因，
+  `AGENTSW_GATEWAY_TIMEOUT_MS` 可覆盖默认 15 秒的整体请求预算。
 - **自动查询不等于自动同步：** 添加、快速添加、发现、导入、刷新时补全保存的元数据，并不新增自动推送。
   同步行为不变：普通 `sync` 仅写入已保存的设置，既不获取模型列表，也不请求元数据目录。
 
@@ -330,6 +332,8 @@ JSON 载荷一律不含凭据；`--json --dry-run` 只报告将要改动的文
 - 同步只覆盖 agentsw 自己管理的字段：未建模的供应商级键与模型级扩展字段保留；
   自己管理但本次不再写出的字段会被清除而非留成陈旧值；与新路由矛盾的模型级
   `api`/`baseUrl` 覆盖会被删除（否则它会静默盖过供应商条目）并在输出中点名。
+  但"清除"要求这一条本身说了点什么：store 完全不认识的模型（没有任何目录行匹配到的 id）
+  只带 id 和能力写入，文件里已有的上下文长度等参数会保留而不是被删掉。
 - YAML 配置（omp、Hermes、dsh）保留注释；`~/.codex/config.toml` 不行——TOML 往返会丢注释，
   所以才先备份。
 - OpenAI 端点有两种接口形态：`/v1/chat/completions` 与 `/v1/responses`。导入时沿用配置里

package/dist/gateway.js

@@ -7,6 +7,13 @@ const API_URL = "https://ai-gateway.vercel.sh/v1/models";
 const CACHE_FILE = path.join(configDir, "ai-gateway.json");
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_BODY_BYTES = 5 * 1024 * 1024;
+/** Whole-request budget. A cold handshake through a tunnel measures ~3s here, so this is generous. */
+const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_ATTEMPTS = 2;
+const RETRY_DELAY_MS = 300;
+/** The endpoint answered — a status, an oversize body, a missing one. A retry repeats the answer. */
+class DefinitiveFailure extends Error {
+}
 const REASONING_EFFORTS = {
     none: true, minimal: true, low: true, medium: true, high: true, xhigh: true, max: true,
 };
@@ -137,10 +144,10 @@ async function readResponseBody(response) {
     const contentLength = response.headers.get("content-length");
     if (contentLength !== null && Number(contentLength) > MAX_BODY_BYTES) {
         await response.body?.cancel().catch(() => { });
-        throw new Error("AI Gateway catalog exceeds size limit");
+        throw new DefinitiveFailure("AI Gateway catalog exceeds size limit");
     }
     if (!response.body)
-        throw new Error("Missing AI Gateway catalog body");
+        throw new DefinitiveFailure("Missing AI Gateway catalog body");
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     const chunks = [];
@@ -152,7 +159,7 @@ async function readResponseBody(response) {
                 break;
             size += value.byteLength;
             if (size > MAX_BODY_BYTES)
-                throw new Error("AI Gateway catalog exceeds size limit");
+                throw new DefinitiveFailure("AI Gateway catalog exceeds size limit");
             chunks.push(decoder.decode(value, { stream: true }));
         }
         chunks.push(decoder.decode());
@@ -166,6 +173,65 @@ async function readResponseBody(response) {
         reader.releaseLock();
     }
 }
+/** Diagnostics for a failure the user cannot otherwise see; opt in with AGENTSW_DEBUG=1. */
+function debug(message) {
+    if (process.env.AGENTSW_DEBUG !== "1")
+        return;
+    warn(message);
+}
+/** One-line reason for a failed attempt, for `AGENTSW_DEBUG` only — never part of the warning. */
+function describeFailure(error, timeoutMs) {
+    if (error instanceof Error && error.name === "TimeoutError")
+        return `no response within ${timeoutMs}ms`;
+    const cause = error instanceof Error ? error.cause : undefined;
+    const code = cause && typeof cause === "object" && "code" in cause ? ` (${String(cause.code)})` : "";
+    return `${error instanceof Error ? error.message : String(error)}${code}`;
+}
+/**
+ * Whole-request budget, overridable with `AGENTSW_GATEWAY_TIMEOUT_MS`. An unusable value is
+ * ignored rather than fatal: this is an escape hatch for a slow route, not configuration.
+ */
+function timeoutMs() {
+    const raw = process.env.AGENTSW_GATEWAY_TIMEOUT_MS;
+    if (raw === undefined)
+        return DEFAULT_TIMEOUT_MS;
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 ? value : DEFAULT_TIMEOUT_MS;
+}
+async function requestOnce(budget) {
+    const response = await fetch(API_URL, {
+        signal: AbortSignal.timeout(budget),
+        credentials: "omit",
+        redirect: "error",
+    });
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => { });
+        throw new DefinitiveFailure(`HTTP ${response.status}`);
+    }
+    return readResponseBody(response);
+}
+/**
+ * Read the catalog text, retrying once when the attempt failed before the endpoint could
+ * answer. The likeliest failure by far is a transient one: a cold TLS handshake over whatever
+ * route this machine has measures an order of magnitude slower than a warm one, so a stall or a
+ * reset is far more common than a bad answer. A `DefinitiveFailure` is not retried — the second
+ * request would only repeat it — and neither is a body that arrived but would not parse, which
+ * is why parsing stays outside this call.
+ */
+async function requestCatalogText() {
+    const budget = timeoutMs();
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await requestOnce(budget);
+        }
+        catch (error) {
+            if (error instanceof DefinitiveFailure || attempt >= MAX_ATTEMPTS)
+                throw error;
+            debug(`AI Gateway attempt ${attempt} failed (${describeFailure(error, budget)}); retrying`);
+            await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+        }
+    }
+}
 /** Optional supplement: offline never fetches, and every failure leaves discovery usable. */
 export async function loadGatewayCatalog(opts = {}) {
     const cached = readCache();
@@ -174,16 +240,7 @@ export async function loadGatewayCatalog(opts = {}) {
     if (!opts.refresh && cached && Date.now() - Date.parse(cached.fetchedAt) < CACHE_TTL_MS)
         return cached;
     try {
-        const response = await fetch(API_URL, {
-            signal: AbortSignal.timeout(15_000),
-            credentials: "omit",
-            redirect: "error",
-        });
-        if (!response.ok) {
-            await response.body?.cancel().catch(() => { });
-            throw new Error("AI Gateway catalog request failed");
-        }
-        const body = JSON.parse(await readResponseBody(response));
+        const body = JSON.parse(await requestCatalogText());
         const catalog = parseGatewayCatalog(body, new Date().toISOString());
         try {
             writeFileAtomic(CACHE_FILE, JSON.stringify({ version: 1, fetchedAt: catalog.fetchedAt, body }) + "\n", 0o600);
@@ -193,7 +250,8 @@ export async function loadGatewayCatalog(opts = {}) {
         }
         return catalog;
     }
-    catch {
+    catch (error) {
+        debug(`AI Gateway metadata unavailable: ${describeFailure(error, timeoutMs())}`);
         warn(cached
             ? "could not refresh AI Gateway metadata; using cached metadata"
             : "could not load AI Gateway metadata");

package/dist/metadata.js

@@ -116,7 +116,10 @@ function indexCatalog(catalog) {
     for (const provider of Object.values(catalog)) {
         for (const [key, model] of Object.entries(provider.models)) {
             const modelId = model.id.includes("/") ? model.id : `${provider.id}/${model.id}`;
-            const entry = { provider: provider.id, modelId, identity: model.canonical_model_id ?? modelId, model };
+            const entry = {
+                provider: provider.id, modelId, identity: model.canonical_model_id ?? modelId,
+                claimed: model.canonical_model_id !== undefined, model,
+            };
             for (const id of new Set([key, model.id]))
                 push(exact, id, entry);
             push(canonical, modelId, entry);
@@ -125,10 +128,29 @@ function indexCatalog(catalog) {
     }
     return { exact, canonical, identities };
 }
+/**
+ * The identities a group of catalog rows stands for.
+ *
+ * Only `canonical_model_id` is evidence. Counting the fallback guess of a row
+ * that declares nothing would let one sloppy reseller row invent a second
+ * creator and block an otherwise unique match — the id then reports as
+ * ambiguous even though every row that does carry the field names one model.
+ * A group where *nothing* declares an identity is a different situation: there
+ * is no primary evidence to weigh, so the listings' own ids are all the group
+ * can be held to, which is exactly the conservative answer. An empty group
+ * stays empty — that is "no evidence at all", not "one guess".
+ */
+function claimIdentities(entries) {
+    const list = entries ?? [];
+    const claimed = new Set(list.filter((entry) => entry.claimed).map((entry) => entry.identity));
+    if (claimed.size)
+        return claimed;
+    return new Set(list.map((entry) => entry.identity));
+}
 /** Creator identity of a catalog model id, or undefined when its rows disagree. */
 function catalogIdentity(index, modelId) {
-    const identities = new Set(index?.canonical.get(modelId)?.map((entry) => entry.identity));
-    return identities?.size === 1 ? [...identities][0] : undefined;
+    const identities = claimIdentities(index?.canonical.get(modelId));
+    return identities.size === 1 ? [...identities][0] : undefined;
 }
 /**
  * The creator's own listing for an identity, when models.dev carries one.
@@ -164,7 +186,7 @@ function selectExact(index, id, hint, aliases, gateway, gatewayBareIds) {
             const candidate = gatewayBareIds?.get(id);
             const evidence = index?.exact.get(id);
             const hintedEvidence = hint ? evidence?.filter((entry) => entry.provider === hint) : undefined;
-            const identities = new Set((hintedEvidence?.length ? hintedEvidence : evidence)?.map((entry) => entry.identity));
+            const identities = claimIdentities(hintedEvidence?.length ? hintedEvidence : evidence);
             // Gateway names the creator while models.dev names the listing provider, so
             // the two agree only once both are reduced to a creator identity. A gateway
             // id the catalog has no row for stands for itself.
@@ -181,7 +203,7 @@ function selectExact(index, id, hint, aliases, gateway, gatewayBareIds) {
         : (bare && hint ? index?.canonical.get(`${hint}/${id}`) : undefined)
             ?? index?.canonical.get(id) ?? index?.exact.get(id);
     const hinted = candidates?.find((entry) => entry.provider === hint);
-    const identities = new Set(candidates?.map((entry) => entry.identity));
+    const identities = claimIdentities(candidates);
     // Reseller rows for one model share an identity but disagree on limits and
     // prices, so only the creator's own row is authoritative.
     const primary = hinted ?? (identities.size === 1 ? creatorEntry(index, [...identities][0]) : undefined);
@@ -440,10 +462,13 @@ export function classifyUnresolved(catalog, ids, hint) {
         const candidates = hinted ?? index.canonical.get(id) ?? index.exact.get(id);
         if (!candidates?.length)
             unknown.push(id);
-        else if (new Set(candidates.map((entry) => entry.identity)).size > 1)
-            ambiguous.push(id);
-        else if (!creatorEntry(index, [...new Set(candidates.map((entry) => entry.identity))][0]))
-            noCreatorRow.push(id);
+        else {
+            const identities = claimIdentities(candidates);
+            if (identities.size > 1)
+                ambiguous.push(id);
+            else if (!creatorEntry(index, [...identities][0]))
+                noCreatorRow.push(id);
+        }
     }
     return { ambiguous, unknown, noCreatorRow };
 }

package/dist/targets/dsh.js

@@ -10,7 +10,7 @@ import { apiValue, classifyApi, entryApi, mergeModels, sdkBaseUrl } from "./wire
 const CREDENTIALS_VERSION = 1;
 /** Thinking levels a `reasoningEfforts` entry may offer (llm-pi-ai THINKING_LEVEL_GATE). */
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-/** Per-model keys this adapter writes; one that stops being emitted is cleared, not inherited. */
+/** Per-model keys this adapter writes; one a metadata-bearing entry stops emitting is cleared, not inherited. */
 const OWNED_MODEL_KEYS = ["id", "name", "contextWindow", "maxTokens", "input", "reasoningEfforts"];
 /** models.dev efforts -> `{ level: wire spelling }`; an unoffered level is omitted, not nulled. */
 function reasoningEfforts(efforts) {

package/dist/targets/pistyle.js

@@ -6,7 +6,7 @@ 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 that stops being emitted is cleared, not inherited. */
+/** Per-model keys this adapter writes; one a metadata-bearing entry stops emitting is cleared, not inherited. */
 const OWNED_MODEL_KEYS = [
     "id",
     "name",

package/dist/targets/wire.js

@@ -69,12 +69,24 @@ export function entryApi(entry) {
 /**
  * Merge the model entries agentsw owns over the ones already in an app
  * config: per-model keys the adapter does not model (`compat`, per-model wire
- * overrides, ...) survive a re-sync, while an `owned` key the new entry no
- * longer carries is cleared instead of lingering as last sync's value — a
- * stale `thinkingLevelMap` beside `reasoning: false` is a state no fresh write
+ * overrides, ...) survive a re-sync, and an `owned` key the entry omits is
+ * cleared rather than lingering as last sync's value — a stale
+ * `thinkingLevelMap` beside `reasoning: false` is a state no fresh write
  * produces.
+ *
+ * That clearing is only meaningful for an entry that carries metadata at all.
+ * A model the store knows nothing about arrives as a bare `{ id }` — that is
+ * exactly what enrichment does with an id no catalog row matched — and every
+ * adapter still adds the derived capability in `derived`. Absence in such a
+ * stub says nothing about the model, so the config's existing values are kept:
+ * deleting them would throw away limits an earlier lookup filled in, or that a
+ * person typed by hand, every time a catalog lookup misses. Once an entry
+ * carries any owned metadata of its own, the same absence is a statement about
+ * the model and is applied as before.
  */
-export function mergeModels(previous, written, owned) {
+export function mergeModels(previous, written, owned, 
+/** Owned keys every adapter derives instead of reading them from the model. */
+derived = ["input"]) {
     const prev = new Map();
     if (Array.isArray(previous)) {
         for (const m of previous) {
@@ -82,14 +94,17 @@ export function mergeModels(previous, written, owned) {
                 prev.set(m.id, m);
         }
     }
+    const informative = owned.filter((key) => key !== "id" && !derived.includes(key));
     return written.map((m) => {
         const old = prev.get(m.id);
         if (!old)
             return m;
         const kept = { ...old };
-        for (const key of owned)
-            if (!(key in m))
-                delete kept[key];
+        const known = informative.some((key) => key in m);
+        if (known)
+            for (const key of owned)
+                if (!(key in m))
+                    delete kept[key];
         return { ...kept, ...m };
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsw",
-  "version": "0.10.0",
+  "version": "0.10.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": {