dsh-model-think-level 1.0.0 → 1.0.1

package/README.md

@@ -32,13 +32,16 @@ The `llm-pi-ai` adapter natively supports per-model `reasoningEfforts` and `inpu
 ## 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-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. Beside the official **Get available models** link at the head of a provider's model list sits the plugin's own **Auto-detect thinking levels** (自动获取思考等级): one click runs that same adaptation over **every model of that provider at once**, so a newly added gateway does not need one click per row. It is deliberately the per-model action repeated, not a second write path — each mounted row runs its own auto-adapt and commits through the card's own pending state — so the result is byte-identical to clicking each row in turn, a read-only row or a save already in flight is skipped rather than raced, and the passes are queued one after another because each one reads the provider's own model list.
 - **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.
+- **Tabbed provider editor** — the provider card's one long column (identity fields, model list, request headers) is re-presented as three tabs — **Provider / Models / Advanced** (供应商配置 / 模型配置 / 高级配置) — with a segmented control that the plugin renders inside its own request-header section, above the panes. The official fields never move: each region is tagged and the visibility is decided in CSS, so the card's own Save/Cancel row stays put and an official redesign degrades back to the single-column editor untouched. The official "Customized" disclosure that folds the identity fields and the model list together is sorted into its panes and stays expanded for as long as the tabs are in charge. The editor's own header — the provider name and route tag printed at the top of the pane — repeats the card row sitting directly above it, so it is hidden on every tab; and the Models pane drops both of its hairlines — the "Customized" group's separator and the catalogue's own — together with every top padding that held content off them. Neither has anything to divide here: the identity fields the group's rule separated it from are not in this pane, and the tab bar above already ends the pane. What is left runs from the tab bar into the catalogue with only the editor's own 14px gap between blocks — no doubled line, and no blank space where a line used to be. The tags land in the same frame the official editor is committed in, so opening a card shows the tabbed editor directly — never the single column first, re-sorting itself a moment later. The same visit dresses the API-key field with a trailing **eye**: one click unmasks what is being typed or pasted just now, and on a saved provider it **fetches the stored key and puts it back into the field**. The eye belongs to that input, so both step aside on the cards the key manager takes over: the list below is where a key gets written there, and two ways to write one key on one card read as a conflict. The official page is write-only by design — the settings document carries only the profile's `apiKeyEnv` reference and the credential service never returns a value — so the plugin's own host route (`GET /dsh-model-think-level/provider-key?route=<route>`, the same trust fence as the raw-models probe) resolves it for the page, uncached and never logged. The read happens only on that click and only while the field is empty: a draft you typed is never overwritten, hiding gives a borrowed key back (an empty field is exactly what the official form reads as "keep the stored key"), and a resolve that comes back empty leaves the field masked with the reason in the button's tooltip. The mask and the button both go when the takeover withdraws. The **Advanced** tab is never collapsible: it holds the request-header section alone now, so folding it would leave the pane empty — the section keeps its disclosure header only while other regions still share the pane, and renders as a plain heading on its own tab.
+- **Per-provider key manager** — the API-key field grows the provider's whole key list **inline, directly beneath the field**: one bordered list whose rows are every key configured for that provider route, closed by a full-width **Add another key** row. There is no icon chip, no `+` button and no floating panel — no key glyph sitting beside the official "API key" label printing the same word twice, and no layer to position against the dialog's opaque mask. Each row is the key's name — the alias — followed by its **masked** value, or the masked value alone when the row was never named (the mask is composed host-side, because only the host can resolve a stored credential), and closes on the **enable** radio: one circle per row, one enabled key per provider, so picking a row is what puts that key in use. Hovering a row — or focusing into it — reveals exactly three actions and nothing else: **Delete** (asks twice), **Alias** (renames only) and **Change key** (replaces that row's stored value). All three, plus adding, use the one form that opens **below the affected row** — name on the left, `Paste API key` on the right, then **Cancel** and the confirm button — never a dialog, and the value never leaves the host except as a mask. Exactly one key per route is in use, and enabling one writes the profile's `apiKeyEnv` — the single reference the adapter resolves — so the key in use is the same one the official page, the composer and every other consumer of that profile use, not a plugin-local notion. Labels are plugin state: the credential store has no enumeration and no labels, so the list lives in `<harness home>/dsh-model-think-level/key-index.json` — references and labels only, never a value — kept beside the harness home rather than inside the pi-ai profile, because the official add-provider card writes the whole profile at `providers.<route>`. Adding a key mints the next free reference server-side in one write (`ROUTE_API_KEY`, then `_2`, `_3`, …), stores the value **first** and lists it only once the store accepted it; removing the key in use hands the seat to the next listed key **before** the value is forgotten, and removing the last key clears the reference. A key whose value the store no longer holds stays listed and is flagged, so it can be re-added or removed. The list and its form are plugin-owned DOM in a host div appended as the key field's **next sibling** — the same anchored leaf the reveal eye is measured against — so they sit inside the dialog's own layout and need no z-index of their own; the form closes on **Cancel** or on a successful commit, and the host is swept on teardown, on a route change and when the pane leaves the provider tab.
+- **Provider-list rows** — the official list of provider cards is dressed from the plugin side: each row carries an enable **switch** (switching a provider off greys its name and identity) and can be reordered by dragging its grip — the insertion line that says which side the row would land on is drawn above the settings dialog, so it is not swallowed by the overlay's opaque mask. Its action column also stays aligned, because the host renders a delete button only for a provider it allows removing — a built-in such as DeepSeek rendered none at all, so that row's remaining actions started further right than its neighbours'. The plugin fills that hole with a disabled **Delete** placeholder wearing the official row metrics (28px tall, the row's 12px label) at the host's own 40% disabled opacity, labelled with the host's own word for the action and tooltipped "a built-in provider cannot be deleted". The placeholder is handed back the moment the host renders its own button, and swept on teardown.
 - **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).
 
@@ -74,9 +77,12 @@ Restart `dsh web` and hard-refresh the browser.
    - 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.
+3. Above the model list, beside the official **Get available models** link, **Auto-detect thinking levels** runs that same adaptation over **every model of the provider at once** — one click instead of one per row. Each mounted row still runs its own auto-adapt and commits through the card's own pending state, so the outcome is what clicking **Auto-adapt** on every row in turn would produce; the passes are queued, because each one reads the provider's own model list.
+4. 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`.
+5. All levels off + Save = unset the declaration; only `off` checked + Save = disable reasoning (`false`); *Clear declaration* + Save = back to inheriting the provider default.
+6. 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.
+
+7. The API-key field carries that provider's key list **inline**: the radio marks the key in use (the one the profile's `apiKeyEnv` points at), **Add another key** opens the form beneath the list, and hovering a row offers **Delete**, **Alias** and **Change key**.
 
 Declared models are immediately selectable for reasoning effort in the composer, and image-declared models accept attachments end to end.
 
@@ -114,10 +120,20 @@ Browser (lib/client.js)                  Host (lib/index.js)
 │   input-modality toggle /
 │   auto-adapt (zoned suggestions) / committed with the card's Save
 │   └─ writes settings.mutate (llm-pi-ai)
+├─ Key manager (provider card)
+│   inline key list under the key field; add / alias / change-value
+│   forms open under the affected row (one key in use per route)
+│   └─ host route: key index + credentials (enable = apiKeyEnv write)
+├─ Auto-detect thinking levels (catalogue head)
+│   a seat beside the official "Get available models" link → one
+│   event → every mounted row of that provider runs its own auto-adapt
 ```
 
 - `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/`.
+- `reconcileEditorTabs()` in `src/client/injection/editor-tabs.ts` re-presents the open editor card as three tabs (Provider / Models / Advanced) — it tags each region and stamps the card with the active tab; the visibility is decided in the stylesheet, so no official node ever moves. The bar is React-rendered by `src/client/injection/editor-tab-bar.ts` inside the plugin's own request-header mount, so it is plugin-owned DOM rather than a foreign node in the official child list; the pass only classifies, tags and labels it. The same visit calls `revealKeyField()` in `src/client/injection/key-reveal.ts`, which gives the API-key field its reveal eye — the one node this plugin appends to official DOM, a positioned leaf removed again on teardown. It unmasks a draft in place, and for a saved provider it asks the host for the stored credential through `PROVIDER_KEY_PATH` in `src/constants.ts` (registered in `src/index.ts` beside the raw-models probe, under the same trust fence and explicitly uncached), writing the answer into the official input through the prototype value setter plus a bubbling `input` event so the official component adopts it; a reveal is always borrowed, so hiding empties the field again — which is what the official form reads as "keep the stored key". The compare-before-write helpers shared by the tab pass and the key reveal live in `src/client/injection/dom.ts`.
+- `enhanceKeyManagerField()` in `src/client/injection/key-manager.ts` owns the inline key list under the API-key field (the eye stays in `key-reveal.ts`) and the host div the list and its form mount into; while the list is mounted the field's own input is hidden by the stylesheet, because the list says the same thing once per key and both in one card read as a conflict — the input stays in the DOM, so the official form still owns it and unmanaging the field brings it back; the list itself is the React component in `src/client/KeyManager.tsx`, which talks to the host through `src/client/key-manager-client.ts` (`KEY_INDEX_PATH`) — `list`, `add`, `enable`, `rename`, `replace` and `remove`. The host route in `src/index.ts` reads and writes the plugin's index through `src/key-index.ts` and moves the "in use" seat with `settings.mutate(llm-pi-ai, { op: 'set' | 'unset', path: ['providers', route, 'apiKeyEnv'] })`, retrying once on a revision conflict; reference minting, validation and alias normalisation are shared with the browser half through `src/key-refs.ts`, which also composes the mask (`first4…last4`, or a fixed dot run below twelve characters) so no unmasked value ever crosses the host boundary. The injected leaf is compared against the field's next sibling before it is appended, so a settled pass emits no mutation and cannot retrigger the page observer.
+- `reconcileAutoEffortSeats()` in `src/client/injection/auto-effort-seat.ts` renders the provider-wide seat into the open card's catalogue head — one raw-DOM button after the official **Get available models** link, matched by position because that link's own label swaps to a fetching state mid-request, and identified by `data-bre-auto-effort`, which carries the route. The click publishes `AUTO_EFFORT_EVENT` (`src/client/auto-effort.ts`) instead of writing anything: the seat holds no write path of its own, so `EffortEditor` listens, checks the route against its own, and queues its own `autoAdapt()` — the queue is a single promise chain, so passes run one at a time in arrival order and a failure never stops the next. The seat reconciles on every pass (idempotently — a settled pass emits no mutation), re-reads the route at click time so a retyped Provider ID is followed, and is swept both in the pass's own early-exit branches and on teardown.
 - `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
@@ -144,6 +160,7 @@ Compiled and gated against the `0.2.0-rc.1` official packages; see [docs/compati
 - **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.
+- **The per-provider key list is plugin state** (`<harness home>/dsh-model-think-level/key-index.json`): references and labels only, never a value, but removing a key forgets its value from the credential store, and uninstalling the plugin leaves the file behind. If a key is renamed or enabled from another window while the card is open, reload it (the list reads when the card opens, not live).
 
 ## Acknowledgements
 

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;

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

@@ -0,0 +1,84 @@
+/**
+ * The eye on a provider's API-key field.
+ *
+ * Two jobs, one control. The official input is `<input type="password">` whose
+ * value is React's own draft state (`keyDraft`), and a SAVED key is never part
+ * of it: a configured provider shows a placeholder instead, because the harness
+ * keeps provider keys write-only (the settings document carries only the
+ * profile's `apiKeyEnv` reference, and the credential service reports
+ * `{ configured }` — never the value). So on a settled card the eye has nothing
+ * to unmask, and the plugin asks its own host for the stored value
+ * ({@link loadProviderKey}, the `PROVIDER_KEY_PATH` route) when — and only
+ * when — the user clicks it with an empty field. A field holding a draft the
+ * user just typed is never touched: the fetch is skipped and the click only
+ * swaps the mask.
+ *
+ * The read is deliberately constrained:
+ *
+ *   - it happens on an explicit click, never on render, and answers `undefined`
+ *     for every failure (no route, refused fence, reference-free profile,
+ *     unconfigured credential), which leaves the field masked;
+ *   - it is never cached (the request says `no-store` and the route answers
+ *     with the same header) and never logged;
+ *   - hiding the field again takes the borrowed value back out — the draft
+ *     returns to empty, which the official form reads as "keep the stored key",
+ *     so revealing can never overwrite the credential by accident. A value the
+ *     user edits after revealing is theirs, and is left alone.
+ *
+ * The button is the one node this plugin inserts into official DOM, and it is
+ * inserted deliberately: the affordance only reads as an eye at the END of the
+ * input if it sits inside the input's own box, and the official field has no
+ * wrapper to hang it on. The trade is contained —
+ *
+ *   - the field itself is never restructured, and nothing official is moved or
+ *     removed: the button is an absolutely positioned LEAF appended last;
+ *   - React ignores trailing foreign children when it reconciles the field's
+ *     known children, so the node survives every re-render (each keystroke
+ *     re-renders this field);
+ *   - React never writes the input's `type` back (its props do not change), so
+ *     the revealed state survives too;
+ *   - the pass removes the button, the marker and the class on cleanup, and
+ *     restores the mask, so a withdrawn takeover leaves nothing behind.
+ *
+ * @module dsh-model-think-level/client/injection/key-reveal
+ */
+/** Set on the field that carries the key input. */
+export declare const KEY_FIELD_CLASS = "bre-key-field";
+/** The eye button inside that field. */
+export declare const KEY_EYE_CLASS = "bre-key-eye";
+/** The repo's inline translator shape (see `HeadersEditor`, `ComposerSlider`). */
+export type Translator = (key: string, params?: Record<string, string | number>) => string;
+/** What a reconcile tells the field's eye. */
+export interface KeyRevealDeps {
+    /** Copy for the button's labels and its failure tooltip. */
+    readonly t: Translator;
+    /**
+     * The provider route this card edits, when the card announces one. Absent on
+     * the add-provider form (no route exists yet), which is what keeps the eye
+     * there a plain mask toggle.
+     */
+    readonly route?: string | undefined;
+    /** How to resolve the stored credential; injectable for tests. */
+    readonly loadKey?: ((route: string) => Promise<string | undefined>) | undefined;
+}
+/**
+ * Give an editor field an eye at the end of its input, if it holds the API key.
+ *
+ * Runs on every reconcile of the card, so it only ever writes what differs; a
+ * field with no key input is handed to {@link resetKeyField} instead, which is
+ * how a takeover that has moved on (a provider whose key field is gone) drops
+ * the affordance it no longer needs.
+ */
+export declare function revealKeyField(field: HTMLElement, deps: KeyRevealDeps): void;
+/** Undo {@link revealKeyField}: drop the button, the class, the marker, and
+ * re-mask the input, leaving the official field exactly as it was rendered. */
+export declare function resetKeyField(field: HTMLElement): void;
+/**
+ * Ask the host for the credential a provider profile names.
+ *
+ * Fails closed by design: every refusal — an unknown route, a profile with no
+ * reference, a credential that is not configured, a refused trust fence, a
+ * network error — is `undefined`, and the caller leaves the field masked rather
+ * than uncovering an empty box.
+ */
+export declare function loadProviderKey(route: string): Promise<string | undefined>;