dsh-model-think-level 1.0.0 → 1.0.2

package/README.md

@@ -1,164 +1,12 @@
 # DSH Model Think Level
 
-<p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="docs/banner-dark.svg">
-    <img src="docs/banner.svg" alt="DSH Model Think Level" width="720">
-  </picture>
-</p>
+DSH 的第三方模型补齐思考等级：在官方 Models 页每个模型行注入 Thinking 开关和强度/模态编辑器，在输入框模型菜单加供应商→模型选择器、视觉徽章与等级行，并带搜索、拖拽排序、供应商启用开关；以及按路由接管请求头与 user-agent。
 
-[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![npm version](https://img.shields.io/npm/v/dsh-model-think-level)](https://www.npmjs.com/package/dsh-model-think-level)
-[![npm downloads](https://img.shields.io/npm/dw/dsh-model-think-level)](https://www.npmjs.com/package/dsh-model-think-level)
-![DeepSeek Harness](https://img.shields.io/badge/DeepSeek%20Harness-plugin-4d6bfe)
-[![Awesome DSH Plugin](https://awesome-dsh-plugin.com/badge.svg)](https://awesome-dsh-plugin.com)
+模型选择器
+![alt text](./docs/image.png)
+![alt text](./docs/image2.png)
 
-**English** | [中文](README.zh.md)
-
-Thinking levels, vision badges and request headers for **third-party models** in DeepSeek Harness — a provider → model picker with capability icons inside the official composer menu, a one-switch thinking gate plus auto-adapted levels inside the official Models page card, and per-route request headers. A renamed derivative of [dsh-better-reasoning-effort](https://github.com/HaoyueQin/dsh-better-reasoning-effort) — see [Acknowledgements](#acknowledgements).
-
-<p align="center">
-  <img src="docs/demo.svg" alt="demo" width="640">
-</p>
-
-<p align="center">
-  <img src="assets/models-page-effort-editor.png" alt="The thinking-effort editor injected into a model row on the official Models page" width="720">
-</p>
-
-## Why
-
-The `llm-pi-ai` adapter natively supports per-model `reasoningEfforts` and `input` declarations, but the official Models page editor deliberately keeps both fields out of reach. As a result, third-party models get **no thinking-level picker** in the composer, only the official DeepSeek API can set reasoning effort, hand-declared models are treated as **text-only**, and configuring any of this meant hand-writing `settings.yaml` blocks. This plugin brings both configuration surfaces back into the UI: edit inside the official model editor card, plus one-click auto-adapt.
-
-## Features
-
-- **In-page editor** — a **Thinking** switch plus a reasoning-effort block appears under each model row's disclosure on the official Models page (levels, default effort, input modalities, endpoint compatibility), committing with the card's own **Save**; changes stay pending until then, and **Cancel** discards them with the card's fields. The switch sits **outside** that block and gates it: switched off, the model is written as not reasoning and the whole block is not rendered — one row is all an un-thinking model shows.
-- **Auto-adapt** — one click fills recommended levels, wire spellings and modalities from a built-in knowledge base (65 entries across 15 vendors — see [Supported models](docs/supported-models.md)), wire-protocol inference, and a same-origin probe of the provider's raw `/models` listing, every suggestion labeled by confidence; reference capacities show as read-only hints you copy yourself.
-- **Auto-fill** — models without a declaration are filled at boot and when added mid-session (opt out via `autofill: false` / `modalityAutofill: false`); explicit declarations, `false` and deliberately-unset markers are never touched.
-- **Three intents** — all levels off = unset (back to inheritance); only `off` = disable reasoning; levels armed = write the declaration.
-- **Composer model & reasoning rows** — the official model menu's body renders a **Model** row and a **Reasoning level** row. The model row opens a provider column with that provider's models beside it, every entry carrying vision / thinking badges and the current pick marked in accent colour (no tick, so it cannot be mistaken for a badge); the reasoning row opens the model's own level list. The official trigger stays untouched, picks are optimistic and roll back on refusal, the popover stays open after a model switch so the level can be chosen next, and model switches keep your level through a per-session memory chain (issue #4's per-model default effort outranks it across sessions).
-- **Composer model search** — a filter box above the official model list (provider / model / id tokens), always on.
-- **Per-model default effort** — a "Default effort" picker on each model row, stored in the settings document; every new session starts the model there.
-- **Request headers & `user-agent`** — a provider-card section edits the official `headers` field (masked, path-merged, Save-gated), and the plugin performs the `user-agent` override at the fetch layer per **provider route**, because the official adapter reserves that name. Routes that share one endpoint are told apart by their `baseURL` path and by the `model` carried in the request body, so each provider keeps its own identity; a request that identifies no single route falls back to the first declarer and the overlap is reported rather than guessed. Same-origin `/models` probes are covered.
-- **Defensive injection** — everything keys off the official page's DOM; if an official upgrade changes the structure, injection simply pauses and the official page is unaffected.
-- Bilingual copy (中文 / English).
-
-## Supported models
-
-The auto-adapt knowledge base carries **65 curated entries across 15 vendors** (DeepSeek, OpenAI, Anthropic Claude, Gemini, Grok, Qwen, GLM, Kimi, Mistral, MiniMax, MiMo, Doubao, Hunyuan, Step, ERNIE — re-verified against official docs 2026-08/09, including vision-capable variants and no-effort-control families). The full table — match patterns, level → wire-spelling ladders, defaults, modalities, reference capacities — lives in **[docs/supported-models.md](docs/supported-models.md)** (generated from [`src/knowledge.ts`](src/knowledge.ts), the authoritative source). Unlisted models fall back to protocol inference + generic levels, adjustable by hand.
-
-## Install
-
-Requires DeepSeek Harness **`0.1.5-alpha.1` or later** (per-line peer ranges; the `0.1.2-rc` / `0.1.3-alpha` lines are no longer supported — use plugin `0.3.7` there). Compiled and gated against `0.2.0-rc.1`. The per-kernel seam re-checks behind this live in [docs/compatibility-notes.md](docs/compatibility-notes.md).
-
-```bash
-# from npm, under the dsh web profile
-dsh plugin --profile web add dsh-model-think-level
-
-# or from GitHub (source install; `lib/` builds via the prepare hook — the
-# installer prints the `allowBuilds` key it needs, follow that and re-add)
-dsh plugin --profile web add github:GaoHu1997/dsh-model-think-level
-
-# or link a local checkout for development
-npm install && npm run build
-dsh plugin --profile web add link:D:/Project/dsh-model-think-level
-```
-
-Restart `dsh web` and hard-refresh the browser.
-
-## Usage
-
-1. Configure a third-party provider (API key etc.) on the official Models page.
-2. Expand a model row: the **Thinking** switch sits above the effort block, and the block sits under the official capacity fields.
-   - Leave **Thinking** on to configure levels. Switch it **off** and the model is saved as not reasoning — the whole effort block disappears with it, leaving just the switch row.
-   - Check levels (off / minimal / low / medium / high / xhigh / max) and fill the wire values (e.g. give `high` the spelling `ultra`, and the gateway receives `ultra` when you pick High in the composer);
-   - Toggle **Image input** under *Input modalities* to declare what the model accepts;
-   - Click **Auto-adapt** to fill recommended levels and modalities — reference capacities show up as read-only hints you copy into the official fields yourself;
-   - Any change is **pending** and lands when you press the card's own **Save**; **Cancel** (or a reload) discards it with the card's fields.
-3. On a compatible protocol, the *Endpoint compatibility* section appears at the bottom — thinking budget field / vLLM priority on `openai-completions`, `max_output_tokens` handling on `openai-responses`.
-4. All levels off + Save = unset the declaration; only `off` checked + Save = disable reasoning (`false`); *Clear declaration* + Save = back to inheriting the provider default.
-5. In the composer, open the model menu: the **Model** row lists providers on the left and that provider's models on the right — each model carries an eye badge when it accepts images and a sparkle badge when it reasons — and the **Reasoning level** row lists the levels of the current model. Picking a model closes its list but keeps the menu open, so the level can be picked right after.
-
-Declared models are immediately selectable for reasoning effort in the composer, and image-declared models accept attachments end to end.
-
-## Configuration
-
-Optional on the plugin's profile row (values shown are the defaults):
-
-```yaml
-- insert:
-    - id: dsh-model-think-level
-      name: dsh-model-think-level
-      config:
-        autofill: true          # auto-fill undeclared models at boot
-        modalityAutofill: true  # whether the boot fill also covers modalities
-        probeTimeoutMs: 15000   # /models probe fetch timeout
-        bootRetryDelaysMs: [1000, 2000, 4000, 8000, 16000, 30000]
-        defaultGuard: true      # map effort-less calls on forced-thinking
-                                # ladders to the vendor default
-```
-
-## How it works
-
-```
-Browser (lib/client.js)                  Host (lib/index.js)
-├─ DOM injector                          └─ Auto-fill
-│   MutationObserver on the models page      settings/document-updated →
-│   → mounts EffortEditor in each            invalidates the host cache;
-│     model row's disclosure                 browser idle pass fills models
-├─ Composer injection
-│   MutationObserver on the document
-│   → ComposerSlider (root pane)
-│   → model search box (model-list pane)
-├─ EffortEditor (React component)             (knowledge base + inference)
-│   level checkboxes / wire values /
-│   input-modality toggle /
-│   auto-adapt (zoned suggestions) / committed with the card's Save
-│   └─ writes settings.mutate (llm-pi-ai)
-```
-
-- `suggestEfforts()` in `src/knowledge.ts` is the knowledge base + inference engine — a pure function shared by host and browser.
-- `reconcile()` in `src/client/injection/models-page-editor.ts` locates model rows and mounts the editor; `src/client/index.ts` assembles the browser half, one module per seam in `src/client/injection/`.
-- `createEditorApi()` in `src/client/ops.ts` writes the declarations via `settings.mutate`, preserving every other row field and retrying once on a revision conflict.
-
-## Development
-
-```bash
-npm run typecheck   # tsc strict check on src
-npm test            # vitest: knowledge / inference / autofill / DOM injection / writing
-npm run build       # lib/*.js + lib/client.js (module-loader bundle)
-```
-
-Compiled and gated against the `0.2.0-rc.1` official packages; see [docs/compatibility-notes.md](docs/compatibility-notes.md) for the per-kernel records.
-
-## Known limitations
-
-- Injection depends on the official Models page's DOM (aria-label/class); an official upgrade may pause injection until adapted — the official page is unaffected meanwhile.
-- The auto-adapt probe route answers **loopback and IP-literal hosts only** (the core `/api` Host-allowlist discipline without `trustedHosts`), and **never follows redirects** — a gateway listing its models only behind a 30x simply yields no endpoint evidence; Auto-adapt falls back to the knowledge base and protocol inference.
-- `reasoningEfforts` declarations are suggestions — what an endpoint actually accepts is up to its docs; tweak in the UI. The knowledge base is not exhaustive; families without an effort ladder carry no entry at all.
-- Endpoint-compatibility switches are never auto-filled by design: they describe a gateway, not a model.
-- The modality vocabulary follows pi-ai's core (`text` / `image` today); wider gateway support (PDF, audio, video) is recorded per family until the core vocabulary grows.
-- Name-heuristic modality advice (vision-flavored ids) is deliberately low-confidence and labeled as such.
-- Self-hosted relays: auto-fill pins `supportsDeveloperRole: false` on routes no official host claims (some upstreams reject the `developer` role); explicit values are never overwritten.
-- Forced-thinking models (ladders without `off`, e.g. GLM-5.3): effort-less calls map to the vendor default instead of sending `thinking: disabled` — set `defaultGuard: false` to restore raw behavior.
-- **Credentials inside `headers` are not redacted on disk**: the read-only view masks them, but the settings document still holds them in clear text — treat it like an API key.
-- **The request-header section's edit-state detection reads an unofficial signal** (the official row exposes no data attribute for its editor state); if an official build renames that class root, the section stops appearing — never breaking the page.
-- **Only one `user-agent` rewrite should be active**: sibling header plugins land on the same layer; the plugin detects and reports known ones, but the last writer on the wire wins.
-- The request-layer takeover relies on the official adapter creating a fresh SDK client per request — guarded by an end-to-end test that fails loudly if that changes.
-
-## Acknowledgements
-
-This plugin is a renamed derivative of **[dsh-better-reasoning-effort](https://github.com/HaoyueQin/dsh-better-reasoning-effort) by [HaoyueQin](https://github.com/HaoyueQin)** (MIT). The request-header layer, the model knowledge base, the auto-adapt / auto-fill pipeline and the Models-page editor all come from that project — thank you for the original work. What changed here: the composer's effort slider was replaced by a provider → model picker plus a reasoning-level list, model entries gained vision / thinking badges, the selection tick was dropped in favour of an accent colour, and the per-model editor gained the master **Thinking** switch that gates it.
-
-That project's own composer slider was **adapted from [dsh-reasoning-effort](https://github.com/HanaAyane/dsh-reasoning-effort) by [HanaAyane](https://github.com/HanaAyane)** (MIT); it is no longer shipped here, but the credit stands for the lineage. If you used the upstream plugin, remove it to avoid two effort controls on the same seat:
-
-```bash
-dsh plugin --profile web remove dsh-reasoning-effort
-```
-
-## Activity
-
-[![GaoHu1997/dsh-model-think-level GitStock K-Line Chart](https://gitstock.org/GaoHu1997/dsh-model-think-level/stock.svg)](https://gitstock.org/GaoHu1997/dsh-model-think-level/stock.svg)
-
-## License
-
-MIT
+供应商配置
+![alt text](./docs/image3.png)
+![alt text](./docs/image4.png)
+![alt text](./docs/image5.png)

package/lib/client/EffortEditor.d.ts

@@ -14,8 +14,8 @@
  */
 import type { ReactNode } from 'react';
 import type { CompatSuggestion, InputModalities, ReasoningEfforts } from '../knowledge.js';
-import { type DraftLevels } from './effort.js';
-import type { EffortEditorApi } from './types.js';
+import { type DraftLevels, type EffortIntent } from './effort.js';
+import type { EffortEditorApi, EffortWriteIntent, PendingWrite, PendingWriteParts } from './types.js';
 /** One model row's data the editor needs. */
 export interface EffortModel {
     /** Model id (the settings key). */
@@ -77,6 +77,17 @@ export interface EffortEditorProps {
     /** Localized copy. */
     t: (key: string, params?: Record<string, string | number>) => string;
 }
+/** Draft state of the modality part: declared or inheriting, image or not. */
+export interface DraftModality {
+    declared: boolean;
+    image: boolean;
+}
+/** Read the stored declaration into a draft. Empty mirrors undefined: the
+ * resolved settings layer materializes absent arrays as [], and core reads
+ * that as "no answer here" -- never as a phantom text-only declaration. */
+export declare function modalityFrom(input: InputModalities | undefined): DraftModality;
+/** Resolve a modality draft to the write intent (null = durably unset). */
+export declare function buildModalityIntent(draft: DraftModality): InputModalities | null;
 /**
  * The compat fields this editor can SET, per protocol — which is also the set
  * it may clear. A key from neither list survives an apply untouched: a
@@ -103,6 +114,47 @@ export declare function clearedCompatKeys(routeApi: string | undefined, draft: C
 export declare function compatClearIntent(routeApi: string | undefined, writeCompat: CompatSuggestion | undefined): {
     clearCompatKeys?: readonly string[];
 };
+/** Semantic equality between a modality draft and a stored declaration. */
+export declare function sameModality(draft: DraftModality, stored: InputModalities | undefined): boolean;
+/**
+ * The ladder part of a write, from a switch state and the draft it resolves to.
+ *
+ * `'keep'` when nothing is armed and nothing is stored: that is a no-op, NOT an
+ * unset — an undefined there would stamp the durable unset marker onto a
+ * never-declared model and silence host auto-fill.
+ * @param nextThinking - the (pre-update) switch state the edit resolved to.
+ * @param built - `buildIntent` of the draft the edit resolved to, which is the
+ *   explicit `false` when the only armed level is 'off'.
+ * @param initialEfforts - the row's stored declaration.
+ * @returns the ladder intent to write.
+ */
+export declare function ladderIntent(nextThinking: boolean, built: EffortIntent, initialEfforts: EffortWriteIntent | undefined): EffortWriteIntent;
+/**
+ * The compat draft a FRESH editor on this row would hold.
+ *
+ * The editor's three compat inputs are seeded from the stored block, so an
+ * untouched editor's draft is exactly the stored block restricted to the three
+ * fields it shows. The injector's provider-wide adapt has no editor to ask for
+ * a draft, so it derives the same value here: a hand-tuned field the UI does
+ * not show stays untouchable, and one it does show survives the write.
+ * @param compat - the row's stored compat block.
+ * @returns the draft, or undefined when it holds no field at all.
+ */
+export declare function compatDraftOf(compat: CompatSuggestion | undefined): CompatSuggestion | undefined;
+/**
+ * Assemble one complete pending write from the parts a caller resolved: the
+ * compat merge (the applied suggestion's block with the caller's own fields on
+ * top), the thinking-budget default an openai-completions endpoint needs, and
+ * the clear list for the fields this write OWNS and left empty.
+ *
+ * The single implementation of that assembly: the row's own editor reports the
+ * user's edits through it, and the injector's provider-wide adapt reports
+ * collapsed rows through it, so the same suggestion always writes the same
+ * bytes whichever path applied it.
+ * @param parts - the resolved parts (see {@link PendingWriteParts}).
+ * @returns the write to hand the injector's ledger.
+ */
+export declare function pendingWriteOf(parts: PendingWriteParts): PendingWrite;
 /**
  * Render one model's thinking-effort + input-modality editor: the level
  * checkboxes, the modality toggle, the auto-adapt action, and the

package/lib/client/KeyManager.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The API-key list: one provider's keys, which one is in use, and the one
+ * inline form that adds, relabels or replaces a key.
+ *
+ * Rendered inline under the official key field (see `injection/key-manager`),
+ * not as a floating panel: the field's label already says "API key", so its list
+ * belongs directly beneath it, inside the card that owns the profile — the list
+ * reads as part of the field rather than as a surface that has to be opened,
+ * positioned and dismissed.
+ *
+ * The list is a view over host state and holds no truth of its own — every
+ * mutation answers with the whole list, and the list is adopted as it arrives
+ * (`adopt`), so the GUI can never drift from what the settings document and the
+ * credential store actually say. Three facts it deliberately reflects:
+ *
+ *   - **the key in use is the profile's reference.** Choosing a row writes
+ *     `providers.<route>.apiKeyEnv`, so it holds for every request the route
+ *     makes, not only the ones this GUI starts. Exactly one key is in use per
+ *     provider, which is why the mark at the head of a row is a radio.
+ *   - **a value is shown masked, or not at all.** The host reads the stored
+ *     secret and answers a head-and-tail preview; the middle never leaves it,
+ *     and the eye beside the field stays the one gesture that reveals a value.
+ *   - **one form serves all three edits.** Adding, relabelling and replacing a
+ *     value differ only in which fields it shows, so they share a form rendered
+ *     as the row below the row they act on — for an add, the list's last row.
+ *
+ * @module dsh-model-think-level/client/KeyManager
+ */
+import type { ReactNode } from 'react';
+import { type KeyManagerClient } from './key-manager-client.js';
+/** The repo's inline translator shape. */
+type Translate = (key: string, params?: Record<string, string | number>) => string;
+/** Props of {@link KeyManager}. */
+export interface KeyManagerProps {
+    /** The provider route whose keys this list manages. */
+    readonly route: string;
+    /** Copy for the list's labels. */
+    readonly t: Translate;
+    /** Transport; injectable for tests. */
+    readonly client?: KeyManagerClient | undefined;
+}
+/**
+ * Render the key list for one provider route.
+ * @param props - see {@link KeyManagerProps}.
+ * @returns the list's root element.
+ */
+export declare function KeyManager(props: KeyManagerProps): ReactNode;
+export {};

package/lib/client/auto-effort.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The "adapt every model of this provider" request (user request ⑤).
+ *
+ * The seat beside the official fetch-models link and the per-row reasoning
+ * editor are two DIFFERENT React roots: the seat is raw DOM this plugin writes
+ * into the official catalogue head, while the editor is a root the injector
+ * mounts into each model row's disclosure. They share no props, so the request
+ * travels as one document event, and every editor whose own route matches
+ * answers it by running the very same `autoAdapt()` its own 自动适配 link runs.
+ *
+ * That indirection is the point: adapting N models this way is byte-identical
+ * to clicking that link N times, so the seat cannot drift from the control the
+ * user already trusts — and it still reaches the models whose thinking switch
+ * is OFF, which the link itself cannot (with the switch off the whole effort
+ * card, link included, is not rendered at all).
+ *
+ * @module dsh-model-think-level/client/auto-effort
+ */
+/** The event a seat dispatches and every mounted editor listens for. */
+export declare const AUTO_EFFORT_EVENT = "bre:auto-effort";
+/** The event's payload: the provider route whose models are to be adapted. */
+export interface AutoEffortDetail {
+    /** The provider route the request belongs to. */
+    readonly route: string;
+}
+/** Run one auto-adapt after every earlier one settled. */
+export declare function queueAutoEffort(run: () => Promise<void> | void): void;
+/** Ask every editor of `route` on this document to adapt its own model. */
+export declare function requestAutoEffort(route: string, target?: Document): void;
+/**
+ * Answer this document's auto-adapt requests until the returned disposer runs.
+ * A request naming another route is ignored — one card is open at a time, but a
+ * re-render can leave a previous card's rows mounted for a scan.
+ */
+export declare function listenAutoEffort(handler: (route: string) => void, target?: Document): () => void;

package/lib/client/injection/auto-effort-seat.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The "adapt every model of this provider" seat, beside the official
+ * fetch-models link (user request ⑤).
+ *
+ * The official catalogue head carries exactly one control — the link that
+ * fetches the provider's model list — so a provider with twenty models makes
+ * the user open twenty rows and click 自动适配 in each. The seat stands next to
+ * that link and asks every model of the provider to adapt at once.
+ *
+ * It is raw DOM inside the host's own head for the same reason the provider
+ * delete seat is: the plugin owns no slot there. It never moves a React-owned
+ * node — it only inserts itself as the anchor's next sibling and re-inserts
+ * itself when a re-render drops it — and every write is compare-before-write,
+ * so a settled pass emits no mutation of its own.
+ *
+ * The click does not write anything itself: it publishes a request on the
+ * document (see `../auto-effort.js`), which the per-model editors answer for
+ * their own rows, and hands the route to `deps.onRequest`, which answers for
+ * the models that have no editor on screen -- a collapsed row renders no
+ * disclosure container, so nothing else on the page can serve it. The seat
+ * therefore holds no write path of its own, and neither answer stages a
+ * document the open card is already holding.
+ *
+ * @module dsh-model-think-level/client/injection/auto-effort-seat
+ */
+/** One card's catalogue, paired with the route that card edits. */
+export interface AutoEffortSeatTarget {
+    /** The card's catalogue section. */
+    readonly catalogue: HTMLElement;
+    /** The provider route the card edits. */
+    readonly route: string;
+}
+export interface AutoEffortSeatDeps {
+    /** The plugin's own translator, for the label and the tooltip. */
+    t: (key: string, params?: Record<string, string | number>) => string;
+    /**
+     * Adapt every model of the route that has no on-screen editor: the injector
+     * owns the settings writes, so the seat only reports the click. Absent in
+     * tests that only care where the seat is placed.
+     */
+    onRequest?: (route: string) => void;
+}
+/**
+ * Give every target's catalogue head an auto-adapt seat. Idempotent: a head
+ * that already has one is only relabelled and re-seated, and a seat whose
+ * catalogue this pass no longer names is taken out.
+ */
+export declare function reconcileAutoEffortSeats(root: HTMLElement, targets: readonly AutoEffortSeatTarget[], deps: AutoEffortSeatDeps): void;
+/** Take every seat out again (plugin dispose, HMR teardown). */
+export declare function teardownAutoEffortSeats(): void;

package/lib/client/injection/dom.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Compare-before-write DOM helpers.
+ *
+ * Every write in the injection layer goes through one of these. An unchanged
+ * `setAttribute` still fires a mutation record, and the passes listen for
+ * mutations on the whole panel, so a blind write would have the scan chasing
+ * its own tail: mark → record → rescan → mark. Comparing first is what makes
+ * a settled page produce no mutations at all.
+ *
+ * @module dsh-model-think-level/client/injection/dom
+ */
+/** setAttribute only when the value would change. */
+export declare function setAttr(el: Element, name: string, value: string): void;
+/** `hidden` is a property, not an attribute these passes can compare textually. */
+export declare function setHidden(el: HTMLElement | undefined, hidden: boolean): void;
+/** Class writes compare first, like {@link setAttr}. `classList.add` is a
+ * no-op for a token it already holds in a spec-conforming engine, but it is
+ * not one in jsdom — and this helper's promise ("a settled page writes
+ * nothing") has to hold in both, since a write here feeds the same scan. */
+export declare function setClass(el: HTMLElement, name: string, on: boolean): void;
+/** Write text only when it differs, for the same reason as {@link setAttr}. */
+export declare function setText(el: HTMLElement | undefined, text: string): void;

package/lib/client/injection/editor-tab-bar.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The provider editor's segmented control (供应商配置 / 模型配置 / 高级配置).
+ *
+ * This is the bar the editor-tabs pass drives. It lives HERE, in the plugin's
+ * own React subtree, rather than being built by the pass and inserted into the
+ * official card: the card's children belong to React, and a foreign node in
+ * that list survives only until the next render. The component is rendered
+ * inside the provider-card slot's own mount — a child of the card the slot
+ * already resolves — and the stylesheet reveals it as soon as the pass marks
+ * the card (`bre-tabbed`), which happens in the same mutation batch as the
+ * official render.
+ *
+ * The component renders STRUCTURE only: it holds no state, because the card's
+ * `data-bre-tab` attribute is the source of truth for both the pane switch
+ * (pure CSS) and the selected button. The pass owns the copy, the per-pane
+ * availability and `aria-selected`, so a language switch relabels the bar
+ * without a re-render and a pane that is not on the card hides its own button.
+ *
+ * @module dsh-model-think-level/client/injection/editor-tab-bar
+ */
+import type { ReactNode } from 'react';
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+export interface EditorTabBarProps {
+    /** The plugin's own mount inside the card this bar switches. It hangs
+     * directly off the card, which is how the card is resolved on click. */
+    host: {
+        readonly current: HTMLDivElement | null;
+    };
+    /** The plugin's translator. */
+    t: Translate;
+}
+/** One provider editor's tab bar. */
+export declare function EditorTabBar({ host, t }: EditorTabBarProps): ReactNode;

package/lib/client/injection/editor-tabs.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The provider editor's three-tab takeover for the official Models settings
+ * page.
+ *
+ * The official editor presents one provider as a single long column — identity
+ * fields, then the model list, then (one section further up the card) this
+ * plugin's request-header editor — and the column keeps growing with every
+ * feature. This pass re-presents the same content as three tabs:
+ *
+ *   `provider` — the official identity fields (display name, key, base URL,
+ *                protocol); the editor's own header and action row stay put.
+ *   `models`   — the official model list, the rows the effort editor seats
+ *                into.
+ *   `advanced` — the plugin's request-header section, which the provider-card
+ *                slot already mounts and which owns its own save/cancel.
+ *
+ * The takeover is pure CSS, by the same iron rule every pass here follows:
+ * React owns the official children, so none of them move. The card carries the
+ * active tab (`data-bre-tab`), each region carries its tab membership
+ * (`data-bre-region`), and the stylesheet — not this module — decides what is
+ * visible.
+ *
+ * The bar is NOT part of that DOM, and this module never inserts it. It is
+ * React-rendered by {@link EditorTabBar} inside the plugin's own request-header
+ * mount, which the provider-card slot already guarantees is a child of the
+ * card; the stylesheet reveals it the moment the card carries the takeover
+ * class. An earlier revision inserted the bar straight into the official child
+ * list from here, which made it a foreign node in a React-reconciled list: it
+ * was at the mercy of the next render, and the insertion itself needed the
+ * headers mount to be a DIRECT child of the card — an anchor this module cannot
+ * verify and which threw (aborting the whole scan) when it did not hold. Owning
+ * the bar inside our own subtree removes both hazards: the pass below only ever
+ * writes attributes, and the slot component publishes the card's open state the
+ * same way.
+ *
+ * Everything degrades to the official page: a card whose structure this pass
+ * cannot recognise (host redesign, partial render) is left exactly as the
+ * official page built it, a card whose takeover throws is rolled back the same
+ * way, and every attribute write is compared before it lands so the scan never
+ * feeds the MutationObserver its own tail.
+ *
+ * The same visit also dresses the provider's API-key field with its reveal eye
+ * ({@link revealKeyField}) and its key controls ({@link enhanceKeyManagerField}),
+ * because that field's shape is decided by exactly the same classification and
+ * its affordances have to come and go with the takeover.
+ *
+ * @module dsh-model-think-level/client/injection/editor-tabs
+ */
+declare const TAB_IDS: readonly ["provider", "models", "advanced"];
+/** A tab id, as both the bar and the card attribute spell it. */
+export type EditorTabId = (typeof TAB_IDS)[number];
+/** The tab ids, in display order, for the tab-bar component. */
+export declare const EDITOR_TAB_IDS: readonly EditorTabId[];
+/** The bar's class, a button's class and a button's tab-id attribute, exported
+ * so the component that renders the bar and the pass that labels it spell the
+ * contract once. */
+export declare const EDITOR_TABS_CLASS = "bre-editor-tabs";
+export declare const EDITOR_TAB_BUTTON_CLASS = "bre-editor-tab";
+export declare const EDITOR_TAB_ID_ATTR = "data-bre-tab-id";
+/** Per-scan bookkeeping (one instance lives in `models-page.ts`). */
+export interface EditorTabsState {
+    /** Cards whose takeover threw and had to be rolled back. A card that cannot
+     * be taken over must not repeat its complaint on every scan. */
+    readonly warned: WeakSet<Element>;
+}
+export interface EditorTabsDeps {
+    /** The plugin's own translator, for the tab labels. */
+    t: (key: string, params?: Record<string, string | number>) => string;
+}
+export declare function createEditorTabsState(): EditorTabsState;
+/**
+ * The card a plugin mount sits in. Both the slot component (publishing the
+ * card's open state, switching tabs) and this pass resolve the card through
+ * this one rule, so a card can never be taken over by one and addressed by the
+ * other.
+ */
+export declare function editorCardOf(element: Element | null): HTMLElement | null;
+/**
+ * Switch one card to a tab. The card attribute is the single source of truth:
+ * the stylesheet swaps the pane on the attribute alone, and the bar's buttons
+ * follow it here.
+ */
+export declare function selectEditorTab(card: HTMLElement, id: EditorTabId): void;
+/**
+ * Visit every open provider editor and make sure it presents as tabs.
+ * Idempotent: a card that already carries the takeover is only relabelled,
+ * which is also how a language switch reaches the page. Cards the pass no
+ * longer recognises as open fall back to the official one-column layout.
+ */
+export declare function reconcileEditorTabs(root: HTMLElement, deps: EditorTabsDeps, state: EditorTabsState): void;
+/** Remove every takeover mark. The bar is the tab-bar component's own DOM and
+ * is hidden, not removed, by dropping the class it is revealed under. */
+export declare function teardownEditorTabs(): void;
+export {};

package/lib/client/injection/icon.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The plugin's own outline glyphs.
+ *
+ * Shared because two injected controls draw one: the API-key eye, which swaps
+ * between two glyphs by attribute, and the key field's alias chip, which is
+ * icon-only so that it does not repeat the official "API key" label with the
+ * word for the same thing. Every glyph is a stroke-only outline on the same
+ * 16px grid, inherits `currentColor`, and is hidden from assistive tech — the
+ * button holding it carries the meaning in its own `aria-label`.
+ *
+ * @module dsh-model-think-level/client/injection/icon
+ */
+/** The namespace every SVG node here is created in. */
+export declare const SVG_NS = "http://www.w3.org/2000/svg";
+/** Marks a glyph, so the stylesheet can show one of several, and a sweep find it. */
+export declare const ICON_ATTR = "data-bre-icon";
+/** One outline path of a glyph, in the 16px viewBox. */
+export declare function svgPath(d: string): SVGPathElement;
+/** A stroke-only 16px glyph built from outline paths. */
+export declare function svgGlyph(kind: string, paths: readonly string[]): SVGElement;

package/lib/client/injection/key-manager.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The key list's seat: the official key field grows a plugin-owned host, and the
+ * list is rendered inline into it, directly under the input.
+ *
+ * The field is not reachable from the settings page's React tree — the plugin
+ * only gets keyed slots, and none of them sits beside a form field — so the seat
+ * is a DOM leaf inserted directly AFTER the field. The list then falls under the
+ * input, which is where a provider's keys belong: the label above already says
+ * "API key", and the list reads as part of the field rather than as a surface
+ * that has to be opened, positioned and dismissed.
+ *
+ * A sibling rather than a last child: the reveal eye hangs on the field's own
+ * bottom edge (`bottom: 0` against the field, which its validation-message rule
+ * also measures from), so a list inside the field would carry the eye down with
+ * it and leave it sitting on the list's last row. React tolerates the foreign
+ * sibling — it resolves a node's next sibling by walking past nodes it does not
+ * own — and the list mirrors the field's region, so a pane hides it along with
+ * the field it belongs to.
+ *
+ * The host carries the route its list was built for — that attribute is how the
+ * pass knows whether the mounted list still belongs to the field it follows, and
+ * how a test asks what is mounted there.
+ *
+ * The whole seat is skipped when the field is not a key field, or when its card
+ * announces no route: the add-provider form has no route yet, and keys belong to
+ * a route that exists.
+ *
+ * @module dsh-model-think-level/client/injection/key-manager
+ */
+import type { KeyManagerClient } from '../key-manager-client.js';
+/** Set on a field whose keys the plugin lists. */
+export declare const KEY_MANAGED_CLASS = "bre-key-managed";
+/** The repo's inline translator shape. */
+export type Translator = (key: string, params?: Record<string, string | number>) => string;
+/** What a reconcile tells the field's key list. */
+export interface KeyManagerFieldDeps {
+    /** Copy for the list and its form. */
+    readonly t: Translator;
+    /** The provider route this card edits; absent on the add-provider form. */
+    readonly route?: string | undefined;
+    /** List transport; injectable for tests. */
+    readonly client?: KeyManagerClient | undefined;
+}
+/**
+ * Mount the key list into a field, replacing whatever this module mounted there
+ * before. Idempotent: a field whose list is already up and current is left
+ * exactly as it is, so a settled page sees no write at all.
+ */
+export declare function enhanceKeyManagerField(field: HTMLElement, deps: KeyManagerFieldDeps): void;
+/**
+ * Drop the list of one field, leaving the official field exactly as the page
+ * rendered it. Called when the takeover ends, and for the stray sweep of a page
+ * that is being torn down.
+ */
+export declare function resetKeyManagerField(field: HTMLElement): void;
+/** Drop every list this module mounted. */
+export declare function teardownKeyManager(): void;
+/**
+ * The route a field's list was built for, or undefined when it has none.
+ *
+ * A test hook: the route lives on the host, so what the pass decided can be read
+ * back from the DOM alone.
+ */
+export declare function keyManagerRoute(field: HTMLElement): string | undefined;