@liustack/modlens 3.25.4 → 3.26.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 3.26.1 - 2026-09-08
+
+- **dsh paste-to-path writes into the Lexical composer ([#100](https://github.com/liustack/modlens/issues/100)).** dsh 0.1.2-rc.1 replaced the composer textarea with a Lexical contenteditable div. The paste listener still uploaded the image, then `insertText` returned immediately because it only accepted `TEXTAREA` and `INPUT`, so the path never landed and the console stayed quiet. Paste-to-path now resolves a writable target (textarea, input, or `[data-composer-input][contenteditable=true]`) before taking the event, inserts with `execCommand`, and logs the path if that insert fails. Thanks to @xp1205700819-sudo.
+
+## 3.26.0 - 2026-09-06
+
+- **Opt-in vision twins for other text models ([#98](https://github.com/liustack/modlens/issues/98)).** Set `families: ['*']` in the dsh plugin configuration to include models outside the default DeepSeek, GLM and MiMo families. Wildcard matches require explicit text input metadata and reject native image input, unknown capabilities and the existing native-vision exclusions. Default discovery and explicit family prefixes are unchanged. The bilingual harness guide documents the exact profile override, provider filtering and the native attachment flow. Third-party DeepSeek routes already work with default discovery ([#95](https://github.com/liustack/modlens/issues/95)).
+- **Per-provider proxy routing and dsh settings ([#97](https://github.com/liustack/modlens/issues/97)).** An API provider can now inherit the shared proxy, connect directly, or use its own proxy. The dsh settings card exposes all three choices and keeps stored proxy credentials on the host. A direct provider remains reachable when a shared proxy fails. Provider failover itself is unchanged.
+- **Compatibility:** an explicitly empty provider proxy, such as `providers.openai.proxy: ""`, now means direct connection and ignores the global and environment proxies. Earlier releases treated it as inheritance. To keep inheriting, remove that provider's `proxy` field or choose the inherited route in the dsh settings card. A missing field and a non-empty proxy URL retain their previous behavior. Update ModLens in every harness sharing the config before using the direct setting.
+- **skills.sh installation.** Both READMEs and the installation guide include `npx -y skills add liustack/modlens --skill modlens --global` for installing the skill at user level.
+
 ## 3.25.4 - 2026-09-01
 
 - **openai-compat requests say `stream: false` out loud ([#94](https://github.com/liustack/modlens/issues/94)).** The OpenAI spec defaults `stream` to false when the field is absent, but some self-hosted and regional gateways default the other way and answer an SSE body, which `response.json()` rejects with `Unexpected token 'd', "data:{"id""... is not valid JSON` — making modlens unusable against such a gateway. The request body now carries `stream: false` explicitly, so the response is plain JSON regardless of what the gateway assumes. The field was already on `mergeExtraBody`'s reserved list, so `extraBody` could never override it; it just was never actually sent. Thanks to @moyi497475207 for a report that arrived with curl proof of the gateway's behavior and the exact one-line patch.

package/README.md

@@ -33,7 +33,7 @@ Issues are welcome any time: [open one](https://github.com/liustack/modlens/issu
 
 ## Highlights
 
-**🥇 The most capable vision plugin for DeepSeek Harness (dsh):** install it instantly with one command: `npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.25.4`. See the [setup guide](docs/harness-setup.md) for installation and update details. If the command line is not your thing but you still want to try DSH, check out <a href="https://github.com/liustack/aimanager"><b>AIManager</b></a>, the lightest desktop wrapper for DeepSeek Harness. It gets you started with zero code or configuration and installs every dependency for you with one click.
+**🥇 The most capable vision plugin for DeepSeek Harness (dsh):** install it instantly with one command: `npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.26.1`. See the [setup guide](docs/harness-setup.md) for installation and update details. If the command line is not your thing but you still want to try DSH, check out <a href="https://github.com/liustack/aimanager"><b>AIManager</b></a>, the lightest desktop wrapper for DeepSeek Harness. It gets you started with zero code or configuration and installs every dependency for you with one click.
 
 Pasting an image works two ways. **① Just paste.** On a text-only model the pasted image lands as a private temp file and its path enters the composer (the same interaction OpenCode and Pi ship), then the `modlens_read_image` tool takes it from there. **② Pick a `(modlens vision)` entry** in the model selector (it remembers your choice, so once is enough), then paste: the thumbnail stays visible in your message, closer to the Codex app feel, and the image is converted to structured evidence at request time, answered by the same underlying route. The plugin auto-discovers every provider route carrying eligible text-only DeepSeek, GLM, or MiMo Pro models and adds a wrapped entry per route. A stock install gets **`DeepSeek-V4-Flash (modlens vision)`** and **`DeepSeek-V4-Pro (modlens vision)`**, while extra routes like opencode-go or zai get their own. Native vision models in those families, including GLM-5.3-Flash, are excluded automatically. Which paste route applies is the host's per-model call: only a model its metadata positively confirms text-only is taken over, anything unconfirmed is left alone, so vision models keep their native paste ([details](docs/harness-setup.md)).
 
@@ -49,13 +49,22 @@ A hotkey that captures the screen into DeepSeek Harness is a separate plugin: [d
 
 ## Install in other harnesses
 
-**Step 1, hand it to your AI.** Send it this line:
+**Option 1, install with [skills.sh](https://skills.sh/):**
+
+```bash
+npx -y skills add liustack/modlens --skill modlens --global
+```
+
+This installs the `modlens` skill at user level. Restart the harness, then ask
+your AI to configure modlens and run its health check.
+
+**Option 2, hand the install to your AI.** Send it this line:
 
 > Install and configure the modlens skill following https://github.com/liustack/modlens/blob/main/INSTALL.md, then run the health check and tell me the result.
 
 The install starts by checking what your machine already has. An existing login in Claude Code, Codex, OpenCode, or Pi can be enough: modlens asks before reusing any of them, and the health check tells you where things stand.
 
-**Step 2, only if the health check comes back empty, set up a free engine.** The recommended choice is a free Gemini API key (about three minutes at [Google AI Studio](https://aistudio.google.com), no credit card), which also makes every read 5-10 seconds. A free OpenAI-compatible key from another platform works too. To avoid any sign-up, install Antigravity CLI instead, then sign in:
+**After either option, only if the health check comes back empty, set up a free engine.** The recommended choice is a free Gemini API key (about three minutes at [Google AI Studio](https://aistudio.google.com), no credit card), which also makes every read 5-10 seconds. A free OpenAI-compatible key from another platform works too. To avoid any sign-up, install Antigravity CLI instead, then sign in:
 
 ```bash
 curl -fsSL https://antigravity.google/cli/install.sh | bash
@@ -117,7 +126,7 @@ Two more sources of vision need zero new keys, each behind one explicit consent
 
 ### Picking and routing
 
-Two knobs: `modlens config set provider <name>` states a preference (the chain still backs it up), `-p <name>` pins exactly one with no fallback. Machines behind a proxy set `HTTPS_PROXY` or `modlens config set proxy <url>` and the API providers route through it. Details: the [CLI manual](docs/cli.md) for defaults and flags, [Configuration](skills/modlens/references/configure.md) for every key, and [Security](docs/security.md) for who fetches what on remote URLs.
+Two knobs: `modlens config set provider <name>` states a preference (the chain still backs it up), `-p <name>` pins exactly one with no fallback. Machines behind a proxy set `HTTPS_PROXY` or `modlens config set proxy <url>` and the API providers route through it. An internal endpoint can opt out with `modlens config set openai.proxy ""`. Details: the [CLI manual](docs/cli.md) for defaults and flags, [Configuration](skills/modlens/references/configure.md) for every key, and [Security](docs/security.md) for who fetches what on remote URLs.
 
 ## See it work
 

package/README.zh-CN.md

@@ -33,7 +33,7 @@ DeepSeek 的主力对话模型和 GLM-5.3 本体仍是纯文本，无法读图
 
 ## 亮点
 
-**🥇 全网最强的 DeepSeek Harness（dsh）外挂视觉识别插件：**一条命令即刻安装 `npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.25.4`。更多安装与更新细节参考 [配置手册](docs/harness-setup.zh-CN.md) 。如果用不惯命令行，也想想玩玩 DSH，推荐食用全网最轻量级的 DeepSeek Harness 桌面版封装 <a href="https://github.com/liustack/aimanager"><b> AIManager</b></a>，零代码零配置起手，一键帮你安装所有依赖环境。
+**🥇 全网最强的 DeepSeek Harness（dsh）外挂视觉识别插件：**一条命令即刻安装 `npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.26.1`。更多安装与更新细节参考 [配置手册](docs/harness-setup.zh-CN.md) 。如果用不惯命令行，也想想玩玩 DSH，推荐食用全网最轻量级的 DeepSeek Harness 桌面版封装 <a href="https://github.com/liustack/aimanager"><b> AIManager</b></a>，零代码零配置起手，一键帮你安装所有依赖环境。
 
 DeepSeek Harness 粘贴识图有两种玩法。
 
@@ -53,13 +53,22 @@ DeepSeek Harness 粘贴识图有两种玩法。
 
 ## 在其他 Harness 中安装
 
-**第一步，交给你的 AI。** 把这句话发给它：
+**方式一，通过 [skills.sh](https://skills.sh/) 一条命令安装：**
+
+```bash
+npx -y skills add liustack/modlens --skill modlens --global
+```
+
+这会把 `modlens` skill 安装到用户级目录。重启 Harness 后，让 AI 配置
+modlens 并运行体检即可。
+
+**方式二，把安装交给你的 AI。** 把这句话发给它：
 
 > 按 https://github.com/liustack/modlens 的 INSTALL.md 安装并配置 modlens skill，完成后运行体检并把结果告诉我。
 
 安装会先盘点你机器上已有的东西。Claude Code、Codex、OpenCode 或 Pi 里任何一个已有的登录态都可能就够了：modlens 复用前一定先征得你同意，体检报告会说清现状。
 
-**第二步，只在体检两手空空时，才需要你配一个免费引擎。** 推荐免费的 Gemini api key（到 [Google AI Studio](https://aistudio.google.com) 领取，约三分钟，无需信用卡），配上后每次识别 5 到 10 秒。其他平台的免费 openai 兼容 key 也行。想完全免注册就装 Antigravity CLI，然后完成登录：
+**两种方式完成后，只在体检两手空空时，才需要你配一个免费引擎。** 推荐免费的 Gemini api key（到 [Google AI Studio](https://aistudio.google.com) 领取，约三分钟，无需信用卡），配上后每次识别 5 到 10 秒。其他平台的免费 openai 兼容 key 也行。想完全免注册就装 Antigravity CLI，然后完成登录：
 
 ```bash
 curl -fsSL https://antigravity.google/cli/install.sh | bash
@@ -71,7 +80,7 @@ agy                                                           # 浏览器完成
 **DeepSeek Harness（dsh）用户不走 skill 流程**，本包就是原生 dsh 插件：
 
 ```sh
-npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.25.4
+npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.26.1
 ```
 
 装完即有 `modlens_read_image` 工具，选「(modlens vision)」模型变体即可直接粘贴识图。引擎配置同样在 `~/.modlens`，详见[宿主接入](docs/harness-setup.zh-CN.md)。
@@ -129,7 +138,7 @@ modlens config set openai.model   qwen3-vl-plus
 
 ### 选择与路由
 
-两个旋钮：`modlens config set provider <name>` 表达偏好（链继续兜底），`-p <name>` 钉死单个不回退。代理环境设 `HTTPS_PROXY` 或 `modlens config set proxy <url>`，API provider 自动走代理。细节见 [CLI 手册](docs/cli.zh-CN.md)（默认模型与参数）、[配置手册](skills/modlens/references/configure.zh-CN.md)（全部配置键）、[安全说明](docs/security.zh-CN.md)（远程 URL 由谁抓取）。
+两个旋钮：`modlens config set provider <name>` 表达偏好（链继续兜底），`-p <name>` 钉死单个不回退。代理环境设 `HTTPS_PROXY` 或 `modlens config set proxy <url>`，API provider 自动走代理。内网端点可用 `modlens config set openai.proxy ""` 单独改为直连。细节见 [CLI 手册](docs/cli.zh-CN.md)（默认模型与参数）、[配置手册](skills/modlens/references/configure.zh-CN.md)（全部配置键）、[安全说明](docs/security.zh-CN.md)（远程 URL 由谁抓取）。
 
 ## 实测
 

package/dist/main.js

@@ -443,9 +443,9 @@ async function readCapped(response, url) {
   return Buffer.concat(chunks);
 }
 function apiProxyDispatcher(explicitProxy, env) {
-  const proxy = explicitProxy?.trim();
-  if (proxy) {
-    return new ProxyAgent(proxy);
+  if (explicitProxy !== void 0) {
+    const proxy = explicitProxy.trim();
+    return proxy ? new ProxyAgent(proxy) : void 0;
   }
   if (env.HTTPS_PROXY || env.https_proxy || env.HTTP_PROXY || env.http_proxy) {
     return new EnvHttpProxyAgent();
@@ -1779,7 +1779,7 @@ function providerConfiguredInFile(providerName, config2) {
 function resolveProviderSettings(providerName, config2, env = process.env) {
   const mentioned = providerConfiguredInFile(providerName, config2);
   const settings = mentioned ? { ...fileSettingsFor(providerName, config2) } : envSettingsFor(providerName, env);
-  if (!settings.proxy && typeof config2.proxy === "string" && config2.proxy.trim()) {
+  if (!Object.hasOwn(settings, "proxy") && typeof config2.proxy === "string" && config2.proxy.trim()) {
     settings.proxy = config2.proxy.trim();
   }
   return settings;
@@ -2257,7 +2257,7 @@ function renderEffectiveConfig(config2, env = process.env) {
         fields[field] = `(malformed: not a string) (${source})`;
         continue;
       }
-      const shown = field === "apiKey" ? maskKeys(value) : field === "proxy" ? maskUrlCredentials(guard(value)) : guard(value);
+      const shown = field === "apiKey" ? maskKeys(value) : field === "proxy" ? value.trim() === "" ? "direct" : maskUrlCredentials(guard(value)) : guard(value);
       fields[field] = `${shown} (${source})`;
     }
     if (fileSettings.structuredOutput !== void 0) {
@@ -5562,7 +5562,7 @@ function parsePositiveInt(raw, flag) {
   }
   return Number.parseInt(raw, 10);
 }
-program.name("modlens").description("Plug-in vision for text-only LLMs: image in, structured JSON evidence out").version("3.25.4");
+program.name("modlens").description("Plug-in vision for text-only LLMs: image in, structured JSON evidence out").version("3.26.1");
 program.command("analyze", { isDefault: true }).description("Analyze an image into structured JSON evidence (default command)").requiredOption("-i, --input <path|url>", "Input image path or https URL").option("-o, --output <path>", "Write result JSON to a file").option("-m, --model <name>", "Provider model name").option("-p, --provider <name>", `Vision provider (${listProviders().join(", ")})`).option("--prompt <text>", "Extra focus for this image").option("--timeout <ms>", "Provider timeout in milliseconds", "180000").option("--provider-bin <path>", "Provider binary path (default: agy)").option("--workdir <path>", "Working directory for the provider").option(
   "--extra-body <json>",
   `JSON merged into the API request body, e.g. '{"thinking":{"type":"disabled"}}'`
@@ -5673,7 +5673,7 @@ program.command("doctor").description(
       configPath: CONFIG_PATH,
       // Lets doctor name an installed skill copy that is older than
       // the CLI reporting on it (issue #33).
-      version: "3.25.4"
+      version: "3.26.1"
     });
     const output = options.json ? JSON.stringify(report, null, 2) : renderDoctorReport(report);
     process.stdout.write(`${output}
@@ -5686,7 +5686,7 @@ program.command("doctor").description(
     process.exitCode = 1;
   }
 });
-const config = program.command("config").description(`Manage ${CONFIG_PATH} (providers, keys, models)`);
+const config = program.command("config").description(`Manage ${CONFIG_PATH} (providers, keys, models, proxies)`);
 config.command("init").description(`Create a starter config at ${CONFIG_PATH}`).option("--force", "Overwrite an existing config file").action((options) => {
   try {
     initConfigFile(CONFIG_PATH, Boolean(options.force));
@@ -5696,7 +5696,8 @@ config.command("init").description(`Create a starter config at ${CONFIG_PATH}`).
         "Everything is optional. The usual ones:",
         "  modlens config set provider <name>                      which provider analyzes images",
         "  modlens config set cooldown on|off                       quota cooldown (on by default)",
-        "  modlens config set <provider>.<apiKey|baseUrl|model> <value>   provider settings",
+        "  modlens config set <provider>.<apiKey|baseUrl|model|proxy> <value>   provider settings",
+        '  modlens config set openai.proxy ""                  make one API provider connect directly',
         `  modlens config set <provider>.extraBody '{"thinking":{"type":"disabled"}}'   vendor request fields`,
         ""
       ].join("\n")
@@ -5764,7 +5765,7 @@ config.command("set <key> [value]").description(
     process.exitCode = 1;
   }
 });
-config.command("show").description("Print the effective config (file merged with env vars), API keys masked").action(() => {
+config.command("show").description("Print the effective config (file merged with env vars), credentials masked").action(() => {
   try {
     process.stdout.write(`${renderEffectiveConfig(loadConfigFile())}
 `);

package/docs/cli.md

@@ -98,7 +98,6 @@ Six providers: `antigravity-cli` (no key), `gemini-api` (fastest free route), `o
 Other subcommands:
 
 - `modlens guard [--model <id>]`: should the engine run for the active model at all? Exit 0 allow, 1 deny, verdict as JSON.
-- `modlens config <init|set|show>`: `set` with the value omitted on an `apiKey` field prompts for it with the echo hidden, so the key never enters argv, shell history, or the conversation with an agent driving the terminal. It also accepts one piped line (`pbpaste | modlens config set openai.apiKey`), which keeps the key out of argv, though whatever produced that pipe is still your own command to keep out of history. Keys are `provider`, `proxy` (HTTP/HTTPS proxy for the API providers, `HTTPS_PROXY`/`HTTP_PROXY` also honored), `cooldown` (`on` or `off`, on by default), `reuse.<claude|codex|opencode|pi|grok>`, `guards.<denyModels|allowModels|denyWhenUnknown>`, and `<provider>.<apiKey|baseUrl|model|proxy|extraBody>`, plus `openai.structuredOutput` (that route only). `apiKey` accepts a comma-separated list and rotates after authentication, rate-limit, or quota failures.
+- `modlens config <init|set|show>`: `set` with the value omitted on an `apiKey` field prompts for it with the echo hidden, so the key never enters argv, shell history, or the conversation with an agent driving the terminal. It also accepts one piped line (`pbpaste | modlens config set openai.apiKey`), which keeps the key out of argv, though whatever produced that pipe is still your own command to keep out of history. Keys are `provider`, `proxy` (HTTP/HTTPS proxy for the API providers, `HTTPS_PROXY`/`HTTP_PROXY` also honored), `cooldown` (`on` or `off`, on by default), `reuse.<claude|codex|opencode|pi|grok>`, `guards.<denyModels|allowModels|denyWhenUnknown>`, and `<provider>.<apiKey|baseUrl|model|proxy|extraBody>`, plus `openai.structuredOutput` (that route only). A provider proxy URL overrides the shared route. An explicit empty provider proxy, for example `modlens config set openai.proxy ""`, forces that provider to connect directly. `apiKey` accepts a comma-separated list and rotates after authentication, rate-limit, or quota failures.
 - `modlens state clear`: forget every provider cooldown in `~/.modlens/state.json`, so all providers are tried at full priority again.
 - `modlens doctor`: Node and node:sqlite, provider readiness (including API key counts), the failover chains for this machine, the cooldown switch and any cooling keys, the detected harness, the guard's rules with a live verdict, and the Reuse section with per-harness grant decisions and discovered vision. Spends no quota; `--json` for a machine-readable report.
-

package/docs/cli.zh-CN.md

@@ -95,6 +95,6 @@ modlens recover-paste                           # pull a pasted image into a fil
 其他子命令：
 
 - `modlens guard [--model <id>]`：判断当前激活的模型到底该不该运行引擎。退出码 0 表示放行，1 表示拒绝，判定结果以 JSON 输出。
-- `modlens config <init|set|show>`：`set` 在 `apiKey` 字段上省略值会进入不回显的输入提示，密钥不进 argv、不进 shell 历史，也不进你与终端里那个 agent 的对话。它也接受从管道读一行（`pbpaste | modlens config set openai.apiKey`），这样密钥不进 argv，但产生这条管道的命令本身是否留在历史里，由你自己决定。可用的键有 `provider`、`proxy`（API provider 的 HTTP/HTTPS 代理，也认 `HTTPS_PROXY`/`HTTP_PROXY`）、`cooldown`（`on` 或 `off`，默认打开）、`reuse.<claude|codex|opencode|pi|grok>`、`guards.<denyModels|allowModels|denyWhenUnknown>`，以及 `<provider>.<apiKey|baseUrl|model|proxy|extraBody>`，另有 `openai.structuredOutput`（仅这条路线用得上）。`apiKey` 接受英文逗号分隔的列表，鉴权、限流或配额失败后会轮换。
+- `modlens config <init|set|show>`：`set` 在 `apiKey` 字段上省略值会进入不回显的输入提示，密钥不进 argv、不进 shell 历史，也不进你与终端里那个 agent 的对话。它也接受从管道读一行（`pbpaste | modlens config set openai.apiKey`），这样密钥不进 argv，但产生这条管道的命令本身是否留在历史里，由你自己决定。可用的键有 `provider`、`proxy`（API provider 的 HTTP/HTTPS 代理，也认 `HTTPS_PROXY`/`HTTP_PROXY`）、`cooldown`（`on` 或 `off`，默认打开）、`reuse.<claude|codex|opencode|pi|grok>`、`guards.<denyModels|allowModels|denyWhenUnknown>`，以及 `<provider>.<apiKey|baseUrl|model|proxy|extraBody>`，另有 `openai.structuredOutput`（仅这条路线用得上）。provider 的代理地址会覆盖共享代理。显式传入空值，例如 `modlens config set openai.proxy ""`，会让该 provider 强制直连。`apiKey` 接受英文逗号分隔的列表，鉴权、限流或配额失败后会轮换。
 - `modlens state clear`：忘掉 `~/.modlens/state.json` 里每一条 provider 冷却，让所有 provider 重新按完整优先级尝试。
 - `modlens doctor`：报告 Node 与 node:sqlite、各 provider 的就绪状态（含密钥数量）、本机的故障转移链、冷却开关和正在冷却的密钥、检测到的 harness、guard 规则和一次现场判定，以及 Reuse 一节里按 harness 的授权决定与发现的视觉能力。不花任何额度，`--json` 输出机器可读报告。

package/docs/harness-setup.md

@@ -55,25 +55,75 @@ OpenCode with DeepSeek: `opencode auth login`, pick DeepSeek and paste the key (
 dsh is different from the other harnesses: modlens plugs in as a native tool, not a prompt-triggered skill. The package itself is a dsh bundle, so one command installs it into a profile:
 
 ```sh
-npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.25.4
+npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.26.1
 ```
 
 This registers a `modlens_read_image` tool whose schema reaches the model on every request (no trigger heuristics), runs the modlens CLI shipped inside the same package, and returns the structured evidence as the tool's canonical JSON output. Engines, reuse grants, and guard rules stay in `~/.modlens/config.json`, shared with every other harness. dsh is in developer preview and its plugin surface may change; the plugin keeps its touch small (raw tool registration, the llm adapter surface for the vision variants, the attachment reader, and one agent pre-step hook) and degrades loudly if any of them moves.
 
+### Third-party text models
+
+The vision bridge is not restricted to the official DeepSeek API. By default,
+modlens discovers every registered provider carrying eligible `deepseek`, `glm`
+or `mimo` model IDs, including third-party routes. Select the model under the
+provider group marked `(modlens vision)` to use it. Pasting, dragging an image
+or using dsh's attachment button then follows the host's normal attachment
+flow, with images converted to evidence before the text model is called.
+
+To include other text models, edit the active profile's
+`$DSH_HOME/profiles/<name>/cordis.patch.yml` (`DSH_HOME` defaults to `~/.dsh`).
+Add an override for the installed plugin's existing ID, not another `insert`:
+
+```yaml
+- id: modlens
+  config:
+    families: ['*']
+    discover: ['openrouter', 'nvidia', 'ark-deepseek']
+```
+
+Use the actual registered provider IDs in `discover`, not their display names.
+Omit `discover` to inspect all registered routes. Keep any other patch entries
+already in the file. This is dsh plugin configuration, not
+`~/.modlens/config.json`, which configures the engine reading the image.
+
+`families: ['*']` is opt-in. It requires the upstream model metadata to explicitly
+include `text` in `inputModalities` and exclude `image`. Unknown or empty
+modalities do not qualify. Existing native-vision name exclusions still apply,
+and MiMo still requires a `-pro` segment. Native vision models should declare
+`image` in their upstream configuration and use their original entry.
+
+For a narrower selection, set explicit lowercase model-ID prefixes, for example
+`families: ['deepseek', 'glm', 'mimo', 'ling', 'qwen']`. This replaces the default
+list. Prefixes match both the full model ID and the ID after removing a leading
+`~` and its vendor namespace. Explicit prefixes retain the existing behavior
+when modalities are absent, so use them only for models you know are text-only.
+Declared image input and the native-vision exclusions still veto the wrapper.
+
+Check the composed configuration, restart dsh, then select the wrapper entry:
+
+```sh
+npx -y @deepseek-ai/dsh --profile <name> --dump-config
+```
+
+If a third-party DeepSeek entry is missing, check the plugin version in that
+profile, the actual model ID rather than its display name, any `upstream` or
+`discover` restriction, and the model's declared modalities. A configured
+`upstream` keeps single-route mode instead of discovery.
+
 ### Configuring the engine from the web UI
 
 dsh web users have no terminal in front of them, so the engine settings have a
 card in **Settings → Plugins → Plugin configuration**: which engine reads
-images, its key, endpoint and model, and which local sign-ins a read may
+images, its key, endpoint, model and proxy route, and which local sign-ins a read may
 borrow. Expanding it probes this machine and lists the harnesses it actually
 found, so the grants are a choice between real options rather than five names.
 
 The values live where they always did, in `~/.modlens/config.json`, shared
 with every other harness: the card reads and writes that file through a
 loopback route, so an edit here is the same edit `modlens config set` makes.
-The card never receives a stored key, only whether one is set, and leaving the
-key field empty keeps the stored one. `settingsCard: false` in the plugin row
-removes it, route included.
+The card never receives a stored key or proxy URL, only whether the key is set
+and whether proxy routing inherits, connects directly, or uses a custom URL.
+Leaving either secret field empty keeps the stored value. `settingsCard: false`
+in the plugin row removes it, route included.
 
 The card's own text follows dsh's interface language setting, switching
 between Chinese and English as you switch dsh. On a dsh too old to expose that
@@ -87,7 +137,7 @@ modlens ships often, and both install shapes freeze at whatever version they
 got. On dsh, re-run the install with the version named:
 
 ```sh
-npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.25.4
+npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.26.1
 ```
 
 `npm view @liustack/modlens version` prints the current one, and this page is

package/docs/harness-setup.zh-CN.md

@@ -55,16 +55,59 @@ OpenCode 接 DeepSeek：执行 `opencode auth login`，选择 DeepSeek 并粘贴
 dsh 与其他 harness 不同：modlens 以原生工具的形式接入，而不是靠提示词触发的 skill。本包自身就是一个 dsh bundle，一条命令即可装进某个 profile：
 
 ```sh
-npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.25.4
+npx -y @deepseek-ai/dsh plugin --profile web add @liustack/modlens@3.26.1
 ```
 
 这会注册一个 `modlens_read_image` 工具，它的 schema 随每次请求抵达模型（不靠触发启发式），运行同一个包里自带的 modlens CLI，并把结构化证据作为工具的标准 JSON 输出返回。引擎、复用授权和 guard 规则仍在 `~/.modlens/config.json` 里，与其他所有 harness 共享。dsh 还在开发者预览阶段，插件接口可能变化。这个插件刻意保持很小的接触面（原生工具注册、视觉变体所用的 llm 适配层、附件读取器，以及一个 agent 执行前钩子），其中任何一处变动，它都会大声报错而不是无声退化。
 
+### 第三方文本模型
+
+视觉桥接不限于 DeepSeek 官方 API。默认会自动发现所有已注册 provider 中符合条件的
+`deepseek`、`glm`、`mimo` 模型 ID，包括第三方转发渠道。选择带有
+`(modlens vision)` 的 provider 分组下的模型，粘贴、拖拽图片和附件按钮就会走
+DSH 原生附件流程，在调用文本模型前转成证据文本。
+
+需要接入其他文本模型时，编辑当前 profile 的
+`$DSH_HOME/profiles/<name>/cordis.patch.yml`。`DSH_HOME` 默认是 `~/.dsh`。
+按已安装插件的 ID 添加覆盖项，不要再写一条 `insert`：
+
+```yaml
+- id: modlens
+  config:
+    families: ['*']
+    discover: ['openrouter', 'nvidia', 'ark-deepseek']
+```
+
+`discover` 填实际注册的 provider ID，不是界面展示名。省略它则检查全部已注册渠道。
+保留文件中已有的其他配置项。这是 DSH 插件配置，不是 `~/.modlens/config.json`，
+后者配置的是实际读取图片的视觉引擎。
+
+`families: ['*']` 需要主动开启。上游模型元数据的 `inputModalities` 必须明确包含
+`text` 且不包含 `image`，缺失或空数组都不会自动获得变体。原有视觉模型名称排除规则
+仍然生效，MiMo 仍须带有 `-pro` 段。原生视觉模型应在上游配置中正确声明 `image`，
+并使用原模型条目。
+
+也可以缩小到明确的小写模型 ID 前缀，例如
+`families: ['deepseek', 'glm', 'mimo', 'ling', 'qwen']`。该列表会替换默认值。
+前缀既匹配完整模型 ID，也匹配移除开头的 `~` 和厂商命名空间后的 ID。
+显式前缀保留原有行为，元数据缺失时也能匹配，因此只添加已确认是文本模型的前缀。
+声明支持图片的模型和命中原有视觉排除规则的模型仍不会获得变体。
+
+检查最终配置，重启 DSH，再选择变体：
+
+```sh
+npx -y @deepseek-ai/dsh --profile <name> --dump-config
+```
+
+第三方 DeepSeek 没有出现变体时，检查该 profile 的插件版本、实际模型 ID 而非展示名、
+是否有 `upstream` 或 `discover` 限制，以及上游声明的输入能力。
+配置了 `upstream` 时沿用单渠道模式，不进行自动发现。
+
 ### 在网页界面里配置引擎
 
-dsh 的网页用户面前没有终端，所以引擎设置有一张卡片，在**设置 → 插件 → 插件配置**里：用哪个引擎读图、它的密钥、地址和模型，以及一次读取可以借用本机哪些已有登录。展开时会探测本机，只列出真正找到的 harness，让授权是在真实选项之间做选择，而不是面对五个名字。
+dsh 的网页用户面前没有终端，所以引擎设置有一张卡片，在**设置 → 插件 → 插件配置**里：用哪个引擎读图、它的密钥、地址、模型和代理方式，以及一次读取可以借用本机哪些已有登录。展开时会探测本机，只列出真正找到的 harness，让授权是在真实选项之间做选择，而不是面对五个名字。
 
-这些值仍然住在 `~/.modlens/config.json`，与其他所有 harness 共享：卡片通过一条回环路由读写那个文件，所以在这里改一笔，和 `modlens config set` 改的是同一笔。卡片从不拿到已保存的密钥，只知道有没有；密钥框留空就不动已存的那个。在插件配置行里设 `settingsCard: false` 可以连同路由一起去掉它。
+这些值仍然住在 `~/.modlens/config.json`，与其他所有 harness 共享：卡片通过一条回环路由读写那个文件，所以在这里改一笔，和 `modlens config set` 改的是同一笔。卡片从不拿到已保存的密钥或代理地址，只知道密钥有没有，以及代理是继承、直连还是使用专属地址。密钥或代理输入框留空就不动已存的值。在插件配置行里设 `settingsCard: false` 可以连同路由一起去掉它。
 
 卡片自己的文案跟随 dsh 的界面语言设置，你在 dsh 里切换语言，卡片跟着切。dsh 版本太旧、拿不到这个设置时，退回跟随浏览器语言。失败时服务端回的那句话保持原样（例如未知引擎、打不开的路径），那是诊断信息，不是界面文案。
 
@@ -73,7 +116,7 @@ dsh 的网页用户面前没有终端，所以引擎设置有一张卡片，在*
 modlens 发布很频繁，而两种安装形态都会冻结在装进来的那个版本上。dsh 上重跑一遍安装即可，版本号要点名：
 
 ```sh
-npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.25.4
+npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.26.1
 ```
 
 `npm view @liustack/modlens version` 可以查到当前版本号，本页的版本号则由发布流程自动写入。

package/docs/troubleshooting.md

@@ -163,7 +163,7 @@ simply lands on an older one. Name the exact version instead, which pnpm treats
 as a deliberate request rather than a resolution:
 
 ```sh
-npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.25.4
+npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.26.1
 ```
 
 `npm view @liustack/modlens version` prints the current one. pnpm 11 installs a named
@@ -178,7 +178,7 @@ file:
 
 ```yaml
 minimumReleaseAgeExclude:
-  - '@liustack/modlens@3.25.4'
+  - '@liustack/modlens@3.26.1'
 ```
 
 Or lift the gate for a single command, which lifts it for everything that
@@ -230,8 +230,15 @@ in either form:
 HTTPS_PROXY=http://127.0.0.1:7890 modlens -i shot.png -p gemini-api   # env (NO_PROXY honored too)
 modlens config set proxy http://127.0.0.1:7890                        # persistent, all API providers
 modlens config set openai.proxy http://127.0.0.1:7890                 # one provider only
+modlens config set openai.proxy ""                                    # this provider connects directly
 ```
 
+The provider field has three states. Missing inherits the shared config or
+environment proxy, an empty string means direct, and a URL is a provider-only
+proxy. This matters when an internet provider needs the shared proxy but an
+internal endpoint must stay direct. Failover still tries both providers, but a
+shared dead proxy otherwise makes both attempts fail the same way.
+
 The proxy applies to API provider requests only. The remote-image download
 path keeps its direct, IP-pinned connection on purpose: its SSRF guards
 validate the exact address being contacted, and a proxy would blind them. On

package/docs/troubleshooting.zh-CN.md

@@ -144,7 +144,7 @@ dsh profile 装到的是旧版 modlens。`dsh.bundle` 声明从 3.9.0 起才存
 `@latest` 绕不开这一层，本页早先的说法是错的。冷静期先把候选版本过滤掉，dist-tag 才在剩下的里面解析，于是它直接落到了更旧的那个上。改成写死精确版本号，pnpm 会把它当作一次明确的指定，而不是一次解析：
 
 ```sh
-npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.25.4
+npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.26.1
 ```
 
 `npm view @liustack/modlens version` 可以查到当前版本号。pnpm 11 会装上被点名的版本，11.1.3 起还会把它作为一条已批准的例外写进该 profile 的 `pnpm-workspace.yaml`，其余所有包和 modlens 以后的版本仍然留在窗口后面。
@@ -153,7 +153,7 @@ npx -y @deepseek-ai/dsh plugin --profile <name> add @liustack/modlens@3.25.4
 
 ```yaml
 minimumReleaseAgeExclude:
-  - '@liustack/modlens@3.25.4'
+  - '@liustack/modlens@3.26.1'
 ```
 
 或者只为这一条命令解除冷静期，注意它解除的是这条命令解析到的所有包，不只 modlens：
@@ -188,8 +188,11 @@ API 请求根本没离开这台机器。在要靠代理才能上网的网络里
 HTTPS_PROXY=http://127.0.0.1:7890 modlens -i shot.png -p gemini-api   # env (NO_PROXY honored too)
 modlens config set proxy http://127.0.0.1:7890                        # persistent, all API providers
 modlens config set openai.proxy http://127.0.0.1:7890                 # one provider only
+modlens config set openai.proxy ""                                    # 这个 provider 强制直连
 ```
 
+provider 代理字段有三种状态。字段缺失表示继承共享配置或环境代理，空字符串表示直连，URL 表示只给该 provider 使用的代理。当外部 provider 需要共享代理，而内网端点必须直连时，这个区别很重要。故障转移仍然会尝试两者，但共享的失效代理会让两个尝试以同一种方式失败。
+
 代理只作用于 API provider 的请求。远程图片的下载路径有意保持直连并钉死 IP：它的 SSRF 防护校验的正是实际连接的那个地址，加了代理这些防护就失明了。在必须走代理的机器上，优先用本地文件，或让故障转移链把远程 URL 交给会在上游自行抓取的 provider。
 
 ## 配置文件问题

package/dsh/client.js

@@ -32,10 +32,36 @@ window.__ModuleLoader__.load({
       return files
     }
 
+    function isTextField(el) {
+      return el && (el.tagName === 'TEXTAREA' || el.tagName === 'INPUT')
+    }
+
+    function isComposerEditable(el) {
+      if (!el || typeof el.getAttribute !== 'function') return false
+      if (el.getAttribute('data-composer-input') == null) return false
+      return el.isContentEditable === true || el.contentEditable === 'true'
+    }
+
+    function isWritable(el) {
+      return isTextField(el) || isComposerEditable(el)
+    }
+
+    // Resolve before taking the event. No writable composer means native
+    // paste; missing closest (stubs, odd hosts) falls through to
+    // activeElement so a focused textarea still works.
+    function resolveWriteTarget(event) {
+      var fromEvent = event.target
+      if (fromEvent && typeof fromEvent.closest === 'function') {
+        var found = fromEvent.closest('textarea, input, [data-composer-input][contenteditable=true]')
+        if (found) return found
+      }
+      var active = document.activeElement
+      return isWritable(active) ? active : null
+    }
+
     function insertText(target, text) {
-      var el = target && (target.tagName === 'TEXTAREA' || target.tagName === 'INPUT') ? target : document.activeElement
-      if (!el || (el.tagName !== 'TEXTAREA' && el.tagName !== 'INPUT')) return
-      el.focus()
+      if (!isWritable(target)) return false
+      target.focus()
       // execCommand fires the input event React's controlled textarea needs;
       // the prototype-setter dance is the fallback for engines dropping it.
       var inserted = false
@@ -44,11 +70,19 @@ window.__ModuleLoader__.load({
       } catch {
         inserted = false
       }
-      if (!inserted) {
-        var proto = el.tagName === 'TEXTAREA' ? window.HTMLTextAreaElement.prototype : window.HTMLInputElement.prototype
+      if (inserted) return true
+      // Lexical's composer is a contenteditable div: it has no value
+      // setter, and assigning innerHTML/textContent bypasses the editor.
+      if (!isTextField(target)) return false
+      try {
+        var proto =
+          target.tagName === 'TEXTAREA' ? window.HTMLTextAreaElement.prototype : window.HTMLInputElement.prototype
         var setter = Object.getOwnPropertyDescriptor(proto, 'value').set
-        setter.call(el, el.value + text)
-        el.dispatchEvent(new Event('input', { bubbles: true }))
+        setter.call(target, target.value + text)
+        target.dispatchEvent(new Event('input', { bubbles: true }))
+        return true
+      } catch {
+        return false
       }
     }
 
@@ -146,18 +180,22 @@ window.__ModuleLoader__.load({
       // No fresh confirmed host verdict: leave the paste native. Wrong only
       // for a text-only model's very first paste, and self-correcting.
       if (!cached || cached.at === 0 || cached.takeover !== true || Date.now() - cached.at > VERDICT_MAX_AGE_MS) return
+      var target = resolveWriteTarget(event)
+      if (!target) return
       // Take the paste before the composer's intake starts an attachment (and
       // with it the host-side image admission a text-only model fails).
       event.preventDefault()
       event.stopImmediatePropagation()
-      var target = event.target
       Promise.all(files.map(uploadOne))
         .then((results) => {
           var text = results
             .map((r) => r.path)
             .filter(Boolean)
             .join(' ')
-          if (text) insertText(target, `${text} `)
+          if (!text) return
+          if (!insertText(target, `${text} `)) {
+            console.error(`[modlens] paste-to-path: could not insert into the composer (${text})`)
+          }
         })
         .catch((error) => {
           // A 404 here means the route vanished AFTER a verdict confirmed it
@@ -196,6 +234,14 @@ window.__ModuleLoader__.load({
           'Separate multiple keys with commas. ModLens rotates to the next key after authentication, rate-limit, or quota failures.',
         baseUrl: 'Base URL',
         model: 'Model',
+        proxyRoute: 'Proxy route',
+        proxyInherit: 'Inherit global or environment proxy',
+        proxyDirect: 'Direct connection',
+        proxyCustom: 'Custom proxy',
+        proxyUrl: 'Proxy URL',
+        proxyStored: 'stored, leave empty to keep it',
+        proxyExample: 'http://127.0.0.1:7890',
+        proxyHint: 'Direct ignores the global proxy and HTTP_PROXY / HTTPS_PROXY.',
         stored: 'stored, leave empty to keep it',
         unset: 'not set',
         fallback: 'provider default',
@@ -224,6 +270,14 @@ window.__ModuleLoader__.load({
         apiKeyHint: '多个密钥用英文逗号分隔。鉴权、限流或配额失败时会自动轮换到下一个密钥。',
         baseUrl: '接口地址',
         model: '模型',
+        proxyRoute: '代理方式',
+        proxyInherit: '继承全局代理或环境变量',
+        proxyDirect: '直连',
+        proxyCustom: '使用专属代理',
+        proxyUrl: '代理地址',
+        proxyStored: '已保存，留空即不改动',
+        proxyExample: 'http://127.0.0.1:7890',
+        proxyHint: '直连会忽略全局代理与 HTTP_PROXY / HTTPS_PROXY。',
         stored: '已保存，留空即不改动',
         unset: '未设置',
         fallback: '使用该引擎默认值',
@@ -266,8 +320,8 @@ window.__ModuleLoader__.load({
       return detail || fallback
     }
 
-    // The next draft when the engine changes or a summary arrives. The three
-    // engine fields belong to the newly selected engine; the reuse grants are
+    // The next draft when the engine changes or a summary arrives. The engine
+    // fields belong to the newly selected engine; the reuse grants are
     // the user's pending answers and survive an engine switch, since granting
     // codex has nothing to do with which engine reads the images.
     function nextDraft(summary, provider, keepReuse) {
@@ -280,6 +334,10 @@ window.__ModuleLoader__.load({
         apiKey: '',
         baseUrl: engine.baseUrl,
         model: engine.model,
+        proxyMode: engine.proxyMode || 'inherit',
+        // A proxy URL can carry credentials, so the host reports only its
+        // mode. Blank means keep the stored custom URL unless one is typed.
+        proxy: '',
         reuse: Object.assign({}, keepReuse || summary.reuse),
       }
     }
@@ -299,42 +357,57 @@ window.__ModuleLoader__.load({
         payload.provider = draft.provider
       }
       var pristine = nextDraft(summary, draft.provider, draft.reuse)
-      var engineEdited = draft.apiKey !== '' || draft.baseUrl !== pristine.baseUrl || draft.model !== pristine.model
+      var apiKey = draft.apiKey || ''
+      var baseUrl = draft.baseUrl || ''
+      var model = draft.model || ''
+      var proxyMode = draft.proxyMode || 'inherit'
+      var proxy = draft.proxy || ''
+      var apiKeyEdited = apiKey !== ''
+      var baseUrlEdited = baseUrl !== pristine.baseUrl
+      var modelEdited = model !== pristine.model
+      var proxyEdited = proxyMode !== pristine.proxyMode || proxy !== ''
+      var engineEdited = apiKeyEdited || baseUrlEdited || modelEdited || proxyEdited
       if (draft.provider !== '' && engineEdited) {
         payload.engine = draft.provider
-        payload.apiKey = draft.apiKey
-        payload.baseUrl = draft.baseUrl
-        payload.model = draft.model
+        if (apiKeyEdited) payload.apiKey = apiKey
+        if (baseUrlEdited) payload.baseUrl = baseUrl
+        if (modelEdited) payload.model = model
+        if (proxyEdited) {
+          payload.proxyMode = proxyMode
+          // Once the route is inherit or direct, a custom URL is irrelevant
+          // and may contain credentials. Do not put stale input on the wire.
+          payload.proxy = proxyMode === 'custom' ? proxy : ''
+        }
       }
       return payload
     }
 
     /**
-     * How to render the API key field so the characters are hidden.
+     * How to render key and proxy credential fields with hidden characters.
      *
      * A real password input makes Safari's iCloud Keychain offer to enable
      * autofill for the site and then pop its bubble on every focus, for a
-     * field that is always empty: the key lives in the config file and the
+     * field that is always empty: the secret lives in the config file and the
      * host never sends it here, only whether one is stored. `autocomplete`
      * cannot turn that off, because WebKit ignores it on password fields on
      * purpose (issue #56). Masking with text-security gets the same hidden
-     * characters without ever being a password field, and it also keeps a key
-     * meant for one machine out of a synced keychain.
+     * characters without ever being a password field, and it also keeps a
+     * machine-local secret out of a synced keychain.
      *
      * Feature-detected rather than assumed. Where the property is missing the
      * field stays a password input: the nuisance is worth more than the
-     * alternative, which is somebody's API key rendered in clear text while
-     * they type it.
+     * alternative, which is somebody's credential rendered in clear text
+     * while they type it.
      *
      * This is a trade, not a free win, and the cost falls on people who are
      * not in the room. A password input carries a protected state into the
      * accessibility tree, and screen readers stop reading characters back
      * because of it. Masking is only paint: VoiceOver and NVDA will read this
-     * key aloud, and ARIA has no equivalent to restore. Selection and copy
+     * secret aloud, and ARIA has no equivalent to restore. Selection and copy
      * also become possible, and an IME candidate window shows what is being
      * typed above the field. Accepted here because the field is empty in
-     * normal use (the key lives in the config file and is never sent to the
-     * browser), so what a screen reader can read back is what the user is
+     * normal use (the stored value is never sent to the browser), so what a
+     * screen reader can read back is what the user is
      * typing at that moment, not a stored secret.
      */
     /**
@@ -549,7 +622,13 @@ window.__ModuleLoader__.load({
               draft.apiKey !== '' ||
               draft.baseUrl !== pristine.baseUrl ||
               draft.model !== pristine.model ||
+              draft.proxyMode !== pristine.proxyMode ||
+              draft.proxy !== '' ||
               REUSE.some((name) => draft.reuse[name] !== summary.reuse[name])
+            var customProxyMissing =
+              draft.proxyMode === 'custom' && current.proxyMode !== 'custom' && draft.proxy.trim() === ''
+            var canDiscard = dirty && note !== t.saving
+            var canSave = canDiscard && !customProxyMissing
 
             var set = (key, value) => {
               var next = Object.assign({}, draft)
@@ -699,6 +778,55 @@ window.__ModuleLoader__.load({
                   ),
               draft.provider === '' || keyless ? null : textField(t.baseUrl, 'baseUrl', 'text', t.fallback),
               draft.provider === '' ? null : textField(t.model, 'model', 'text', t.fallback),
+              draft.provider === '' || keyless
+                ? null
+                : fieldRow(
+                    t.proxyRoute,
+                    h(
+                      'select',
+                      {
+                        name: 'proxyMode',
+                        value: draft.proxyMode,
+                        onChange: (event) => set('proxyMode', event.target.value),
+                        style: {
+                          appearance: 'none',
+                          width: '100%',
+                          padding: '8px 12px',
+                          borderRadius: '8px',
+                          border: '1px solid var(--dsw-alias-border-l2, rgba(127,127,127,0.35))',
+                          background: 'transparent',
+                          color: 'inherit',
+                          font: 'inherit',
+                          fontSize: '13px',
+                        },
+                      },
+                      [
+                        h('option', { key: 'inherit', value: 'inherit' }, t.proxyInherit),
+                        h('option', { key: 'direct', value: 'direct' }, t.proxyDirect),
+                        h('option', { key: 'custom', value: 'custom' }, t.proxyCustom),
+                      ],
+                    ),
+                    'proxy-mode',
+                  ),
+              draft.provider === '' || keyless
+                ? null
+                : fieldRow(
+                    '',
+                    h(
+                      'div',
+                      {
+                        style: {
+                          fontSize: '13px',
+                          color: 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.8))',
+                        },
+                      },
+                      t.proxyHint,
+                    ),
+                    'proxy-hint',
+                  ),
+              draft.provider === '' || keyless || draft.proxyMode !== 'custom'
+                ? null
+                : secretField(t.proxyUrl, 'proxy', current.proxyMode === 'custom' ? t.proxyStored : t.proxyExample),
               // Where these values are coming from, said once, because the
               // first save moves them: an engine the file names takes its
               // settings from the file alone.
@@ -794,7 +922,7 @@ window.__ModuleLoader__.load({
                   'button',
                   {
                     type: 'button',
-                    disabled: !dirty || note === t.saving,
+                    disabled: !canDiscard,
                     onClick: () => {
                       draftState[1](seed(summary, summary.provider))
                       noteState[1]('')
@@ -804,13 +932,13 @@ window.__ModuleLoader__.load({
                       font: 'inherit',
                       fontSize: '13px',
                       lineHeight: 1.5,
-                      cursor: dirty ? 'pointer' : 'default',
+                      cursor: canDiscard ? 'pointer' : 'default',
                       border: '1px solid var(--dsw-alias-border-l2, rgba(127,127,127,0.35))',
                       borderRadius: '8px',
                       padding: '5px 14px',
                       background: 'none',
                       color: 'var(--dsw-alias-label-secondary, inherit)',
-                      opacity: dirty ? 1 : 0.4,
+                      opacity: canDiscard ? 1 : 0.4,
                     },
                   },
                   t.discard,
@@ -819,7 +947,7 @@ window.__ModuleLoader__.load({
                   'button',
                   {
                     type: 'button',
-                    disabled: !dirty || note === t.saving,
+                    disabled: !canSave,
                     onClick: () => {
                       noteState[1](t.saving)
                       var payload = savePayload(summary, draft)
@@ -856,13 +984,13 @@ window.__ModuleLoader__.load({
                       font: 'inherit',
                       fontSize: '13px',
                       lineHeight: 1.5,
-                      cursor: dirty ? 'pointer' : 'default',
+                      cursor: canSave ? 'pointer' : 'default',
                       border: '1px solid transparent',
                       borderRadius: '8px',
                       padding: '5px 14px',
                       background: 'var(--dsw-alias-label-primary, currentColor)',
                       color: 'var(--dsw-alias-bg-layer-3, rgba(127,127,127,0.05))',
-                      opacity: dirty ? 1 : 0.4,
+                      opacity: canSave ? 1 : 0.4,
                     },
                   },
                   t.save,

package/dsh/index.js

@@ -676,7 +676,16 @@ function registerVisionProvider(ctx, config, ownProviders, evidenceCache) {
     // to contain the word cannot veto the text model behind it.
     const unaliased = id.replace(/^~/, '')
     const bare = unaliased.slice(unaliased.lastIndexOf('/') + 1)
-    if (!families.some((family) => id.startsWith(family) || bare.startsWith(family))) return false
+    const matchesFamily = families.some(
+      (family) => family !== '*' && (id.startsWith(family) || bare.startsWith(family)),
+    )
+    if (!matchesFamily) {
+      // Opting into all families is not evidence that an unknown model is
+      // text-only. Outside an explicitly named family, require the catalog
+      // to declare text input. The image and native-name vetoes still apply.
+      if (!families.includes('*') || !Array.isArray(info?.inputModalities) || !info.inputModalities.includes('text'))
+        return false
+    }
     if (VISION_ID.test(bare)) return false
     if (Array.isArray(info?.inputModalities) && info.inputModalities.includes('image')) return false
     // MiMo needs the gate reversed. Xiaomi's bare version ids name native
@@ -1642,9 +1651,10 @@ function readModlensConfig() {
 }
 
 /**
- * What the card is allowed to know. Every engine's endpoint and model, plus
- * whether a key is stored, and never the key itself: a browser that cannot
- * read a secret cannot leak one, and cannot write it back either.
+ * What the card is allowed to know. Every engine's endpoint, model and proxy
+ * mode, plus whether a key is stored. Neither keys nor proxy URLs cross into
+ * the browser: both can carry credentials, and a browser that cannot read a
+ * secret cannot leak one or write it back accidentally.
  */
 function engineSummary(config = readModlensConfig()) {
   const engines = {}
@@ -1663,6 +1673,11 @@ function engineSummary(config = readModlensConfig()) {
       baseUrl: typeof settings.baseUrl === 'string' ? settings.baseUrl : '',
       model: typeof settings.model === 'string' ? settings.model : '',
       hasKey: hasApiKeys(settings.apiKey),
+      proxyMode: !Object.hasOwn(settings, 'proxy')
+        ? 'inherit'
+        : typeof settings.proxy === 'string' && settings.proxy.trim() === ''
+          ? 'direct'
+          : 'custom',
       // '' means neither source holds anything, which is not the same as the
       // file holding an empty entry: that one is already off its variables.
       source: inFile ? 'file' : Object.keys(settings).length > 0 ? 'env' : '',
@@ -1687,7 +1702,7 @@ function engineSummary(config = readModlensConfig()) {
 
 /**
  * Apply one card submission to the shared file. Only the named engine's own
- * three fields are touched, so switching engines in the card cannot copy one
+ * fields are touched, so switching engines in the card cannot copy one
  * engine's endpoint onto another. An absent or empty `apiKey` leaves the
  * stored one alone: the card never receives a key, so it must never be able
  * to clear one by submitting the blank field it was shown.
@@ -1734,6 +1749,7 @@ function applyEngineSettings(patch) {
     const seed = holders.length > 0 ? {} : engineEnvSettings(engine)
     const settings = { ...seed, ...config.providers[target] }
     for (const field of ['baseUrl', 'model']) {
+      if (!Object.hasOwn(patch, field)) continue
       const value = typeof patch[field] === 'string' ? patch[field].trim() : ''
       if (value === '') {
         delete settings[field]
@@ -1745,6 +1761,36 @@ function applyEngineSettings(patch) {
     if (apiKey !== '') {
       settings.apiKey = apiKey
     }
+    if (Object.hasOwn(patch, 'proxyMode')) {
+      if (patch.proxyMode === 'inherit') {
+        // Absence is the inheritance signal. Remove the field from every
+        // alias-backed entry or an older alias value resurfaces when settings
+        // are merged, even after the canonical entry says it was cleared.
+        for (const holder of holders) {
+          const stored = config.providers[holder]
+          if (stored && typeof stored === 'object' && !Array.isArray(stored)) {
+            delete stored.proxy
+          }
+        }
+        delete settings.proxy
+      } else if (patch.proxyMode === 'direct') {
+        settings.proxy = ''
+      } else if (patch.proxyMode === 'custom') {
+        const proxy = typeof patch.proxy === 'string' ? patch.proxy.trim() : ''
+        if (proxy !== '') {
+          settings.proxy = proxy
+        } else {
+          // The card reports the merged route, which may live under an alias
+          // while the canonical entry owns only the model or endpoint.
+          const storedProxy = Object.assign({}, ...holders.map((key) => config.providers[key])).proxy
+          if (typeof storedProxy !== 'string' || storedProxy.trim() === '') {
+            throw new Error('custom proxy mode needs a proxy URL')
+          }
+        }
+      } else {
+        throw new Error(`unknown proxy mode: ${patch.proxyMode}`)
+      }
+    }
     config.providers[target] = settings
   }
   // Auto mode, when the card sent it: only the harnesses this build knows,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@liustack/modlens",
-    "version": "3.25.4",
+    "version": "3.26.1",
     "description": "Plug-in vision for text-only LLMs, powered by the free Antigravity CLI",
     "type": "module",
     "bin": {

package/skills/modlens/SKILL.md

@@ -20,11 +20,11 @@ powershell -ExecutionPolicy Bypass -File <skill-dir>\scripts\run.ps1 <args>
 
 It resolves a working runtime (PATH `modlens`, then `npx`, then `bunx`) and forwards your arguments unchanged. Exit 78 means no runtime: relay the `nextSteps` from its stderr JSON instead of retrying.
 
-If your harness forbids running scripts, reason through the same order by hand and run the first line that works (the pinned version is 3.25.4):
+If your harness forbids running scripts, reason through the same order by hand and run the first line that works (the pinned version is 3.26.1):
 
-1. A `modlens` on `PATH` whose major version is 3 and is at least 3.25.4: `modlens <args>`.
-2. Otherwise, if `npx` exists: `npx --yes --package @liustack/modlens@3.25.4 modlens <args>`.
-3. Otherwise, if `bunx` exists: `bunx --bun @liustack/modlens@3.25.4 <args>`.
+1. A `modlens` on `PATH` whose major version is 3 and is at least 3.26.1: `modlens <args>`.
+2. Otherwise, if `npx` exists: `npx --yes --package @liustack/modlens@3.26.1 modlens <args>`.
+3. Otherwise, if `bunx` exists: `bunx --bun @liustack/modlens@3.26.1 <args>`.
 4. Otherwise tell the user no JavaScript runtime was found and that installing Node 22.19+ (https://nodejs.org) or Bun (https://bun.sh) is the next step. Do not claim modlens itself failed.
 
 `references/runtime.md` documents the pin and the diagnostic fields.

package/skills/modlens/references/configure.md

@@ -13,6 +13,8 @@ modlens config init                     # write a starter config (refuses to ove
 modlens config show                     # effective file, API keys masked
 modlens config set provider <name>      # change the default provider
 modlens config set <provider>.<field> <value>   # fields: apiKey, baseUrl, model, proxy, extraBody, structuredOutput
+modlens config set proxy http://127.0.0.1:7890          # default for every API provider
+modlens config set openai.proxy ""                      # make one provider connect directly
 ```
 
 `config set` writes the file with 0600 permissions.
@@ -66,6 +68,8 @@ Field semantics:
 
 - `provider`: which provider runs when `-p` is not given. Canonical names or aliases both work (`agy`/`antigravity` for `antigravity-cli`, `gemini` for `gemini-api`, `openai-compat` for `openai`, `claude` for `anthropic`, `kimi`/`kimi-code` for `kimi-cli`, `claude-code` for `claude-cli`). Empty or absent pins nothing: the failover chain decides, trying configured API providers before the agent CLIs.
 - `cooldown`: `'on'` (default) or `'off'`. On, a quota-spent key is remembered in `~/.modlens/state.json` and tried last until it recovers (45 minutes by default, 24 hours for monthly HTTP 432/433, or the engine-reported `Resets in` clause). Off, that file is neither read nor written. `modlens state clear` forgets every cooldown.
+- `proxy`: the default route for all API providers. When it is absent, `HTTPS_PROXY` or `HTTP_PROXY` supplies the default instead. `NO_PROXY` is honored on that environment route.
+- `providers.<name>.proxy`: a three-state override. An absent field inherits the default above, an empty string forces a direct connection, and a non-empty URL selects a proxy for this provider alone. This lets an internal endpoint stay reachable when the shared proxy fails. To restore inheritance, remove the field from the file or choose the inherited route in the dsh settings card. `config show` renders the empty state as `direct`, and the card exposes all three choices without sending a stored proxy URL to the browser.
 - `providers.<name>.<field>`: six fields exist, `apiKey`, `baseUrl`, `model`, `proxy`, `extraBody`, and `structuredOutput` (the openai route only). Every provider entry is optional, and every field inside it is optional. Alias keys are read too (settings saved under `gemini` are found when `gemini-api` resolves), with the canonical key winning on conflict. `apiKey` accepts a comma-separated list. Requests use the configured order and rotate only after authentication, rate-limit, or quota failures. Other failures skip remaining keys and keep provider failover.
 - `providers.<name>.extraBody`: a JSON object merged into the request body of the API providers (`gemini-api`, `openai`, `anthropic`), for whatever knobs that vendor has and modlens has no flag for. Turning thinking off is the usual reason, see the section below. Nested objects merge key by key, so adding one knob leaves the rest of that block alone. The fields carrying the image, the prompt, and each route's own enforcement machinery are refused with an error naming the field. `response_format` on the `openai` route is not one of them: setting it there deliberately replaces the schema modlens would otherwise send. The three CLI providers take no request body, so a run on `antigravity-cli`, `claude-cli` or `kimi-cli` ignores it and says so in `meta.warnings`.
 - `providers.openai.structuredOutput`: `true` asks an OpenAI-compatible gateway to enforce the vision contract itself, as `response_format: json_schema` in the strict form those endpoints require. Off by default, since a gateway without structured-output support answers 400 for the field. A `response_format` you set in `extraBody` wins over it.

package/skills/modlens/references/configure.zh-CN.md

@@ -13,6 +13,8 @@ modlens config init                     # 写入一份起步配置（已存在
 modlens config show                     # 生效的配置文件，API key 打码显示
 modlens config set provider <name>      # 更改默认 provider
 modlens config set <provider>.<field> <value>   # 字段：apiKey、baseUrl、model、proxy、extraBody、structuredOutput
+modlens config set proxy http://127.0.0.1:7890          # 所有 API provider 的默认代理
+modlens config set openai.proxy ""                      # 让一个 provider 强制直连
 ```
 
 `config set` 写文件时权限为 0600。
@@ -66,6 +68,8 @@ modlens config set <provider>.<field> <value>   # 字段：apiKey、baseUrl、mo
 
 - `provider`：不传 `-p` 时由哪个 provider 执行。标准名和别名都行（`agy`/`antigravity` 对应 `antigravity-cli`，`gemini` 对应 `gemini-api`，`openai-compat` 对应 `openai`，`claude` 对应 `anthropic`，`kimi`/`kimi-code` 对应 `kimi-cli`，`claude-code` 对应 `claude-cli`）。留空或缺失表示不钉任何一个：由失败切换链决定，已配置的 API provider 先于 agent CLI 被尝试。
 - `cooldown`：`'on'`（默认）或 `'off'`。打开时，配额耗尽的密钥会记入 `~/.modlens/state.json`，恢复前放到队尾再试（默认 45 分钟，月度 HTTP 432/433 为 24 小时，引擎回报的 `Resets in` 子句优先）。关闭时不读也不写那个文件。`modlens state clear` 会忘掉全部冷却。
+- `proxy`：所有 API provider 的默认代理。它缺失时改由 `HTTPS_PROXY` 或 `HTTP_PROXY` 提供默认值，环境变量路线会遵守 `NO_PROXY`。
+- `providers.<name>.proxy`：有三种状态。字段缺失表示继承上述默认值，空字符串表示强制直连，非空 URL 表示只给这个 provider 使用的代理。这样共享代理失效时，内网端点仍然可以直连。要恢复继承，删除配置文件中的这个字段，或在 dsh 设置卡中选择继承。`config show` 会把空值显示成 `direct`，设置卡会提供三种选择，而且不会把已保存的代理地址发送给浏览器。
 - `providers.<name>.<field>`：共六个字段，`apiKey`、`baseUrl`、`model`、`proxy`、`extraBody`、`structuredOutput`（仅 openai 路线）。每个 provider 条目都可选，条目里的每个字段也都可选。别名键同样会被读取（存在 `gemini` 下的设置在解析到 `gemini-api` 时也能找到），冲突时标准键胜出。`apiKey` 接受英文逗号分隔的列表。请求按配置顺序使用，只在鉴权、限流或配额失败后轮换。其他失败会跳过剩余密钥，并继续走现有的 provider 故障转移。
 - `providers.<name>.extraBody`：一个 JSON 对象，合并进 API provider（`gemini-api`、`openai`、`anthropic`）的请求体，用来传厂商有而 modlens 没有对应参数的开关。最常见的用途是关掉思考，见下文小节。嵌套对象逐键合并，所以加一个开关不会动到该块里的其他内容。承载图片、提示词和各路线自身强制机制的字段会被拒绝，报错会点名该字段。`openai` 路线上的 `response_format` 不在此列：在那里设置它就是有意替换掉 modlens 本来会发的那份 schema。三个 CLI provider 不发请求体，所以在 `antigravity-cli`、`claude-cli` 或 `kimi-cli` 上运行时它会被忽略，并在 `meta.warnings` 里说明。
 - `providers.openai.structuredOutput`：设为 `true` 时，让 OpenAI 兼容网关自己强制执行视觉契约，以 `response_format: json_schema` 的严格形式发出。默认关闭，因为不支持结构化输出的网关会对这个字段返回 400。你在 `extraBody` 里设的 `response_format` 优先级更高。

package/skills/modlens/references/runtime.md

@@ -8,7 +8,7 @@ shell syntax.
 
 ## Pinned version
 
-- Pinned CLI version: 3.25.4
+- Pinned CLI version: 3.26.1
 - npm package: `@liustack/modlens`
 - CLI binary name: `modlens`
 

package/skills/modlens/scripts/run.ps1

@@ -24,7 +24,7 @@ $ErrorActionPreference = 'Stop'
 # package.json version, and the release script rewrites it on every bump.
 $Package = '@liustack/modlens'
 $Bin = 'modlens'
-$Pinned = '3.25.4'
+$Pinned = '3.26.1'
 # -------------------------------------------------------------------------------
 
 $NativeNote = 'no native artifact is published for this tool yet; phase A ships npm launch paths only'

package/skills/modlens/scripts/run.sh

@@ -22,7 +22,7 @@ set -eu
 # package.json version, and the release script rewrites it on every bump.
 PKG="@liustack/modlens"
 BIN="modlens"
-PINNED="3.25.4"
+PINNED="3.26.1"
 # -------------------------------------------------------------------------------
 
 NATIVE_NOTE="no native artifact is published for this tool yet; phase A ships npm launch paths only"