dsh-newapi-provider 0.8.3 → 0.9.4

package/PUBLISHING.md

@@ -6,13 +6,15 @@
 
 | 项目 | 状态 |
 | --- | --- |
-| 版本 | 0.8.1（未发布） |
-| 包名 | `dsh-newapi-provider` — npm 上仍是 404，名称可用 |
+| npm | **已发布 0.8.3** — https://www.npmjs.com/package/dsh-newapi-provider （`latest`，2026-10-23 17:48 东八区） |
+| 包内容校验 | 下载 tarball 与仓库逐文件字节一致，19 个文件，shasum 一致，无凭据泄漏 |
+| Git tag | `v0.8.3` 已推送 |
 | 仓库 | https://github.com/zenVibeCoding/dsh-newapi-provider （公开，已加 `dsh-plugin` topic） |
+| 市场投稿 | **未提交**，条目文件已备好：[docs/market-entry.yml](docs/market-entry.yml)，卡片图 [assets/icon-180.png](assets/icon-180.png) |
+| 可投稿时间 | 仓库创建 2026-10-23 07:01 UTC，满 24 小时 = **2026-10-24 15:01（东八区）之后** |
 | 许可证 | MIT，作者 `zenVibeCoding` |
 | 验证环境 | DSH 0.2.1-rc.2 / Node.js 22.19+，`engines.dsh: >=0.2.1-rc.1 <0.3.0-0` |
 | 离线测试 | `npm test`，103 项全过 |
-| 打包 | 19 个文件，无凭据/本机路径 |
 | 真实生图 | **未验证**（网关返回 503 无可用渠道） |
 | 真实视频 | **未验证**（无视频渠道），工具为实验性 |
 
@@ -85,25 +87,28 @@ dsh plugin add dsh-newapi-provider    # 走 npm 而非本地目录
 
 **时间门槛**：仓库创建于 2026-10-23 07:01 UTC，需满 24 小时，即 **2026-10-24 15:01（东八区）之后**再提 PR。
 
-投稿文件内容（保存为 `data/plugins/zenVibeCoding__dsh-newapi-provider.yml`）：
+条目已经写好并校验通过：**[docs/market-entry.yml](docs/market-entry.yml)**（用 js-yaml 解析验证过，分类合法、描述以句号结尾）。目标路径是 `data/plugins/zenVibeCoding__dsh-newapi-provider.yml`，直接复制即可：
 
 ```yaml
 url: https://github.com/zenVibeCoding/dsh-newapi-provider
 name: zenVibeCoding/dsh-newapi-provider
 category: model
 description:
-  en: 'New API gateway provider: multi-channel models with context and modality details, quota, and image and video generation.'
-  zh: 'New API 网关提供商：多渠道模型管理与上下文/多模态标注、额度查询，以及生图与视频生成。'
+  en: 'New API gateway provider: several gateways with one active at a time, per-gateway model lists with context and modality details, quota, and image and video generation tools.'
+  zh: 'New API 网关提供商：多网关同一时间激活一个，每个网关独立的模型清单与上下文/多模态标注、额度查询，以及生图与视频生成工具。'
+icon: https://raw.githubusercontent.com/zenVibeCoding/dsh-newapi-provider/master/assets/icon-180.png
 ```
 
-> 描述里有 `: ` 必须加引号，否则 YAML 解析失败。
+> 描述里有 `: ` 必须加引号，否则 YAML 解析失败（上面英文描述就是这种情况）。
+> 卡片图是 `assets/icon-180.png`（180×180 PNG），市场要求 GitHub 托管的位图；仓库里的 `icon.svg` 是 DSH 插件页用的，不适用于市场卡片。
 
 提交步骤：
 
 ```sh
 gh repo fork awesome-dsh-plugin/awesome-dsh-plugin --clone
 cd awesome-dsh-plugin
-# 写入上面那个 yml（文件名必须是 owner__repo.yml）
+mkdir -p data/plugins
+cp ~/dsh-newapi-provider/docs/market-entry.yml data/plugins/zenVibeCoding__dsh-newapi-provider.yml
 git checkout -b add-dsh-newapi-provider
 git add data/plugins/zenVibeCoding__dsh-newapi-provider.yml
 git commit -m "Add dsh-newapi-provider"

package/README.md

@@ -2,7 +2,10 @@
 
 English · [中文](README.zh.md)
 
-A New API gateway workbench for DeepSeek Harness: several gateways with one active at a time, per-gateway model lists and parameter overrides, quota, and image and experimental video generation. **Development build; not published to npm yet.**
+A New API gateway workbench for DeepSeek Harness: several gateways with one active at a time, per-gateway model lists and parameter overrides, quota, and image and experimental video generation.
+
+[![npm](https://img.shields.io/npm/v/dsh-newapi-provider.svg)](https://www.npmjs.com/package/dsh-newapi-provider)
+[![license](https://img.shields.io/npm/l/dsh-newapi-provider.svg)](LICENSE)
 
 ![Settings → New API Provider: gateways and connections](docs/screenshots/channels.png)
 
@@ -16,54 +19,52 @@ A New API gateway workbench for DeepSeek Harness: several gateways with one acti
 
 The screenshots render this plugin's real components and stylesheet with sample data; gateway names, URLs and amounts are examples. The UI follows the DSH theme, so colours adapt to your skin and dark mode.
 
-## Features
-
-- Save multiple gateways and activate exactly one. Each keeps its own URL, credential reference, model list and model overrides.
-- Channel-scoped model management: fetch what a gateway lists, choose which models appear in DSH, test one model, remove with undo, add models the gateway does not list.
-- Capability data from models.dev (context window, output cap, modalities, reasoning), correctable per model, with an optional per-model upstream name mapping.
-- Token quota plus account balance when the token is allowed to query it; unlimited tokens show used quota instead of a negative remainder.
-- Generate images as durable DSH attachments; experimental video through the unified `/v1/videos` interface with background polling and restart recovery.
-
-## Requirements and local installation
+## Install
 
-Verified runtime: **DSH 0.2.1-rc.2**, Node.js 22.19+. Install the local project directory with DSH's plugin manager, refresh the page, then open **Settings → New API Provider**. No separate web server is needed. Do not install this name from npm before it is published.
+Requires **DSH 0.2.1-rc.1 or newer** (verified on 0.2.1-rc.2) and Node.js 22.19+.
 
-This replaces, rather than depends on, `dsh-gateway-provider`; two adapters cannot own the same provider route. The development installation uses the `newapi-provider` route.
-
-## Migrating from the former name (v0.7.0)
+Install `dsh-newapi-provider` with DSH's plugin manager, then refresh the page and open **Settings → New API Provider**. No separate web server is needed.
 
-The plugin was called `dsh-newapi-studio`. The rename covers the package, the loader row and provider route (`newapi-provider`), the HTTP prefix (`/newapi-provider/api/`) and the data directory (`plugin-data/dsh-newapi-provider`).
+1. **Add gateway** — name, New API site URL, calling token.
+2. **Fetch models** — read what the gateway lists, select the ones you want.
+3. **Activate the gateway** — this plugin's model route now serves those models.
 
-To migrate an existing installation, back up the profile patch and plugin data, then keep each channel's id, credential reference, model list and overrides while moving the data directory to the new name. This release does not read the old directory automatically. Keep existing credential references even if they contain `STUDIO`: they still hold the working tokens; new references use the `NEWAPI_PROVIDER_` prefix.
+The token is stored in the DSH credential service, never in the gateway configuration, and is never sent back to the browser.
 
-Sessions pinned to the old `newapi-studio` route must pick models again under the new route. Other adapters are unaffected. Tool names (`newapi_channels`, `newapi_models`, …) did not change.
+## Features
 
-## Gateways
+- Several gateways, exactly one active; each keeps its own URL, credential reference, model list and model overrides.
+- Channel-scoped model management: fetch what a gateway lists, choose which models appear in DSH, test one model, remove with undo, add models the gateway does not list.
+- Capability data from models.dev (context window, output cap, modalities, reasoning), correctable per model, with an optional per-model upstream name mapping.
+- Token quota in the settings summary and at the sidebar foot, plus the account balance when the token is allowed to query it.
+- Image generation saved as durable DSH attachments with a generation history; experimental video through the unified `/v1/videos` interface with background polling and restart recovery.
 
-1. **Add gateway**: name, site URL and a New API calling token.
-2. **Test connection** reads the model list only and does not make paid model calls; it also shows the gateway version and model counts.
-3. **Activate** switches every subsequent call made through this plugin, or tick "activate after saving".
-4. Switching never rewrites other adapters or your default provider.
-5. Submitted video tasks keep their originating gateway and are never polled on a newly activated one.
+## Gateways and quota
 
-Legacy flat `baseURL` / `apiKeyEnv` settings are still readable and are migrated to `channels` on the first settings-page save. Tokens live only in the DSH credential service: they are never echoed to the browser, never written into gateway configuration, never sent to a changed address without being re-entered, and are redacted from errors. Configuration writes carry a revision, so a stale editor gets a conflict instead of overwriting another window.
+1. **Test connection** reads the model list only and does not make paid model calls; it also shows the gateway version and model counts.
+2. **Activate** switches every subsequent call made through this plugin, or tick "activate after saving".
+3. Switching never rewrites other adapters or your default provider.
+4. Submitted video tasks keep their originating gateway and are never polled on a newly activated one.
 
-## Balance
+Quota details:
 
 - Quota comes from `GET /api/usage/token/` (note the trailing slash).
 - Amounts are converted with `/api/status` (`quota_per_unit`, `quota_display_type`, `usd_exchange_rate`), never the top-up price.
 - A token that allows user-quota queries also reports the account balance.
+- An unlimited token shows used quota instead of a meaningless negative remainder.
 - Both numbers are the site's own; a present catalog or balance does not prove an upstream channel can serve a model.
 
+The sidebar shows the active gateway's name and amount, with a health dot; click it to refresh. It collapses to a status dot when the sidebar is a rail.
+
 ## Per-gateway model lists
 
 Each gateway keeps an independent list, even when two gateways point at the same site with the same token:
 
 - **Model capabilities tab** has a gateway picker; the active gateway is marked and its list edits apply to that gateway only.
-- **Fetch models** reads the gateway catalog with a search box plus status (new / added / removed upstream) and kind filters; filtering only changes what is listed, never the current selection. The list scrolls on its own and the action bar stays in view.
+- **Fetch models** reads the gateway catalog with a search box plus status (new / added / removed upstream) and kind filters, grouped by kind; filtering only changes what is listed, never the current selection. The list scrolls on its own and the action bar stays in view.
 - **Remove** only removes the model from this gateway; custom parameters can be kept and the removal can be undone briefly.
 - **Add manually** is for models the gateway can serve but does not list.
-- Gateways created in this version start with an empty list; channels saved before the feature existed stay in automatic mode (all gateway models) until their first edit, which materialises the list from what the gateway currently lists.
+- Gateways created in current versions start with an empty list; channels saved before the feature existed stay in automatic mode (all gateway models) until their first edit, which materialises the list from what the gateway currently lists.
 
 ## Testing models
 
@@ -79,7 +80,38 @@ Each gateway keeps an independent list, even when two gateways point at the same
 - **Upstream model name** (`upstreamModel`): the `model` actually sent. Empty means the local id. Mapping is one hop and applies to chat, image generation, image edits, video and model tests.
 - The editor previews the mapping, resolves automatic protocol/capabilities/pricing from the mapping target, and lets input modalities and reasoning follow the catalog or be pinned. Reset clears every override including the mapping.
 
-Capability data is a hint, not proof: a relay may list a model and still fail to serve it. DSH chat currently accepts text and image input only; PDF, audio and video tags are informational.
+Capability data is a hint, not proof: a relay may list a model and still fail to serve it.
+
+## Thinking levels
+
+Vendors do not agree on reasoning levels, so each model resolves its own set instead of every reasoning model showing the same five:
+
+| Vendor / model | Levels offered | Notes |
+| --- | --- | --- |
+| Claude adaptive thinking (Opus 5 / Sonnet 5 / Fable) | low / medium / high / xhigh / max | no `minimal`, no `off` |
+| Older Claude (budget based) | off / minimal / low / medium / high | mapped to token budgets |
+| GPT-5.1+ / GPT-6 | off / low / medium / high / xhigh / max | `off` is sent as `none`, no `minimal` |
+| GPT-5.0 / o-series | minimal / low / medium / high | GPT-5.0 cannot be turned off; o-series stops at high |
+| gpt-5-pro | high only | the vendor accepts nothing else |
+| Gemini 3 / 4 | minimal / low / medium / high | `thinking_level` has no off; no xhigh/max |
+| Gemini 2.5 | off / minimal / low / medium / high | budget based; Pro cannot really be switched off |
+| DeepSeek V4 | off / low / high / max | the vendor folds the in-between levels |
+| GLM-5.3 | low / high / max | sending `disabled` errors, so no off |
+| GLM-5.2 | all seven | most levels are folded upstream |
+| Kimi K3 | low / high / max | no medium, cannot be switched off |
+| Qwen3 / unknown | off / minimal / low / medium / high | pi-ai's own default when a model has no levels |
+
+Resolution order: **your override → pi-ai's shipped model data (same model, same behaviour as the built-in provider) → vendor-family default**.
+
+**Model capabilities → Edit model → Thinking levels** opens on a table pre-filled from the model data (turn the switch off to see the detected set read-only). The left column is the level shown in the chat selector — the built-ins (off/minimal/low/medium/high/xhigh/max) or a name you type yourself (1–24 lowercase letters, digits, `-`, `_`); a custom level must carry a value and then appears in the chat selector like any other. The right column is what that level sends upstream; an empty value sends nothing. The mapping is stored per model per gateway and affects only this plugin.
+
+> Limitation: relays rename models (`claude-opus-5-5`), so a family guess fills the gap when the exact id is unknown. Use a custom override if the upstream disagrees. A level only changes the request; whether the upstream honours that depth is up to it.
+
+## Models and modalities
+
+models.dev data is cached. Exact matches win; when nothing matches, defaults apply. Base-model matches, defaults and manual overrides are all marked in the UI. Never treat a guessed capability as something the gateway has proven.
+
+The DSH chat interface currently accepts text and image input only. PDF, audio and video tags are catalog metadata and cannot be sent to a DSH chat. Image and video models serve the generation tools and do not appear as chat models.
 
 ## Tools
 
@@ -94,7 +126,9 @@ Capability data is a hint, not proof: a relay may list a model and still fail to
 
 Settings-page actions and these tools share one service, so nothing can drift between the UI and the agent.
 
-## Paid results (v0.7.1)
+**Image and video generation cost money.** A submission whose outcome is unknown is never resent automatically; check the gateway's task log first. Stopping a local watch does not cancel or refund the upstream task.
+
+## Paid results
 
 - A video submission that loses the connection or returns an unreadable body after HTTP 200 is reported as **submission unknown, possibly billed**, and is never resent automatically.
 - A video that finished upstream but failed to download stays **generated, retrying download**. Only GET requests are retried, against refreshed URLs; when the recovery deadline passes it becomes **generated, download unsuccessful**. Do not regenerate.
@@ -103,10 +137,18 @@ Settings-page actions and these tools share one service, so nothing can drift be
 
 ## Verification status
 
-- Real chat, model discovery, quota and per-channel lists have been exercised against a local New API instance.
+- Real chat, model discovery, quota, per-gateway lists and gateway editing have been exercised against a local New API instance (v1.0.0-rc.45).
 - A real image request was rejected with HTTP 503 (no available upstream channel). Successful paid image generation is therefore **not yet verified**; the attachment pipeline is covered by offline tests.
 - Video is **experimental**: no real video channel was available. Submission, polling, download recovery, restart recovery and duplicate-submission prevention are covered offline only.
-- The settings page has been rendered and checked locally against the plugin stylesheet; final visual acceptance requires the connected DSH window.
+- Only one New API deployment has been tested. Other versions and relays may differ in endpoint details.
+
+## Migrating from the former name (v0.7.0)
+
+The plugin was called `dsh-newapi-studio`. The rename covers the package, the loader row and provider route (`newapi-provider`), the HTTP prefix (`/newapi-provider/api/`) and the data directory (`plugin-data/dsh-newapi-provider`).
+
+To migrate an existing installation, back up the profile patch and plugin data, then keep each channel's id, credential reference, model list and overrides while moving the data directory to the new name. Current releases do not read the old directory automatically. Keep existing credential references even if they contain `STUDIO`: they still hold the working tokens; new references use the `NEWAPI_PROVIDER_` prefix.
+
+Sessions pinned to the old `newapi-studio` route must pick models again under the new route. Other adapters are unaffected. Tool names (`newapi_channels`, `newapi_models`, …) did not change.
 
 ## Development
 
@@ -117,9 +159,11 @@ node --check client.js
 npm pack --dry-run --ignore-scripts
 ```
 
-DSH runtime imports are optional peerDependencies supplied by the host, so no DSH package is installed or copied here. Tests use local fake gateways and never read personal credentials.
+To work on a checkout instead of the published package, install the project directory with DSH's plugin manager.
+
+DSH runtime imports are optional peerDependencies supplied by the host, so no DSH package is installed or copied here. Tests use local fake gateways and never read personal credentials. This repository replaces, rather than depends on, `dsh-gateway-provider`; two adapters cannot own the same provider route.
 
-npm publishing, creating a public repository and marketplace submission are separate manual steps; see [PUBLISHING.md](PUBLISHING.md). Keep personal gateway data, credentials, research notes and session screenshots out of the package.
+Release steps are in [PUBLISHING.md](PUBLISHING.md).
 
 MIT License. Uses public DSH exports and pi-ai protocol implementations; no third-party plugin source is vendored.
 

package/README.zh.md

@@ -2,7 +2,10 @@
 
 [English](README.md) · 中文
 
-DeepSeek Harness 的 New API 渠道与模型工作台。**开发中，尚未发布到 npm。**
+DeepSeek Harness 的 New API 渠道与模型工作台：多网关同一时间激活一个，每个网关独立的模型清单与参数覆盖，额度查询，以及生图与实验性视频生成。
+
+[![npm](https://img.shields.io/npm/v/dsh-newapi-provider.svg)](https://www.npmjs.com/package/dsh-newapi-provider)
+[![license](https://img.shields.io/npm/l/dsh-newapi-provider.svg)](LICENSE)
 
 ![设置 → New API 提供商：渠道与连接](docs/screenshots/channels.png)
 
@@ -16,65 +19,61 @@ DeepSeek Harness 的 New API 渠道与模型工作台。**开发中，尚未发
 
 截图使用插件真实的组件与样式渲染，数据为示例（渠道名、地址、金额均为虚构）。界面跟随 DSH 主题，配色会随你的皮肤和深色模式变化。
 
-## 能做什么
-
-- 保存多个网关，每个渠道独立保存地址、凭据引用与模型参数；一次只激活一个。
-- 在「渠道与连接」中新增、编辑、测试、激活和删除渠道。
-- 查询令牌的剩余额度和已用量；无限额度显示累计已用，不展示无意义的负余额。
-- 从网关发现模型，从 models.dev 补充上下文、输出上限和输入/输出能力。
-- 在「模型能力」中搜索模型，直接编辑上下文、输出上限、模型类型、输入能力与显隐。
-- 生图工具返回 DSH 图片附件；视频工具使用统一 `/v1/videos` 接口后台轮询。
-
-## 环境与安装
-
-目前验证环境为 DSH **0.2.1-rc.2**，Node.js 22.19 或以上；Web 与 Desktop 配置页通过 DSH 原生插槽显示。不需要单独启动网页服务器。
-
-通过 DSH 的插件管理工具安装本地项目目录。安装后刷新现有 DSH 页面，打开「设置 → New API 提供商」。未发布到 npm 前不要直接执行 `npm install dsh-newapi-provider`。
-
-本插件不依赖 `dsh-gateway-provider`。若需要保留旧会话的 provider 名称，可使用相同的 `providerId`，但不能让两个适配器占用同一路由。当前开发安装保留独立的 `newapi-provider` 路由。
+## 安装
 
-## 从旧开发名称迁移（v0.7.0）
+需要 **DSH 0.2.1-rc.1 或以上**（已在 0.2.1-rc.2 验证），Node.js 22.19 或以上。
 
-旧名称为 `dsh-newapi-studio`。此版本统一改为 `dsh-newapi-provider`：配置行与模型路由为 `newapi-provider`，HTTP 接口为 `/newapi-provider/api/`，数据目录为 `plugin-data/dsh-newapi-provider`。
+用 DSH 的插件管理工具安装 `dsh-newapi-provider`，安装后刷新页面，打开「设置 → New API 提供商」。不需要单独启动网页服务器。
 
-已有安装迁移时需先备份配置和数据，再保留各渠道的 ID、凭据引用、模型清单及覆盖参数，将旧数据目录迁移至新名称。不要直接新装后丢弃旧配置；本版本不自动从旧目录读取。既有凭据引用即使含有 `STUDIO` 也应保留，新建引用使用 `NEWAPI_PROVIDER_` 前缀，无需复制令牌。
+1. **添加渠道** —— 填名称、New API 站点地址和调用令牌。
+2. **获取模型列表** —— 读取网关目录，勾选要用的模型。
+3. **激活渠道** —— 本插件的模型路由开始提供这些模型。
 
-使用旧 `newapi-studio` 路由的会话需要重新选择新路由下的模型；其他适配器不受影响。工具名 `newapi_channels`、`newapi_models` 等保持不变。
+令牌存在 DSH 凭据服务里，不写进渠道配置，也不会回传到浏览器。
 
-## 渠道管理
+## 能做什么
 
-1. 点击「添加渠道」，填写名称、New API 站点地址与调用令牌。
-2. 「测试连接」只查询模型目录，不产生生成费用；能列出模型不代表上游渠道实际可调用。
-3. 保存后点击「激活此渠道」，或勾选「保存后激活」。
-4. 切换影响所有通过本插件路由发起的后续调用，不修改官方适配器或其他插件。
-5. 已提交视频任务保持原始渠道，不应转向新激活的网关轮询。
+- 保存多个网关，一次只激活一个；每个渠道独立保存地址、凭据引用、模型清单和模型参数覆盖。
+- 按渠道管理模型：读取网关目录、挑选哪些模型出现在 DSH、单个测试、删除后撤销、手动添加网关未列出的模型。
+- 能力数据来自 models.dev（上下文窗口、输出上限、多模态、推理），可按模型校正，并支持为单个模型设置上游映射名。
+- 设置页汇总和侧栏底部都能看到令牌额度；令牌允许查询用户额度时同时显示账户余额。
+- 生图结果保存为 DSH 附件并进入生成记录；视频使用统一 `/v1/videos` 接口、后台轮询与重启恢复，属实验性能力。
 
-现有单渠道 `baseURL` / `apiKeyEnv` 配置可继续读取；第一次在页面保存渠道时迁移到 `channels` 数组。凭据只经 DSH 凭据服务读写，不在渠道配置中存明文，也不把已有令牌发回浏览器。
+## 渠道与额度
 
-模型覆盖属于渠道；在编辑器里修改参数时，绑定打开编辑器时的渠道。出现配置冲突提示后应刷新再编辑，避免覆盖另一个窗口的修改。
+1. **测试连接**只读取模型目录，不产生生成费用；同时显示网关版本与模型数量。
+2. **激活**切换本插件后续所有调用，或勾选「保存后激活」。
+3. 切换不会修改官方适配器或其他插件。
+4. 已提交的视频任务保持原始渠道，不会转向新激活的网关轮询。
 
-## 额度含义
+额度说明：
 
 - 主接口为 `GET /api/usage/token/`，注意末尾斜杠。
-- 金额换算使用 `/api/status` 的 `quota_per_unit`、`quota_display_type` 和 `usd_exchange_rate`，不使用充值单价 `price`。
-- 在 New API 为令牌开启「允许查询用户额度」后，较新版本可同时返回账户余额。
+- 金额换算使用 `/api/status` 的 `quota_per_unit`、`quota_display_type`、`usd_exchange_rate`，不使用充值单价。
+- 在 New API 为令牌开启「允许查询用户额度」后，可同时返回账户余额。
+- 无限额度令牌显示累计已用，不展示无意义的负余额。
 - 这些数字来自站点；模型目录存在、余额可查，都不保证站点已配置可调用的上游。
 
-## 模型清单与测试（v0.3.0 起，v0.6.0 支持按渠道独立）
+侧栏显示当前激活渠道的名称与金额，带健康状态点，点击即刷新；侧栏收成 56px 窄栏时只保留状态点。
+
+## 模型清单（按渠道独立）
 
 每个渠道独立维护自己的模型清单，即使两个渠道指向同一个站点、使用同一个令牌也互不影响：
 
 - 「模型能力」页顶部有渠道切换器。激活的渠道带标记，编辑只作用于当前选中的渠道。
-- 「获取模型列表」只读取网关目录，可按模型 ID／厂商搜索，并按状态（新增／已添加／网关已下架）和类型（对话／生图／视频／其他）筛选；筛选只影响显示，已勾选的模型不会丢失。列表自身滚动，底部操作栏始终可见。
-- 新增渠道的清单默认为空；旧渠道兼容原自动模式，第一次添加或删除时按网关当前目录物化清单。
+- 「获取模型列表」只读取网关目录，可按模型 ID／厂商搜索，按状态（新增／已添加／网关已下架）和类型（对话／生图／视频／其他）筛选，并按类型分组显示。筛选只影响显示，已勾选的模型不会丢失；列表自身滚动，底部操作栏始终可见。
+- 新增渠道的清单默认为空；旧渠道兼容原有自动模式，第一次添加或删除时按网关当前目录物化清单。
 - 删除只影响当前渠道，不删除上游模型；可以保留自定义参数，并短暂提供撤销。刷新不会把删除的模型自动加回来。
 - 「手动添加」适合网关未列出但可调用的自定义模型。已从网关下架的模型会单独标注，不自动删除。
-- 对话模型测试发送一条很短的真实请求，**会产生调用费用**，显示总耗时、首包时间、最近结果和脱敏错误。首包时间不等于首字时间。
-- 生图／视频测试每次需要二次确认，实际产生一个生成任务；视频提交成功只显示「任务已接受」，不等于生成验证通过。
-- 批量测试只针对当前筛选下的对话模型，最多3个并发。停止阻止后续排队请求；已发出的请求仍会完成并可能计费。
-- 当前测试器支持 OpenAI Chat、Responses 和 Anthropic Messages；Gemini专用协议测试会明确提示暂不支持，不会悄悄换协议测试。
 
-## 模型名称映射（v0.4.0）
+## 模型测试
+
+- 对话模型测试发送一条很短的真实请求，**会产生调用费用**，显示总耗时、首包时间、最近结果和脱敏错误。只有 `[DONE]` 而没有协议响应的流不算成功。
+- 生图／视频测试每次需要二次确认，实际产生一个生成任务。签名图片链接无法安全展示时仍记录为已生成，但不会暴露链接；界面会提示不要因为看不到预览而重复生成。
+- 批量测试只针对当前筛选下的对话模型，最多 3 个并发。停止会阻止后续排队请求；已发出的请求仍会完成并可能计费。
+- 测试器支持 OpenAI Chat、Responses 和 Anthropic Messages；Gemini 专用协议会明确提示暂不支持，不会悄悄换协议。
+
+## 模型名称映射
 
 在模型编辑器的「名称与映射」中，三个名称各司其职：
 
@@ -86,7 +85,32 @@ DeepSeek Harness 的 New API 渠道与模型工作台。**开发中，尚未发
 
 编辑器显示请求映射预览。自动协议、能力、额度参数和定价优先从映射目标补全，手动覆盖仍然优先；输入能力可选自动或自定义，推理支持也可恢复为跟随目录。恢复默认会清除该模型的全部覆盖，包括上游映射。
 
-当前映射有离线回归覆盖；未对真实上游追加付费映射调用。SDK 的模型专属请求兼容逻辑仍可能依赖本地 ID，所以跨厂商或跨模型系列映射需要检查协议、容量和能力是否合适。
+跨厂商或跨模型系列映射需要检查协议、容量和能力是否合适。模型编辑器修改参数时绑定打开时的渠道；出现配置冲突提示应刷新再编辑，避免覆盖另一个窗口的修改。
+
+## 思考等级（v0.9.0）
+
+不同厂商的推理档位并不相同，插件按模型分别解析，不再对所有推理模型显示同一组档位：
+
+| 厂商 / 模型 | 提供的档位 | 说明 |
+| --- | --- | --- |
+| Claude 自适应思考（Opus 5 / Sonnet 5 / Fable） | 低 / 中 / 高 / 很高 / 最高 | 无「最少」，`off` 不提供 |
+| 旧版 Claude（预算式） | 关闭 / 最少 / 低 / 中 / 高 | 按 token 预算换算 |
+| GPT-5.1+ / GPT-6 | 关闭 / 低 / 中 / 高 / 很高 / 最高 | `off` 发 `none`，无「最少」 |
+| GPT-5.0 / o 系列 | 最少 / 低 / 中 / 高 | GPT-5.0 无法关闭；o 系列只到高 |
+| gpt-5-pro | 仅「高」 | 官方只接受 high |
+| Gemini 3 / 4 | 最少 / 低 / 中 / 高 | `thinking_level` 无关闭项；xhigh/max 不存在 |
+| Gemini 2.5 | 关闭 / 最少 / 低 / 中 / 高 | 预算式；Pro 无法真正关闭 |
+| DeepSeek V4 | 关闭 / 低 / 高 / 最高 | 官方会折叠无意义档位 |
+| GLM-5.3 | 低 / 高 / 最高 | 传 `disabled` 会报错，故不提供关闭 |
+| GLM-5.2 | 全部 7 档 | 多数档位会被上游折叠 |
+| Kimi K3 | 低 / 高 / 最高 | 无 medium、无法关闭 |
+| Qwen3 / 未知模型 | 关闭 / 最少 / 低 / 中 / 高 | 无离散档位时沿用 pi-ai 默认 |
+
+解析顺序：**你的自定义覆盖 → pi-ai 自带模型数据（同一模型与官方 provider 行为一致）→ 厂商家族默认**。
+
+在「模型能力 → 编辑模型参数 → 推理等级」里，开关默认打开并预填模型当前档位。左列是对话选择器里的档位（英文），右列是该档位发给网关的参数值，留空表示不发送参数。左列除了 off/minimal/low/medium/high/xhigh/max 内置档位，也可以直接输入自定义名字（1–24 位小写字母、数字、`-`、`_`），自定义档位必须填写参数值，它会像内置档位一样出现在对话选择器里。配置按渠道按模型保存，只影响本插件。
+
+> 限制：中转站的模型 id 常与厂商原名不同（如 `claude-opus-5-5`），无法逐字命中时按家族推断；若上游行为与推断不符，用自定义覆盖修正。思考等级只影响发送给网关的参数，是否能达到该档位仍取决于上游。
 
 ## 模型与多模态
 
@@ -109,20 +133,27 @@ DSH 当前对话接口只支持文本和图片输入。PDF、音频、视频标
 
 **生图和视频可能扣费。** 提交结果不确定时不会自动重新提交；请先到网关任务日志核对。停止本地观察任务不代表取消网关端生成或退款。
 
-## 付费结果保护（v0.7.1）
+## 付费结果保护
 
 - 视频提交在收到响应头后断流、超时或响应不可解析，显示「提交结果未知，可能已计费」；不会自动重发提交。
-- 视频上游已生成、仅下载失败时显示「已生成，等待下载重试」。仅重试 GET 状态/下载，重新获取可能过期的下载链接；下载恢复期限届满则显示「已生成，下载未成功」。不要因此重新生成。
+- 视频上游已生成、仅下载失败时显示「已生成，等待下载重试」。仅重试 GET 状态/下载，并重新获取可能过期的下载链接；下载恢复期限届满则显示「已生成，下载未成功」。不要因此重新生成。
 - 同一任务的并发查询合并为一个请求流程，卸载时中止在途网络请求，防止旧实例覆盖新实例缓存。
-- 模型测试必须有有效协议响应，仅有 `[DONE]` 不算成功。签名图片链接无法安全展示时仍记录已生成，不暴露签名链接；界面明确提示不要因没有预览而重复生成。
-- 本轮只使用离线假网关回归。视频仍属实验性功能，尚无真实视频渠道完成端到端验证。
+- 失败的付费请求不会自动重试。
+
+## 验证范围与限制
 
-## 当前验证范围与限制
+- 对话、模型目录、额度、按渠道独立清单与渠道编辑：已在本地 New API（v1.0.0-rc.45）上验证过。
+- 生图真实调用曾返回 503「无可用渠道」，**真实生成成功尚未验证**；附件保存链路由离线测试覆盖。
+- 视频属**实验性**能力：没有真实上游渠道，只做离线提交、后台轮询、下载恢复、重启恢复与不重复提交测试。
+- 只测过一种 New API 部署；其他版本与中转站的接口细节可能不同。
 
-- 对话、目录与额度：已在本地 New API 上验证过。
-- 生图真实调用曾返回 503「无可用渠道」；模拟网关的附件保存链路通过，真实生成成功尚未验证。
-- 视频没有真实上游渠道，只做离线提交、后台轮询、下载、重启恢复与不重复提交测试，属于实验性能力。
-- 页面最新视觉效果仍需在连接的 DSH 窗口确认；不能以插槽注册成功代替视觉验收。
+## 从旧开发名称迁移（v0.7.0）
+
+旧名称为 `dsh-newapi-studio`。此版本统一改为 `dsh-newapi-provider`：配置行与模型路由为 `newapi-provider`，HTTP 接口为 `/newapi-provider/api/`，数据目录为 `plugin-data/dsh-newapi-provider`。
+
+已有安装迁移时需先备份配置和数据，再保留各渠道的 ID、凭据引用、模型清单及覆盖参数，将旧数据目录迁移至新名称。当前版本不自动从旧目录读取。既有凭据引用即使含有 `STUDIO` 也应保留，新建引用使用 `NEWAPI_PROVIDER_` 前缀，无需复制令牌。
+
+使用旧 `newapi-studio` 路由的会话需要重新选择新路由下的模型；其他适配器不受影响。工具名 `newapi_channels`、`newapi_models` 等保持不变。
 
 ## 开发
 
@@ -133,9 +164,11 @@ node --check client.js
 npm pack --dry-run --ignore-scripts
 ```
 
-无需安装或复制 DSH 官方包；运行时引用通过 optional peerDependencies 声明，由 DSH 宿主提供。测试不依赖真实网关、不读取用户密钥。
+要针对源码目录开发，用 DSH 插件管理工具安装该项目目录，而不是 npm 包。
+
+无需安装或复制 DSH 官方包；运行时引用通过 optional peerDependencies 声明，由 DSH 宿主提供。测试不依赖真实网关、不读取用户密钥。本插件替代而非依赖 `dsh-gateway-provider`，两个适配器不能占用同一路由。
 
-npm 发布、创建公开仓库和插件市场投稿是独立的人工确认步骤，见 [PUBLISHING.md](PUBLISHING.md)。测试与发布包都不应包含个人网关数据、凭据、调研记录或会话截图。
+发布步骤见 [PUBLISHING.md](PUBLISHING.md)。
 
 MIT License。使用 DSH 的公开导出与 pi-ai 协议实现，不包含第三方插件的源码副本。
 

package/client.js

@@ -48,6 +48,17 @@ window.__ModuleLoader__.load({
       reasoning: '推理', noReasoning: '未声明推理', auto: '自动识别', overridden: '已自定义', defaults: '默认值',
       modelEmpty: '没有匹配的模型', noModels: '当前渠道暂无模型目录', hidden: '已隐藏', modelEdit: '编辑模型参数', modelEditHint: '只影响此渠道的该模型；不会修改 New API 站点。',
       kind: '模型类型', displayName: '显示名称', inputModalities: '输入能力', inputHint: 'DSH 对话层支持文本与图片；PDF、音视频标签仅用于展示，不能直接作为对话输入。',
+      reasoningLevels: '推理等级', reasoningLevelsMode: '推理等级模式',
+      levelsAutoHint: '已关闭自定义，按模型自动识别的档位发送；打开开关可以逐个修改。',
+      levelsCustomHint: '下面是从模型数据预填的档位。左侧决定对话里可选什么，右侧是发给网关的参数值；留空表示不发送参数（常用于 off）。不改动就保持跟随模型。',
+      levelsOffered: '将提供',
+      levelsRequired: '至少保留一个档位', level_off: 'off', level_minimal: 'minimal', level_low: 'low', level_medium: 'medium', level_high: 'high', level_xhigh: 'xhigh', level_max: 'max',
+      levelColumn: '档位', apiValueColumn: 'API 参数值', apiValuePlaceholder: '留空则不发送',
+      levelPlaceholder: '档位名，可自定义', levelInvalid: '档位只能用 1-24 位小写字母、数字、- 或 _',
+      levelDuplicate: '档位名重复了', levelNeedsValue: '自定义档位必须填写 API 参数值',
+      levelCustomOption: '自定义…', levelBackToPreset: '改回内置档位',
+      addLevel: '添加档位', removeLevel: '移除该档位',
+      levelsHelp: '不同厂商的推理档位并不相同：这里决定对话里可选哪些档位，以及每个档位发给网关的参数值。关闭开关则跟随模型自动识别。',
       reasoningEnabled: '声明支持推理', hideModel: '隐藏该模型', modelSave: '保存参数', reset: '恢复自动识别',
       resetHint: '清除此渠道中该模型的全部自定义参数。', modelSaved: '模型参数已更新', modelReset: '已恢复自动识别',
       inherited: '留空使用自动识别或默认值', positiveInteger: '请输入大于 0 的整数',
@@ -127,6 +138,17 @@ window.__ModuleLoader__.load({
       reasoning: 'Reasoning', noReasoning: 'No reasoning declared', auto: 'Automatic', overridden: 'Customized', defaults: 'Default',
       modelEmpty: 'No matching models', noModels: 'No model catalog for this gateway', hidden: 'Hidden', modelEdit: 'Edit model', modelEditHint: 'Changes this model on this gateway only, not the New API site.',
       kind: 'Model kind', displayName: 'Display name', inputModalities: 'Input capabilities', inputHint: 'DSH chat accepts text and image. PDF, video and audio tags are informational only.',
+      reasoningLevels: 'Thinking levels', reasoningLevelsMode: 'Thinking level mode',
+      levelsAutoHint: 'Customisation is off: the levels detected for this model are sent as-is. Turn the switch on to edit them.',
+      levelsCustomHint: 'Pre-filled from the model data. The left column decides what the chat selector offers, the right column is the value sent upstream; empty sends nothing (common for off). Leave it untouched to keep following the model.',
+      levelsOffered: 'Offers',
+      levelsRequired: 'Pick at least one thinking level', level_off: 'off', level_minimal: 'minimal', level_low: 'low', level_medium: 'medium', level_high: 'high', level_xhigh: 'xhigh', level_max: 'max',
+      levelColumn: 'Level', apiValueColumn: 'API value', apiValuePlaceholder: 'Empty sends nothing',
+      levelPlaceholder: 'Level name, custom allowed', levelInvalid: 'Levels use 1-24 lowercase letters, digits, - or _',
+      levelDuplicate: 'Duplicate level name', levelNeedsValue: 'A custom level needs an API value',
+      levelCustomOption: 'Custom…', levelBackToPreset: 'Back to built-in levels',
+      addLevel: 'Add level', removeLevel: 'Remove level',
+      levelsHelp: 'Vendors differ: this decides which levels the chat selector offers and what each one sends upstream. Leave the switch off to follow the detected set.',
       reasoningEnabled: 'Declare reasoning support', hideModel: 'Hide model', modelSave: 'Save parameters', reset: 'Use automatic values',
       resetHint: 'Removes all overrides for this model on this gateway.', modelSaved: 'Model parameters updated', modelReset: 'Automatic values restored',
       inherited: 'Leave empty for automatic or default values', positiveInteger: 'Enter a positive integer',
@@ -178,6 +200,7 @@ window.__ModuleLoader__.load({
       useEffect(() => locale?.subscribe(() => rerender((x) => x + 1)), []);
       return (key) => translate?.(key) ?? ZH[key] ?? key;
     }
+    const LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
     const ICONS = {
       plus: 'M12 5v14M5 12h14', refresh: 'M20 7v5h-5M4 17v-5h5M6.1 7a7 7 0 0 1 11.6-1L20 9M4 15l2.3 3a7 7 0 0 0 11.6-1',
       check: 'm5 12 4 4L19 6', close: 'm6 6 12 12M6 18 18 6', edit: 'm15 5 4 4M4 20l4-1L20 7a2.1 2.1 0 0 0-3-3L5 16Z',
@@ -371,6 +394,38 @@ window.__ModuleLoader__.load({
       .nas-side-balance-icon{display:inline-flex;color:var(--nas-sub);flex-shrink:0}
       .nas-side-balance[data-wide=no] .nas-side-balance-btn{justify-content:center;padding:6px 0;gap:0}
       .nas-side-balance[data-wide=no] .nas-side-balance-icon{display:none}
+      /* Level chips: same look as the input-modality toggles. */
+      .nas-chips{display:flex;flex-wrap:wrap;gap:6px;margin-top:8px}
+      .nas-chips .nas-chip,.nas-chips button{display:inline-flex;align-items:center;gap:5px;border:1px solid var(--nas-line);background:var(--nas-bg);color:var(--nas-text);border-radius:7px;padding:4px 9px;font-size:12px;line-height:1.5}
+      .nas-chips button:hover{border-color:var(--nas-brand)}
+      .nas-chips button[aria-pressed=true]{border-color:var(--nas-brand);background:color-mix(in srgb,var(--nas-accent) 7%,transparent);font-weight:550}
+      .nas-chips.readonly .nas-chip{cursor:default;color:var(--nas-sub)}
+      .nas-chips.readonly .nas-chip.on{color:var(--nas-text);border-color:var(--nas-line-strong,var(--nas-line))}
+      /* Reasoning levels: switch + level/value table, mirroring the editor rows. */
+      .nas-levels{display:flex;flex-direction:column;gap:8px;margin-top:14px;padding:12px 13px;border:1px solid var(--nas-line);border-radius:10px;background:var(--nas-raised)}
+      .nas-levels-head{display:flex;align-items:center;justify-content:space-between;gap:12px}
+      .nas-levels-title{display:flex;align-items:center;gap:6px;font-size:12.5px;font-weight:550}
+      .nas-help{display:inline-flex;align-items:center;justify-content:center;width:15px;height:15px;border:1px solid var(--nas-line-strong,var(--nas-line));border-radius:50%;font-size:10px;color:var(--nas-sub);cursor:help}
+      .nas-switch{position:relative;flex-shrink:0;width:38px;height:22px;border:1px solid var(--nas-line);border-radius:999px;background:var(--nas-line);cursor:pointer;transition:background .15s,border-color .15s}
+      .nas-switch>i{position:absolute;top:2px;left:2px;width:16px;height:16px;border-radius:50%;background:#fff;box-shadow:0 1px 2px rgba(0,0,0,.2);transition:transform .15s}
+      .nas-switch.on{background:var(--nas-brand);border-color:var(--nas-brand)}
+      .nas-switch.on>i{transform:translateX(16px)}
+      .nas-switch:disabled{opacity:.5;cursor:default}
+      .nas-levels-table{display:flex;flex-direction:column;gap:8px}
+      .nas-levels-row{display:grid;grid-template-columns:minmax(96px,150px) minmax(0,1fr) 26px;align-items:center;gap:10px}
+      .nas-levels-row.head{font-size:11px;color:var(--nas-sub);padding:0 1px}
+      .nas-levels-row select,.nas-levels-row input{width:100%;min-width:0;border:1px solid var(--nas-line);border-radius:8px;background:var(--dsw-alias-bg-base);color:var(--nas-text);padding:6px 9px;font-size:12.5px;font-family:inherit}
+      .nas-levels-row select:focus-visible,.nas-levels-row input:focus-visible{outline:2px solid var(--nas-brand);outline-offset:1px}
+      .nas-levels-remove{display:inline-flex;align-items:center;justify-content:center;width:26px;height:26px;border:1px solid transparent;border-radius:7px;background:transparent;color:var(--nas-sub);cursor:pointer}
+      .nas-levels-remove:hover:not(:disabled){color:var(--dsw-alias-state-error-primary);border-color:var(--nas-line)}
+      .nas-levels-remove:disabled{opacity:.35;cursor:default}
+      .nas-levels-add{display:inline-flex;align-items:center;gap:6px;align-self:flex-start;border:1px solid var(--nas-line);border-radius:8px;background:var(--dsw-alias-bg-base);color:var(--nas-text);padding:6px 10px;font-size:12px;cursor:pointer}
+      .nas-levels-add:hover:not(:disabled){border-color:var(--nas-brand)}
+      .nas-levels-add:disabled{opacity:.5;cursor:default}
+      .nas-levels-custom{display:flex;align-items:center;gap:6px;min-width:0}
+      .nas-levels-custom input{flex:1;min-width:0}
+      .nas-levels-back{display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;flex-shrink:0;border:1px solid var(--nas-line);border-radius:6px;background:var(--dsw-alias-bg-base);color:var(--nas-sub);cursor:pointer}
+      .nas-levels-back:hover:not(:disabled){color:var(--nas-text);border-color:var(--nas-brand)}
       /* Tooltips: instant, themed, keyboard accessible. */
       .nas [data-tip]{position:relative}
       .nas [data-tip]::after{content:attr(data-tip);position:absolute;z-index:60;bottom:calc(100% + 9px);left:50%;transform:translateX(-50%);width:max-content;max-width:270px;padding:6px 9px;border-radius:7px;border:1px solid var(--nas-line);background:var(--dsw-alias-bg-overlay);color:var(--nas-text);font-size:11px;font-weight:400;line-height:1.55;text-align:left;white-space:pre-line;box-shadow:0 8px 24px color-mix(in srgb,var(--dsw-alias-label-primary) 16%,transparent);opacity:0;pointer-events:none;transition:opacity .12s}
@@ -569,6 +624,117 @@ window.__ModuleLoader__.load({
             : h('div', { className: 'nas-test-error' }, tested.error))
           : h('div', { className: 'nas-note', style: { marginTop: 14 } }, h(Icon, { name: 'info', size: 13 }), t('testHint'))));
     }
+    /**
+     * Reasoning levels: a switch plus a level→wire-value table.
+     * Off = follow what the model declares; on = the table is exactly what ships.
+     */
+    function ReasoningLevelsEditor({ enabled, rows, detected, busy, onToggle, onChange }) {
+      const CUSTOM_CHOICE = '__custom';
+      const t = useT();
+      const setRow = (index, patch) => onChange(rows.map((row, i) => (i === index ? { ...row, ...patch } : row)));
+      // A new row starts on the first preset nobody uses yet; when all seven are taken it
+      // starts as a custom row instead, which is the only case where a name is typed.
+      const add = () => {
+        const free = LEVELS.find((level) => !rows.some((row) => row.level === level));
+        onChange([...rows, free ? { level: free, value: defaultWireFor(free) } : { level: '', value: '' }]);
+      };
+      const used = new Set(rows.map((row) => row.level).filter(Boolean));
+      const problems = rows.map((row) => {
+        if (!row.level) return { row: true };
+        if (!LEVELS.includes(row.level) && !CUSTOM_LEVEL.test(row.level)) return { invalid: true };
+        if (rows.filter((other) => other.level === row.level).length > 1) return { duplicate: true };
+        if (row.value.trim() === '' && !LEVELS.includes(row.level)) return { needsValue: true };
+        return {};
+      });
+      return h('div', { className: 'nas-levels' },
+        h('div', { className: 'nas-levels-head' },
+          h('div', { className: 'nas-levels-title' },
+            h('span', null, t('reasoningLevels')),
+            h('span', { className: 'nas-help', role: 'img', 'aria-label': t('levelsHelp'), 'data-tip': t('levelsHelp'), 'data-tip-align': 'start' }, '?')),
+          h('button', {
+            type: 'button', role: 'switch', 'aria-checked': enabled, 'aria-label': t('reasoningLevelsMode'),
+            className: `nas-switch ${enabled ? 'on' : ''}`, disabled: busy, onClick: onToggle,
+          }, h('i'))),
+        h('div', { className: 'nas-sub' }, enabled ? t('levelsCustomHint') : t('levelsAutoHint')),
+        !enabled && h('div', { className: 'nas-levels-summary', lang: 'en' }, `${t('levelsOffered')}: ${detected.join(' / ') || '—'}`),
+        enabled && h(React.Fragment, null,
+          h('div', { className: 'nas-levels-table' },
+            h('div', { className: 'nas-levels-row head' },
+              h('span', null, t('levelColumn')), h('span', null, t('apiValueColumn')), h('span', { 'aria-hidden': true })),
+            rows.map((row, index) => h('div', { className: 'nas-levels-row', key: `${row.level}-${index}` },
+              LEVELS.includes(row.level)
+                ? h('select', {
+                  value: row.level, disabled: busy, lang: 'en', 'aria-label': t('levelColumn'),
+                  onChange: (e) => setRow(index, e.target.value === CUSTOM_CHOICE
+                    ? { level: '' }                                  // switch this row to a typed name
+                    : { level: e.target.value, value: row.value || defaultWireFor(e.target.value) }),
+                },
+                LEVELS.map((level) => h('option', {
+                  key: level, value: level, lang: 'en',
+                  disabled: level !== row.level && used.has(level),
+                }, level)),
+                h('option', { value: CUSTOM_CHOICE }, t('levelCustomOption')))
+                : h('div', { className: 'nas-levels-custom' },
+                  h('input', {
+                    value: row.level, disabled: busy, lang: 'en', spellCheck: false, autoFocus: true,
+                    placeholder: t('levelPlaceholder'), 'aria-label': t('levelColumn'),
+                    'aria-invalid': Boolean(problems[index].invalid || problems[index].duplicate),
+                    onChange: (e) => setRow(index, { level: e.target.value.trim().toLowerCase() }),
+                  }),
+                  h('button', { type: 'button', className: 'nas-levels-back', disabled: busy,
+                    'aria-label': t('levelBackToPreset'), 'data-tip': t('levelBackToPreset'), 'data-tip-align': 'end',
+                    onClick: () => {
+                      const free = LEVELS.find((level) => !used.has(level));
+                      setRow(index, free ? { level: free, value: defaultWireFor(free) } : { level: LEVELS[0], value: defaultWireFor(LEVELS[0]) });
+                    } }, h(Icon, { name: 'refresh', size: 12 }))),
+              h('input', {
+                value: row.value, disabled: busy, lang: 'en', spellCheck: false, placeholder: t('apiValuePlaceholder'),
+                'aria-label': t('apiValueColumn'), onChange: (e) => setRow(index, { value: e.target.value }),
+              }),
+              h('button', {
+                type: 'button', className: 'nas-levels-remove', disabled: busy || rows.length <= 1,
+                'aria-label': t('removeLevel'), 'data-tip': t('removeLevel'), 'data-tip-align': 'end',
+                onClick: () => onChange(rows.filter((_, i) => i !== index)),
+              }, h(Icon, { name: 'trash', size: 13 })))),
+          h('button', { type: 'button', className: 'nas-levels-add', disabled: busy || rows.length >= LEVELS.length, onClick: add },
+            h(Icon, { name: 'plus', size: 13 }), t('addLevel')),
+          !rows.length && h('span', { className: 'nas-field-error' }, t('levelsRequired')))));
+    }
+    /** Level→wire map to editable rows; falls back to the detected set when nothing is pinned. */
+    function rowsFromMap(map, detectedLevels, detectedMap) {
+      if (map && Object.keys(map).length) {
+        const names = Object.keys(map).filter((l) => typeof map[l] === 'string');
+        return orderLevelNames(names).map((l) => ({ level: l, value: map[l] }));
+      }
+      const levels = detectedLevels ?? [];
+      return levels.map((l) => ({ level: l, value: (detectedMap && typeof detectedMap[l] === 'string') ? detectedMap[l] : defaultWireFor(l) }));
+    }
+    /** Preset levels first, then custom names — the same order the server resolves. */
+    function orderLevelNames(names) {
+      const preset = LEVELS.filter((l) => names.includes(l));
+      const custom = names.filter((l) => !LEVELS.includes(l)).sort();
+      return [...preset, ...custom];
+    }
+    /** A custom level name must be a safe id; presets are always allowed. */
+    const CUSTOM_LEVEL = /^[a-z0-9][a-z0-9_-]{0,23}$/;
+    /** Rows to the override map. A blank value means "this level sends nothing" (e.g. off). */
+    function rowsToMap(rows) {
+      const map = {};
+      for (const row of rows) map[row.level] = row.value.trim() ? row.value.trim() : null;
+      return map;
+    }
+    /** True when two level maps say the same thing (null and absent both mean "hidden"). */
+    function sameLevelMap(a, b) {
+      const read = (map, level) => {
+        const value = map ? map[level] : undefined;
+        return typeof value === 'string' ? value : null;
+      };
+      return LEVELS.every((level) => read(a, level) === read(b, level));
+    }
+    /** Wire value a level usually needs when the user adds it by hand. */
+    function defaultWireFor(level) {
+      return level === 'off' ? '' : level;
+    }
     function ModelEditor({ model, channel, revision, siblings = [], onClose, onSaved }) {
       const t = useT(); const id = useId(); const a = useAction();
       const initial = model.override || {};
@@ -581,6 +747,9 @@ window.__ModuleLoader__.load({
         inputMode: Array.isArray(initial.input) ? 'custom' : 'auto',
         input: [...(initial.input ?? automaticInput)],
         reasoningMode: initial.reasoning == null ? 'auto' : initial.reasoning ? 'on' : 'off',
+        levelsMode: 'custom',
+        // Custom rows: level id plus the wire value it sends ('' means "no value", i.e. off/none).
+        rows: rowsFromMap(initial.thinkingLevelMap, model.automaticReasoningLevels, model.automaticThinkingLevelMap),
         hidden: Boolean(initial.hidden),
       });
       const original = useRef(JSON.stringify(form)); const dirty = original.current !== JSON.stringify(form);
@@ -593,6 +762,13 @@ window.__ModuleLoader__.load({
         if (a.pending) return;
         for (const k of ['contextWindow', 'maxTokens']) if (form[k] && (!/^\d+$/.test(form[k]) || Number(form[k]) < 1 || !Number.isSafeInteger(Number(form[k])))) return setInvalid(t('positiveInteger'));
         if (form.upstreamModel.trim() && (/\s|[\u0000-\u001f\u007f-\u009f]/u.test(form.upstreamModel.trim()) || form.upstreamModel.trim().length > 500)) return setInvalid(t('invalidMapping'));
+        if (form.levelsMode === 'custom') {
+          const levels = form.rows.map((row) => row.level).filter(Boolean);
+          if (!levels.length) return setInvalid(t('levelsRequired'));
+          if (levels.some((level) => !LEVELS.includes(level) && !CUSTOM_LEVEL.test(level))) return setInvalid(t('levelInvalid'));
+          if (new Set(levels).size !== levels.length) return setInvalid(t('levelDuplicate'));
+          if (form.rows.some((row) => row.level && !LEVELS.includes(row.level) && !row.value.trim())) return setInvalid(t('levelNeedsValue'));
+        }
         const override = { ...initial };
         for (const k of ['name', 'upstreamModel', 'kind', 'protocol', 'contextWindow', 'maxTokens']) {
           const value = form[k].trim();
@@ -600,6 +776,12 @@ window.__ModuleLoader__.load({
         }
         override.input = form.inputMode === 'auto' ? null : form.input;
         override.reasoning = form.reasoningMode === 'auto' ? null : form.reasoningMode === 'on';
+        // A table that still matches what the model declares is not an override: keeping it
+        // null means the levels keep following pi-ai's data instead of freezing today's copy.
+        override.reasoningLevels = null;
+        const edited = rowsToMap(form.rows);
+        const detected = model.automaticThinkingLevelMap;
+        override.thinkingLevelMap = sameLevelMap(edited, detected) ? null : edited;
         override.hidden = form.hidden ? true : null;
         return a.run(async () => { await store.mutate('model/override', { revision, channelId: channel.id, modelId: model.id, override }); onSaved(false); });
       };
@@ -637,7 +819,15 @@ window.__ModuleLoader__.load({
           })),
           h('div', { className: 'nas-note', style: { marginTop: 8, marginBottom: 16 } }, t('inputHint')),
           h(Field, { label: t('reasoning'), htmlFor: `${id}-reasoning` }, h('select', { id: `${id}-reasoning`, value: form.reasoningMode, onChange: changed('reasoningMode'), disabled: a.pending },
-            h('option', { value: 'auto' }, `${t('followAuto')} · ${t((model.automaticReasoning ?? model.reasoning) ? 'enableReasoning' : 'disableReasoning')}`), h('option', { value: 'on' }, t('enableReasoning')), h('option', { value: 'off' }, t('disableReasoning'))))),
+            h('option', { value: 'auto' }, `${t('followAuto')} · ${t((model.automaticReasoning ?? model.reasoning) ? 'enableReasoning' : 'disableReasoning')}`), h('option', { value: 'on' }, t('enableReasoning')), h('option', { value: 'off' }, t('disableReasoning')))),
+          (form.reasoningMode !== 'off') && h(ReasoningLevelsEditor, {
+            enabled: form.levelsMode === 'custom',
+            rows: form.rows,
+            detected: model.automaticReasoningLevels ?? [],
+            busy: a.pending,
+            onToggle: () => setForm({ ...form, levelsMode: form.levelsMode === 'custom' ? 'auto' : 'custom' }),
+            onChange: (rows) => setForm({ ...form, rows }),
+          })),
         h('details', { className: 'nas-editor-advanced' }, h('summary', null, t('advancedOptions')),
           h('div', { className: 'nas-two' },
             h(Field, { label: t('kind'), htmlFor: `${id}-kind` }, h('select', { id: `${id}-kind`, value: form.kind, onChange: changed('kind'), disabled: a.pending }, h('option', { value: '' }, t('auto')), ['chat', 'image', 'video', 'audio', 'embedding', 'other'].map((k) => h('option', { key: k, value: k }, t(k))))),
@@ -1032,6 +1222,7 @@ window.__ModuleLoader__.load({
                 m.kind === 'chat' ? `${t('context')}: ${m.effectiveContextWindow} / ${t('maxOutput')}: ${m.effectiveMaxTokens}` : t(m.kind),
                 `${t('source')}: ${m.source?.modelsDev?.provider || t('defaults')} · ${t(m.source?.modelsDev ? m.source.modelsDev.match === 'prefix' ? 'originPrefix' : 'originExact' : 'originNone')}`,
                 m.source?.overridden?.length ? `${t('overridden')}: ${m.source.overridden.join(', ')}` : null,
+                m.reasoning && m.reasoningLevels?.length ? `${t('reasoningLevels')}: ${m.reasoningLevels.map((l) => t('level_' + l)).join(' / ')}` : null,
               ].filter(Boolean).join('\n') },
                 m.kind === 'chat' ? h('span', { className: 'nas-cap-numbers' }, tokens(m.effectiveContextWindow), h('span', { className: 'nas-cap-divider' }, ' / '), tokens(m.effectiveMaxTokens)) : h('span', null, t(m.kind)),
                 h('span', { className: 'nas-cap-icons' },
@@ -1086,7 +1277,7 @@ window.__ModuleLoader__.load({
       const modelChannel = channels.find((c) => c.id === modelChannelId) || active;
       const count = (kind) => entries.filter((e) => e.kind === kind).length;
       const operate = (path, ch, key) => a.run(async () => { await store.mutate(path, { id: ch.id, revision: state.revision }); notify(key); });
-      return h('div', { className: 'nas nas-page', 'data-newapi-provider-version': '0.8.3' }, h(Styles), header,
+      return h('div', { className: 'nas nas-page', 'data-newapi-provider-version': '0.9.4' }, h(Styles), header,
         notice && h('div', { className: 'nas-feedback', role: 'status' }, h(Icon, { name: 'check', size: 14 }), notice),
         h(ErrorText, { text: a.error || error }),
         h('div', { className: 'nas-summary' },

package/index.js

@@ -45,6 +45,8 @@ const ModelOverride = z.object({
   input: z.array(z.union(MODALITIES)).default(undefined).description('Input modalities the model accepts.'),
   reasoning: z.boolean().description('Whether the model supports reasoning effort.'),
   reasoningLevels: z.array(z.union(LEVELS)).default(undefined).description('Reasoning effort levels to offer.'),
+  thinkingLevelMap: z.dict(z.union([z.string(), z.const(null)])).default(undefined)
+    .description('Per-level wire value: a string is sent upstream, null hides the level. Omitted levels fall back to the detected value.'),
   protocol: z.union(ENDPOINT_TYPES).description('Force the wire protocol for this model.'),
   custom: z.boolean().description('Add this model even if the gateway does not list it.'),
 });
@@ -461,9 +463,10 @@ export function apply(ctx, config) {
       fetchedAt: value.fetchedAt,
       pricingAvailable: value.pricingAvailable,
       pricingError: value.pricingError,
-      entries: value.entries.map((e) => ({
+      entries: value.entries.map(({ thinkingLevelMap, ...e }) => ({   // the map is wire detail; the UI gets the same data under its own name
         ...e,
         // Own-property read: built-in names such as `toString` are legal model ids.
+        automaticThinkingLevelMap: thinkingLevelMap ?? null,
         override: structuredClone(Object.hasOwn(captured.models ?? {}, e.id) ? captured.models[e.id] : {}),
         automaticContextWindow: e.automaticContextWindow ?? conn.defaultContextWindow,
         automaticMaxTokens: e.automaticMaxTokens ?? conn.defaultMaxTokens,
@@ -612,6 +615,8 @@ export function apply(ctx, config) {
             input: e.input,
             output: e.outputModalities,
             reasoning: e.reasoning,
+            reasoningLevels: e.reasoningLevels ?? [],
+            reasoningLevelsSource: e.reasoningLevelsSource ?? 'default',
             endpointTypes: e.endpointTypes,
             vendor: e.vendor,
             pricing: e.pricing,

package/lib/adapter.js

@@ -41,9 +41,14 @@ function baseUrlFor(baseURL, api) {
   return api === 'openai-completions' || api === 'openai-responses' ? openaiBase(baseURL) : gatewayRoot(baseURL);
 }
 
-/** Reasoning level map: explicit override levels, else "reasoning on" defaults. */
+/**
+ * Reasoning level map. The catalog resolves it per model — the user's override,
+ * pi-ai's own data for that id, or a vendor-family default — so pi-ai hides the
+ * levels this model cannot express instead of offering the same five everywhere.
+ */
 function thinkingLevelMap(entry) {
   if (!entry.reasoning) return undefined;
+  if (entry.thinkingLevelMap) return entry.thinkingLevelMap;
   if (!entry.reasoningLevels?.length) return undefined;
   const allowed = new Set(entry.reasoningLevels);
   return Object.fromEntries(LEVELS.map((l) => [l, allowed.has(l) ? l : null]));
@@ -163,9 +168,15 @@ export class NewApiAdapter extends LlmAdapter {
   async modelInfo(bound, provider, model, signal) {
     const info = await bound.inner.resolveModel(provider, model, signal);
     const entry = bound.catalog.entries.find((e) => e.id === model);
-    if (entry?.reasoningLevels?.length) info.reasoning = {
-      efforts: entry.reasoningLevels.map((l) => ({ id: ReasoningEffortId(l), name: l.charAt(0).toUpperCase() + l.slice(1) })),
-    };
+    // Report exactly the levels the request path can express: DSH rejects an effort
+    // it did not advertise, and clamps nothing, so these two must agree.
+    if (entry?.reasoning && entry.reasoningLevels?.length) {
+      const names = { off: 'Off', minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'Extra high', max: 'Max' };
+      info.reasoning = {
+        efforts: entry.reasoningLevels.map((l) => ({ id: ReasoningEffortId(l), name: names[l] ?? l })),
+        ...(entry.reasoningLevels.includes('medium') ? { defaultEffort: ReasoningEffortId('medium') } : {}),
+      };
+    }
     if (entry?.maxTokens) info.defaultMaxTokens = entry.maxTokens;
     return info;
   }

package/lib/catalog.js

@@ -11,6 +11,7 @@
  * other) so chat models go to the picker and media models go to the tools.
  */
 import { fetchJson, gatewayRoot } from './util.js';
+import { LevelCatalog, resolveReasoningLevels } from './levels.js';
 
 export const DEFAULT_CONTEXT_WINDOW = 128_000;
 export const DEFAULT_MAX_TOKENS = 32_768;
@@ -44,9 +45,10 @@ function prettyName(id) {
 }
 
 export class Catalog {
-  constructor({ modelsDev, logger }) {
+  constructor({ modelsDev, logger, levels }) {
     this.modelsDev = modelsDev;
     this.logger = logger;
+    this.levels = levels ?? new LevelCatalog();
     this.cache = new Map();
     this.epoch = 0;
   }
@@ -81,11 +83,32 @@ export class Catalog {
     if (!force && hit && Date.now() - hit.at < CATALOG_TTL_MS && hit.overridesRev === conn.overridesRev) return hit.value;
     void this.modelsDev.refresh();
     const raw = await this.fetchGateway(conn, apiKey, signal);
-    const value = this.build(conn, raw);
+    const value = this.build(conn, raw, await this.resolveLevels(conn, raw));
     if (epoch === this.epoch) this.cache.set(key, { at: Date.now(), value, overridesRev: conn.overridesRev });
     return value;
   }
 
+  /**
+   * Reasoning levels for every id the catalog will contain, resolved before the
+   * synchronous build so each entry can carry its exact selector.
+   */
+  async resolveLevels(conn, { models }) {
+    const overrides = conn.overrides ?? {};
+    const ids = new Set((models?.data ?? []).map((m) => m?.id).filter(Boolean));
+    for (const [id, ov] of Object.entries(overrides)) if (ov?.custom === true) ids.add(id);
+    const out = new Map();
+    await Promise.all([...ids].map(async (id) => {
+      const own = Object.hasOwn(overrides, id) ? overrides[id] : undefined;
+      const override = Array.isArray(own?.reasoningLevels) && own.reasoningLevels.length ? own.reasoningLevels : undefined;
+      const overrideMap = own?.thinkingLevelMap && Object.keys(own.thinkingLevelMap).length ? own.thinkingLevelMap : undefined;
+      const hasOverride = Boolean(override || overrideMap);
+      const effective = await resolveReasoningLevels({ id, override, overrideMap, catalog: this.levels });
+      const automatic = hasOverride ? await resolveReasoningLevels({ id, catalog: this.levels }) : effective;
+      out.set(id, { effective, automatic });
+    }));
+    return out;
+  }
+
   /** Last good catalog for a connection without network, if any. */
   key(conn) {
     return JSON.stringify([conn.channelId, gatewayRoot(conn.baseURL), conn.keyFingerprint, conn.overridesRev, conn.headers, conn.enabledModels ?? null]);
@@ -95,7 +118,7 @@ export class Catalog {
     return this.cache.get(this.key(conn))?.value;
   }
 
-  build(conn, { models, pricing, pricingError }) {
+  build(conn, { models, pricing, pricingError }, levelInfo = new Map()) {
     const priced = new Map();
     for (const p of pricing?.data ?? []) priced.set(p.model_name, p);
     const vendors = new Map((pricing?.vendors ?? []).map((v) => [v.id, v.name]));
@@ -146,7 +169,11 @@ export class Catalog {
         automaticReasoning: dev?.reasoning ?? false,
         outputModalities: dev?.outputModalities ?? [],
         reasoning: ov.reasoning ?? dev?.reasoning ?? false,
-        reasoningLevels: ov.reasoningLevels,
+        // Only a reasoning model has a selector; image/embedding models show none.
+        reasoningLevels: (ov.reasoning ?? dev?.reasoning ?? false) ? levelInfo.get(id)?.effective.levels : [],
+        automaticReasoningLevels: (ov.reasoning ?? dev?.reasoning ?? false) ? levelInfo.get(id)?.automatic.levels : [],
+        reasoningLevelsSource: levelInfo.get(id)?.effective.source ?? 'default',
+        thinkingLevelMap: levelInfo.get(id)?.effective.map,
         source: {
           gateway: Boolean(localGatewayEntry),
           upstreamGateway: gateway.has(upstreamModel),

package/lib/channels.js

@@ -45,12 +45,26 @@ export function resolveChannels(raw = {}) {
 }
 
 /** Merge only supplied fields; null removes one override, reset removes the whole override. */
+/** A level map may only key known levels, and each value is a wire string or null. */
+function isValidLevelMap(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const entries = Object.entries(value);
+  if (!entries.length) return false;
+  return entries.every(([level, mapped]) => {
+    const known = LEVELS.includes(level);
+    // Custom names must be a safe id and must carry a value: that value is the whole point.
+    if (!known && !/^[a-z0-9][a-z0-9_-]{0,23}$/.test(level)) return false;
+    if (mapped === null) return known;
+    return typeof mapped === 'string' && mapped.length > 0 && mapped.length <= 64 && !/[\u0000-\u001f\u007f-\u009f]/.test(mapped);
+  });
+}
+
 export function mergeModelOverride(previous, patch, reset = false) {
   if (reset) return undefined;
   if (!patch || typeof patch !== 'object' || Array.isArray(patch)) throw channelError(400, 'override must be an object');
   const next = { ...previous };
   for (const [key, value] of Object.entries(patch)) {
-    if (!['name', 'upstreamModel', 'kind', 'hidden', 'contextWindow', 'maxTokens', 'input', 'reasoning', 'reasoningLevels', 'protocol', 'custom'].includes(key)) {
+    if (!['name', 'upstreamModel', 'kind', 'hidden', 'contextWindow', 'maxTokens', 'input', 'reasoning', 'reasoningLevels', 'thinkingLevelMap', 'protocol', 'custom'].includes(key)) {
       if (Object.hasOwn(previous ?? {}, key) && JSON.stringify(value) === JSON.stringify(previous[key])) continue;
       throw channelError(400, `unsupported override field: ${key}`);
     }
@@ -62,6 +76,7 @@ export function mergeModelOverride(previous, patch, reset = false) {
     else if (key === 'upstreamModel') valid = typeof value === 'string' && value.trim().length > 0 && value.length <= 500 && !/[\u0000-\u001f\u007f-\u009f]/.test(value);
     else if (key === 'kind') valid = KINDS.includes(value);
     else if (key === 'protocol') valid = PROTOCOLS.includes(value);
+    else if (key === 'thinkingLevelMap') valid = isValidLevelMap(value);
     else valid = Array.isArray(value) && value.every((v) => (key === 'input' ? MODALITIES : LEVELS).includes(v));
     if (!valid) throw channelError(400, `invalid override field: ${key}`);
     next[key] = ['name', 'upstreamModel'].includes(key) ? value.trim() : value;

package/lib/levels.js

@@ -0,0 +1,235 @@
+/**
+ * Reasoning ("thinking") levels per model.
+ *
+ * pi-ai renders a level selector from `thinkingLevelMap`: a `null` value hides that
+ * level, a string maps it to the vendor's own vocabulary, and an absent key falls
+ * back to the provider default. Without a map every reasoning model advertises the
+ * same five levels (`off`, `minimal`, `low`, `medium`, `high`) — which is wrong for
+ * vendors that cannot turn thinking off, have no effort parameter at all, or support
+ * `xhigh`/`max`.
+ *
+ * Resolution order, highest precedence first:
+ *   1. the user's per-model override (`reasoningLevels` in the channel config),
+ *   2. pi-ai's own shipped catalog for that model id — the exact map the built-in
+ *      providers use, so a model here behaves like the same model there,
+ *   3. a vendor-family default (below) when the id is a relay alias the catalog
+ *      does not know,
+ *   4. the pi-ai default (no map at all) for anything unrecognised.
+ */
+
+/** pi-ai's built-in level vocabulary, in display order. Custom names may be added on top. */
+export const LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+/** A level id: the built-ins, or a user-chosen name the upstream understands. */
+export const CUSTOM_LEVEL = /^[a-z0-9][a-z0-9_-]{0,23}$/;
+
+/** Preset levels first (pi's order), then custom names alphabetically. */
+export function orderLevels(names) {
+  const preset = LEVELS.filter((level) => names.includes(level));
+  const custom = names.filter((name) => !LEVELS.includes(name)).sort();
+  return [...preset, ...custom];
+}
+
+/** Provider catalogs to consult. Kept small: only vendors a New API relay resells. */
+const CATALOG_PROVIDERS = ['openai', 'anthropic', 'google', 'deepseek', 'zai', 'moonshotai', 'xai', 'minimax', 'alibaba'];
+
+/** First-party provider per model family, used to prefer the right catalog and default. */
+const FAMILY_RULES = [
+  [/^claude|^fable/, 'anthropic'],
+  [/^(gpt|o\d|codex|chatgpt|dall-e)/, 'openai'],
+  [/^gemini|^gemma/, 'google'],
+  [/^deepseek/, 'deepseek'],
+  [/^glm|^cogview|^cogvideo/, 'zai'],
+  [/^(kimi|moonshot)/, 'moonshotai'],
+  [/^grok/, 'xai'],
+  [/^(minimax|abab|hailuo)/, 'minimax'],
+  [/^(qwen|qwq|wan)/, 'alibaba'],
+];
+
+/**
+ * Family defaults for ids the catalog does not know (relay aliases such as
+ * `claude-opus-5-5` or `deepseek-v4.1-flash`). Each entry mirrors the shape pi-ai
+ * ships for that family; `null` hides a level, a string is sent upstream.
+ */
+const FAMILY_DEFAULTS = [
+  // Adaptive thinking: effort levels, no `minimal`, `max` available on every adaptive model.
+  [/^claude-(opus-([456]-?\d*|5)|sonnet-([456]|4-\d+|[56]-\d+)|fable|mythos)/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  // Budget-based thinking: every level maps to a token budget, so all five apply.
+  // Older/unknown Claude: budget-based thinking covers every level (pi-ai ships no map).
+  [/^claude/, null],
+  // Pro variants expose a narrower set (gpt-5-pro: high only; later pros: medium+).
+  [/^gpt-5-pro/, { off: null, minimal: null, low: null, medium: null, high: 'high', xhigh: null, max: null }],
+  [/^gpt-5[.-][245]-pro/, { off: null, minimal: null, low: null, medium: 'medium', high: 'high', xhigh: 'xhigh', max: null }],
+  [/^gpt-6-astra/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  [/^gpt-6[.-]1/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  // GPT-5.1+ and GPT-6: "none" turns reasoning off; minimal is gone; xhigh/max exist.
+  [/^gpt-(5[.-][1-9]|5[.-]\d\d|6)/, { off: 'none', minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  // GPT-5.0: minimal exists, no xhigh/max.
+  [/^gpt-5/, { off: null, minimal: 'minimal', low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+  // o-series: low/medium/high only.
+  [/^o\d/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+  // Gemini 3: two-step thinking level, cannot be switched off.
+  [/^gemini-[34]/, { off: null, minimal: 'MINIMAL', low: 'LOW', medium: 'MEDIUM', high: 'HIGH', xhigh: null, max: null }],
+  // Gemini 2.5: thinkingBudget; 0 disables it on flash models.
+  // Gemini 2.5 and older: budget-based, no level vocabulary (pi-ai ships no map).
+  [/^gemini/, null],
+  // DeepSeek V4 exposes effort with a gap at `medium`.
+  [/^deepseek/, { minimal: null, medium: null, low: 'low', high: 'high', max: 'max', xhigh: null }],
+  [/^glm-5[.-][3-9]/,  { off: null, minimal: null, low: 'low', medium: null, high: 'high', xhigh: null, max: 'max' }],
+  [/^glm-5[.-]2/,  { off: 'none', minimal: 'minimal', low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh', max: 'max' }],
+  [/^glm-5/, { off: 'none', minimal: null, low: 'low', medium: null, high: 'high', xhigh: null, max: 'max' }],
+  [/^glm/, null],
+  [/^(kimi-k3|moonshot-k3)/, { off: null, minimal: null, low: 'low', medium: null, high: 'high', xhigh: null, max: 'max' }],
+  [/^(kimi|moonshot)/, null],
+  [/^grok-4\.[5-9]/, { off: null, minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+  [/^grok/, { off: 'none', minimal: null, low: 'low', medium: 'medium', high: 'high', xhigh: null, max: null }],
+];
+
+/** Normalise an id for catalog comparison: case, dots/underscores, vendor prefixes. */
+function normalize(id) {
+  return String(id).toLowerCase().split('/').pop().replace(/[._]/g, '-');
+}
+
+/** Index one provider catalog by its normalised ids. */
+function indexCatalog(catalog) {
+  const index = new Map();
+  for (const model of Object.values(catalog ?? {})) {
+    if (!model?.id) continue;
+    const key = normalize(model.id);
+    if (!index.has(key)) index.set(key, model);
+  }
+  return index;
+}
+
+/**
+ * Lazily loads and indexes pi-ai's shipped catalogs. Import failures are not fatal:
+ * the family defaults still give a model the right level set.
+ */
+export class LevelCatalog {
+  constructor({ providers = CATALOG_PROVIDERS } = {}) {
+    this.providers = providers;
+    this.index = undefined;
+    this.loading = undefined;
+    this.byFamily = new Map();
+  }
+
+  async load() {
+    if (this.index) return this.index;
+    this.loading ??= (async () => {
+      const index = new Map();
+      for (const name of this.providers) {
+        try {
+          const mod = await import(`@earendil-works/pi-ai/providers/${name}.models`);
+          for (const value of Object.values(mod)) {
+            const models = indexCatalog(value);
+            for (const [key, model] of models) if (!index.has(key)) index.set(key, model);
+          }
+        } catch { /* that provider catalog is absent in this pi-ai build */ }
+      }
+      this.index = index;
+      return index;
+    })();
+    return this.loading;
+  }
+
+  familyOf(id) {
+    const key = normalize(id);
+    for (const [re, provider] of FAMILY_RULES) if (re.test(key)) return provider;
+    return undefined;
+  }
+
+  /**
+   * pi-ai's own entry for this id: exact, then progressively shorter prefixes so a
+   * relay variant (`claude-opus-5-5`, `claude-sonnet-5-5-high`) lands on its base model.
+   */
+  async find(id) {
+    const index = await this.load();
+    const key = normalize(id);
+    const exact = index.get(key);
+    if (exact) return { model: exact, match: 'exact' };
+    const parts = key.split('-');
+    for (let n = parts.length - 1; n >= 2; n--) {
+      const hit = index.get(parts.slice(0, n).join('-'));
+      if (hit) return { model: hit, match: 'prefix' };
+    }
+    return undefined;
+  }
+
+  /** Family default map, or `undefined` when the family keeps the pi-ai default. */
+  familyDefault(id) {
+    const key = normalize(id);
+    if (this.byFamily.has(key)) return this.byFamily.get(key);
+    let map;
+    for (const [re, value] of FAMILY_DEFAULTS) if (re.test(key)) { map = value; break; }
+    this.byFamily.set(key, map);
+    return map;
+  }
+}
+
+/**
+ * Levels a map exposes, in pi-ai display order. `off`/`minimal`/`low`/`medium`/`high`
+ * are shown unless explicitly `null`; `xhigh`/`max` only when mapped.
+ */
+export function levelsFromMap(map) {
+  if (!map) return ['off', 'minimal', 'low', 'medium', 'high'];
+  const names = LEVELS.filter((level) => {
+    const mapped = map[level];
+    if (mapped === null) return false;
+    if (level === 'xhigh' || level === 'max') return mapped !== undefined;
+    return true;
+  });
+  // A custom level exists only when it is mapped to something the upstream accepts.
+  for (const [level, mapped] of Object.entries(map)) {
+    if (LEVELS.includes(level)) continue;
+    if (typeof mapped === 'string' && CUSTOM_LEVEL.test(level)) names.push(level);
+  }
+  return orderLevels(names);
+}
+
+/** Build a pi-ai map that exposes exactly `levels`, keeping `base`'s upstream strings. */
+export function mapFromLevels(levels, base) {
+  if (!Array.isArray(levels) || levels.length === 0) return undefined;
+  const allowed = new Set(levels);
+  const map = {};
+  for (const level of LEVELS) {
+    if (!allowed.has(level)) { map[level] = null; continue; }
+    const mapped = base?.[level];
+    map[level] = typeof mapped === 'string' ? mapped : level;
+  }
+  return map;
+}
+
+/**
+ * Resolve one model's reasoning levels.
+ *
+ * @returns `{ levels, map, source }` where `source` is `override` (user),
+ * `catalog` (pi-ai shipped data), `family` (vendor default) or `default`.
+ */
+export async function resolveReasoningLevels({ id, override, overrideMap, catalog }) {
+  const found = await catalog.find(id);
+  const base = found?.model?.thinkingLevelMap ?? catalog.familyDefault(id);
+  const source = found?.model?.thinkingLevelMap
+    ? 'catalog'
+    : base ? 'family' : 'default';
+  // An explicit level→wire map is authoritative: it is literally what the user configured.
+  if (overrideMap && typeof overrideMap === 'object' && Object.keys(overrideMap).length) {
+    // The table is authoritative: preset levels not listed are hidden, and custom names
+    // are honoured as long as they carry a wire value.
+    const map = {};
+    for (const level of LEVELS) {
+      const mapped = overrideMap[level];
+      map[level] = typeof mapped === 'string' ? mapped : null;
+    }
+    for (const [level, mapped] of Object.entries(overrideMap)) {
+      if (LEVELS.includes(level) || !CUSTOM_LEVEL.test(level)) continue;
+      if (typeof mapped === 'string') map[level] = mapped;
+    }
+    const levels = levelsFromMap(map);
+    // A table that exposes nothing usable is a mistake, not an empty selector: fall back.
+    if (levels.length) return { levels, map, source: 'override' };
+  }
+  if (Array.isArray(override) && override.length) {
+    return { levels: override.filter((l) => LEVELS.includes(l)), map: mapFromLevels(override, base), source: 'override' };
+  }
+  return { levels: levelsFromMap(base), map: base ?? undefined, source };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-newapi-provider",
-  "version": "0.8.3",
+  "version": "0.9.4",
   "description": "New API gateway for DeepSeek Harness: models with context and modality details, balance, image and video generation.",
   "license": "MIT",
   "author": "zenVibeCoding",