dsh-model-think-level 1.1.0 → 1.1.2

package/lib/client/HeadersEditor.d.ts

@@ -14,6 +14,12 @@
  * card's own fields. The headers land through `llm-pi-ai.providers.<route>.headers`,
  * the one channel the adapter actually sends.
  *
+ * Deferred mode (`deferred`) is this same section rendered where there is no
+ * route to write TO yet — the create-provider card's 高级配置 pane, whose route
+ * the card's own 保存 declares. There the draft is reported instead of written,
+ * and the whole-dict discipline is what makes the two commit seams the same
+ * write: see {@link DeferredHeaders}.
+ *
  * @module dsh-model-think-level/HeadersEditor
  */
 import type { ReactNode } from 'react';
@@ -54,6 +60,22 @@ export interface HeaderEnvironment {
         preferOfficialLayer: boolean;
     };
 }
+/**
+ * Deferred mode: how a pane that has no route yet reports its draft.
+ *
+ * The create-provider card's 高级配置 pane edits an id the settings document
+ * does not declare — the card's own 保存 is what declares it — so that pane has
+ * nothing to write and no button to press. It hands the editor this instead:
+ * every change to the draft goes out as the complete dict its Save would write,
+ * and a Cancel reports that the draft is gone. Same component, same whole-dict
+ * discipline; only the commit seam changes, from a write to a report.
+ */
+export interface DeferredHeaders {
+    /** Every change to the draft, as the dict the editor's Save would write. */
+    onDraft: (headers: Record<string, string>) => void;
+    /** The user cleared the draft: whatever was staged for it must go. */
+    onCancel: () => void;
+}
 /** Props of {@link HeadersEditor}. */
 export interface HeadersEditorProps {
     /** The provider route this card edits. */
@@ -62,6 +84,24 @@ export interface HeadersEditorProps {
     api: RemoteApi;
     /** Localized copy. */
     t: (key: string, params?: Record<string, string | number>) => string;
+    /**
+     * Close the whole provider card, as the official footer's `取消` does.
+     *
+     * Only the mount that owns the card's DOM can press that button, so the
+     * editor takes the action as a prop instead of reaching for the DOM itself
+     * (this component needs no injection pass — see the module doc). Called by
+     * {@link cancel} in pane mode only; omitted, cancel stays a draft reset.
+     */
+    onDismiss?: () => void;
+    /**
+     * Deferred mode: report the draft instead of writing it.
+     *
+     * Set by the create-provider card's pane, whose route does not exist yet. The
+     * editor then edits in place — no disclosure, no Edit step — and has no Save
+     * of its own: its copy states that the draft lands with the card's own 保存,
+     * which is the write that declares the route the draft is addressed to.
+     */
+    deferred?: DeferredHeaders;
 }
 /** One editable header row; a stable `id` keeps React keys off the name. */
 interface DraftRow {
@@ -79,8 +119,8 @@ interface Draft {
 export declare function headersFromDraft(draft: Draft): Record<string, string>;
 /**
  * Render the provider card's request-header section.
- * @param props - route identity, write seam and copy.
+ * @param props - route identity, write seam, copy and the card dismiss seam.
  * @returns the section.
  */
-export declare function HeadersEditor({ route, api, t }: HeadersEditorProps): ReactNode;
+export declare function HeadersEditor({ route, api, t, onDismiss, deferred }: HeadersEditorProps): ReactNode;
 export {};

package/lib/client/injection/add-card.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The add-provider card: the custom-API form on its own, carrying the tab bar.
+ *
+ * The official card offers two ways to add a provider — adopt one from the
+ * built-in catalogue, or declare a custom API endpoint — behind a segmented
+ * "How to add" control. The catalogue half only duplicates the configured
+ * provider rows above it, so this pass reduces the card to the custom half: it
+ * selects that mode, hides the switch, and gives the form the same three panes
+ * its sibling editor cards carry — the bar, and the 高级配置 section the card
+ * has nowhere else to put ({@link CreateCardPane}).
+ *
+ * The card is the SAME card the tab takeover dresses (`bre-tabbed`), and that
+ * takeover scopes its regions to the visible half of the form
+ * ({@link activeScopeOf}). What it cannot do is hang the bar: the official card
+ * renders the provider-card slot only inside the catalogue half, so the custom
+ * form has no plugin mount to render a bar into. The mount is created here
+ * instead, at the top of the visible form, and it is the ONLY node this module
+ * inserts. Everything else is attributes on nodes the official page owns.
+ *
+ * Degradation is total: a card with no custom half (no API protocol to declare,
+ * or no `llm-pi-ai` namespace to declare one into) is left exactly as the
+ * official page built it, switch and all, and a card whose dressing throws is
+ * rolled back to that same state.
+ *
+ * @module dsh-model-think-level/client/injection/add-card
+ */
+import type { ReactNode } from 'react';
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import { type ForeignMount } from './mount.js';
+import type { StagedHeadersState } from './staged-headers.js';
+import type { RemoteApi } from '../types.js';
+export interface AddCardDeps {
+    /** The plugin's own translator, for the tab labels and the pane's copy. */
+    t: Translate;
+    /** The write seam the pane's header editor reads the settings document with. */
+    api: RemoteApi;
+    /** The official labels of the form's provider-id field, by locale. */
+    routeIdLabels: () => readonly string[];
+    /** The session's deferred-header ledger (see `staged-headers`). */
+    staged: StagedHeadersState;
+    /** The plugin's locale-refresh seam, so the pane's copy follows a language
+     * switch exactly as the seats the official slot mounts do. */
+    refreshed: (children: () => ReactNode) => ReactNode;
+}
+/** One card's mount, remembered by the card it belongs to. */
+interface AddCardHost {
+    /** The node the root renders into, so a re-created form can be told from a
+     * settled one. */
+    readonly host: HTMLElement;
+    readonly mount: ForeignMount;
+}
+export interface AddCardState {
+    /** Cards this module mounted a bar into. The mount goes with the card, so a
+     * card the page has dropped is dropped here on the next visit. */
+    readonly hosts: Map<HTMLElement, AddCardHost>;
+}
+export declare function createAddCardState(): AddCardState;
+/**
+ * Reduce every add-provider card on the page to its custom form.
+ *
+ * Idempotent by construction: a card already showing the custom form with its
+ * bar up is left untouched, and switching the mode is driven by the official
+ * control's own selected state, so a re-visit writes nothing.
+ */
+export declare function reconcileAddCards(root: HTMLElement, deps: AddCardDeps, state: AddCardState): void;
+/**
+ * Give every card back to the official page: the mounts go, and the switch
+ * comes out of hiding. The mode the card is left in is the official page's own
+ * state, and it is not this module's to reset — React unmounts the card whole.
+ */
+export declare function teardownAddCards(state: AddCardState): void;
+export {};

package/lib/client/injection/create-card-pane.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The create-provider card's 高级配置 pane: the tab bar and the request-header
+ * editor, for a provider that does not exist yet.
+ *
+ * This is the half {@link add-card} used to leave out. On an existing provider
+ * the same editor arrives through the official `settings.models.provider-card`
+ * slot, which the official card renders only inside its CATALOGUE half — so the
+ * custom-only card this plugin reduces it to had a tab bar whose 高级配置 button
+ * could never light up: nothing in that half carried a `.bre-headers` section for
+ * the takeover to reveal. This pane is that section, mounted at the same seat
+ * the bar is.
+ *
+ * The route the pane edits is the id the user is TYPING, which is the one thing
+ * about this card the settings document does not have yet — the card's own 保存
+ * is what declares it. So the pane cannot write as the official card can:
+ *
+ *  - the id is read off the live form (the panel's own label, never a position)
+ *    and re-read on every keystroke, because the form's React state is not ours
+ *    to subscribe to;
+ *  - the rows are editable whether or not the id has been typed: a draft is held
+ *    by the session ledger once it has a route to belong to, and until then it
+ *    simply waits for the id — which the pane does NOT announce, because the id
+ *    field is on the 供应商配置 tab of this same card and the official form
+ *    already speaks for it;
+ *  - once there is an id the editor runs in DEFERRED mode: it edits, and reports
+ *    the draft to the session ledger, but the write happens when the route
+ *    appears in the document — the proof the card's own create landed. The pane
+ *    also asks, one keystroke in, whether that id was ALREADY declared, because
+ *    only a route that was not can be this card's work. See
+ *    {@link staged-headers} for why that is a gate and not a delay.
+ *
+ * @module dsh-model-think-level/client/injection/create-card-pane
+ */
+import type { ReactNode } from 'react';
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import type { RemoteApi } from '../types.js';
+import { type StagedHeadersState } from './staged-headers.js';
+export interface CreateCardPaneProps {
+    /** The plugin's own mount inside this card; the bar resolves the card from it. */
+    host: {
+        readonly current: HTMLDivElement | null;
+    };
+    /** The write seam, for the editor's own settings read. */
+    api: RemoteApi;
+    /** The plugin's translator. */
+    t: Translate;
+    /** The official labels of the form's provider-id field, by locale. */
+    routeIdLabels: () => readonly string[];
+    /** The session's deferred-header ledger. */
+    staged: StagedHeadersState;
+}
+/** One create card's pane: its bar, and the headers pane once there is a route. */
+export declare function CreateCardPane({ host, api, t, routeIdLabels, staged }: CreateCardPaneProps): ReactNode;

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

@@ -75,6 +75,23 @@ export declare function createEditorTabsState(): EditorTabsState;
  * other.
  */
 export declare function editorCardOf(element: Element | null): HTMLElement | null;
+/**
+ * The part of a card that presents its editor.
+ *
+ * A provider ROW has one editor and this returns the card itself. The
+ * create-provider card has TWO form halves — the built-in catalogue and the
+ * custom API declaration — and the official page mounts each once it is visited
+ * and hides the inactive one with `hidden`. Every lookup below is scoped to the
+ * visible half, because the hidden one carries a provider-card slot of its own:
+ * the plugin's mount inside it publishes a route, a tab bar and a headers
+ * section, and reading those would dress the visible form with the hidden
+ * form's provider.
+ *
+ * A card with both halves hidden (mid-swap, before React commits the show) and
+ * a card with none are both scoped to the card, which is the rule this module
+ * has always applied to a single-form card.
+ */
+export declare function activeScopeOf(card: HTMLElement): HTMLElement;
 /**
  * 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

package/lib/client/injection/models-page-editor.d.ts

@@ -74,6 +74,14 @@ export interface HostLabels {
      * offers this plugin no seat to stamp that name on.
      */
     editProvider: readonly string[];
+    /**
+     * The official input-types control's image choice ("Image" / "图片"). When a
+     * row ships that control, it — not the plugin's ledger — is what tells the
+     * user (and the official Save) that a model takes images, so the copy is the
+     * anchor that finds the box a verdict belongs in: see
+     * {@link echoOfficialModality}.
+     */
+    inputImage: readonly string[];
 }
 /** The join the injector renders from. */
 export interface InjectorDeps {
@@ -391,6 +399,65 @@ export interface AutofillFootprint {
  * position (the label's trailing number IS the position).
  */
 export declare function inputValueByLabel(card: HTMLElement, labels: readonly string[]): string;
+/**
+ * The official input-types checkbox an image verdict belongs to, or undefined
+ * when this row ships no such control (a legacy kernel) — or ships one whose
+ * boxes cannot be told apart.
+ *
+ * The official fieldset maps its two choices in a fixed order (`["text",
+ * "image"]`) and labels each one, so the image box is the one whose own label
+ * carries the image copy — matched like every other anchor, by copy, with the
+ * second box as the fallback for a host whose copy is in a language neither
+ * this plugin's locale nor its English floor knows: the order still identifies
+ * it.
+ */
+export declare function officialImageCheckboxOf(container: HTMLElement, imageLabels: readonly string[]): HTMLInputElement | undefined;
+/**
+ * Print a verdict about images on the OFFICIAL input-types control, and report
+ * whether that control now owns the row's modality.
+ *
+ * The official checkbox renders the official card's own DRAFT, not the
+ * settings document, so a document write of the plugin's can never tick it
+ * before the card is saved and reopened — the gap the user hit. Clicking the
+ * box is a real user-equivalent edit: the official form holds the tick in its
+ * draft and its own Save is what persists it. That is also why a row reaching
+ * this path must keep the modality OUT of its own write (see
+ * {@link officialModalityIntent}): two writers for one field would let this
+ * plugin's held write land after that Save and revert whatever the user chose
+ * in the meantime.
+ *
+ * A missing box, or a DISABLED one (a read-only card, which will not carry the
+ * click anywhere), reports `false` so the caller keeps its own write — the
+ * only remaining way the verdict can reach the document.
+ */
+export declare function echoOfficialModality(container: HTMLElement, image: boolean, imageLabels: readonly string[]): boolean;
+/**
+ * The modality intent a row's own write may carry, once the official
+ * input-types control has been offered the verdict.
+ *
+ * `undefined` out means the write states nothing about the modality: either it
+ * never carried one, or the official control took the verdict over. A row with
+ * no such control — a legacy kernel, or a row the user has left folded — hands
+ * its intent through unchanged, which keeps the document write as the way the
+ * verdict travels.
+ *
+ * `null` is the plugin's deliberate UNSET, which the official control cannot
+ * express at all (it knows only text and text+image): it passes through
+ * untouched.
+ */
+export declare function officialModalityIntent(container: HTMLElement | undefined, input: InputModalities | null | undefined, imageLabels: readonly string[]): InputModalities | null | undefined;
+/**
+ * One model row a card shows on screen: what the walk needs to name it, plus
+ * the row element itself, so a verdict about its modality can be printed on
+ * the row's own official control (which lives inside the row, collapsed or
+ * not). The element is optional because a caller may know the rows only by
+ * their ids.
+ */
+export interface ScreenModel {
+    readonly id: string;
+    readonly name: string;
+    readonly row?: HTMLElement;
+}
 /**
  * Adapt every model of one provider, the rows the user never unfolded
  * included.
@@ -428,10 +495,7 @@ export declare function inputValueByLabel(card: HTMLElement, labels: readonly st
  *   click: how many models it held an adaptation for, how many had no
  *   suggestion, and -- when nothing could be adapted at all -- why.
  */
-export declare function adaptEveryModel(state: ScanState, deps: InjectorDeps, route: string, visibleRows?: ReadonlyArray<{
-    id: string;
-    name: string;
-}>): Promise<AutoAdaptReport>;
+export declare function adaptEveryModel(state: ScanState, deps: InjectorDeps, route: string, visibleRows?: readonly ScreenModel[]): Promise<AutoAdaptReport>;
 /**
  * Hand a viewport delta back to whichever container actually moved the card.
  *

package/lib/client/injection/saved-notice.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The official "Saved <provider>." line, taken out of the flow and
+ * answered by a bubble at the top of the window instead.
+ *
+ * The host confirms a save by inserting a paragraph above the provider list
+ * (`ModelsSection`'s `savedNotice`, `role="status"`) that stays there until the
+ * next edit, remove or add clears it. It is feedback, not state — the row it
+ * names is on screen and shows the save itself — but it holds a whole line of
+ * the panel's height the whole time the user works in the card, which is the
+ * "the hint eats space" report. So the line is hidden (never removed: React
+ * owns it, and it must survive the page's own re-renders) and the same words go
+ * up as the plugin's fixed top-centre bubble, which takes itself away after
+ * {@link NOTE_TTL_MS} — the treatment the auto-adapt seat's verdict already
+ * gets, and the one the host's own toast uses.
+ *
+ * The pass owns no wire and no state of its own: it is DOM-only, idempotent and
+ * compare-before-write, so a settled page emits no mutation of its own.
+ *
+ * @module dsh-model-think-level/client/injection/saved-notice
+ */
+/**
+ * Hide every official saved line inside the panel, and put up a bubble for the
+ * one that just appeared.
+ * @param root - the Models panel the passes all decorate.
+ */
+export declare function reconcileSavedNotice(root: HTMLElement): void;
+/** Put every official line back and take the bubble down (plugin dispose). */
+export declare function teardownSavedNotice(): void;

package/lib/client/injection/staged-headers.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Deferred request headers: the create-provider card's 高级配置 draft, held
+ * until the provider it belongs to exists.
+ *
+ * The create card's 高级配置 pane edits a route the settings document does not
+ * declare — the card's own 保存 is what declares it. So there is nothing this
+ * plugin may write at the moment the user types: `writeProviderHeaders` refuses
+ * a route no raw layer declares, and for a good reason (the write would leave a
+ * stray profile carrying nothing but headers). The pane's draft therefore waits
+ * here as an INTENT, and lands on the first scan that finds the route really
+ * declared. That finding is also the proof the creation succeeded: it is the
+ * card's own commit, never this plugin's, that puts the route in the document.
+ *
+ * The wait is bounded, and deliberately so. A pane's unmount cannot tell "the
+ * create landed and the card closed" from "the user gave up", so an intent is
+ * RELEASED at unmount rather than dropped, and a released intent whose route
+ * never appears is retired after {@link RELEASE_GRACE_MS} — which is what keeps
+ * an abandoned card's headers from being inherited by a later provider that
+ * happens to take the same id.
+ *
+ * What decides whether the draft may be written is not the route appearing on its
+ * own — a card whose id names a provider that ALREADY exists sees its route
+ * declared from the first keystroke, and those headers are that provider's, not
+ * this draft's. So each route carries a BASELINE: whether it was already declared
+ * when this card's draft was staged. A route that was not, and now is, was
+ * declared by the card (that is the only thing that could have declared it) and
+ * the draft lands — on the very scan that reads it, whether or not the card has
+ * closed yet. A route that already was gets nothing, exactly as before.
+ *
+ * Nothing is persisted. A reload discards a held intent exactly as it discards
+ * the card's own unsaved fields, which is the contract the pane's copy states.
+ *
+ * @module dsh-model-think-level/client/injection/staged-headers
+ */
+import type { RemoteApi } from '../types.js';
+/**
+ * How long a released intent keeps waiting for its route to appear.
+ *
+ * The window only has to cover the gap between the card's own 保存 landing and
+ * the next scan reading it — a mutation schedules that scan within the debounce
+ * window, so this is generous by two orders of magnitude. It is a window and not
+ * a deadline: a draft whose route never appears is dropped, because after that
+ * long the card it belonged to is not coming back.
+ */
+export declare const RELEASE_GRACE_MS = 15000;
+/** One pane's held draft, keyed by the route it will be written to. */
+export interface StagedHeaderIntent {
+    /** The complete dict the pane holds — the same whole-dict value the editor's
+     * own Save writes, so the two commit paths cannot write different shapes. */
+    headers: Record<string, string>;
+    /** Whether this route was already declared when the draft was staged; see the
+     * module doc. Left undefined while that read is in flight — the drain cannot
+     * tell a typed id from a created one until it knows, so it waits. */
+    declaredBefore?: boolean;
+    /** When the pane that staged this intent unmounted, if it has. */
+    releasedAt?: number;
+    /** Whether the drain has already said — once — that this route has no
+     * baseline, which is the one holding state that ends in silence. */
+    noted?: boolean;
+}
+/** The session's deferred-header ledger. */
+export interface StagedHeadersState {
+    /** Held drafts, by route. Readable so a test (and the console) can see what
+     * the session is still holding. */
+    readonly intents: Map<string, StagedHeaderIntent>;
+    /** What each route's baseline read found, kept for the session so a draft
+     * restaged after the drain retired its intent does not have to ask again. */
+    readonly baseline: Map<string, boolean>;
+    /** One drain at a time: an unmount's release-triggered flush and a scan's
+     * drain must not both walk the ledger and write the same route. */
+    flushing: boolean;
+}
+/** A fresh, empty ledger. */
+export declare function createStagedHeadersState(): StagedHeadersState;
+/**
+ * Hold one pane's draft for a route that is not declared yet.
+ *
+ * An empty draft WITHDRAWS instead of staging: "no headers" is the same state
+ * the route is already in (a card that creates a provider with no headers), so
+ * staging it would only arm a write that changes nothing — and it would make the
+ * pane's first, still-blank report look like an edit.
+ * @param state - the session's ledger.
+ * @param route - the route the pane's id field currently reads.
+ * @param headers - the complete draft dict.
+ */
+export declare function stageRequestHeaders(state: StagedHeadersState, route: string, headers: Record<string, string>): void;
+/** Drop the draft held for one route. */
+export declare function withdrawRequestHeaders(state: StagedHeadersState, route: string): void;
+/**
+ * Mark one route's draft as orphaned: the pane that staged it is gone and the
+ * card's own 保存 has already been pressed or will never be.
+ * @param state - the session's ledger.
+ * @param route - the route the pane last read.
+ */
+export declare function releaseRequestHeaders(state: StagedHeadersState, route: string): void;
+/**
+ * Record whether `route` was already declared when this card's draft was staged.
+ *
+ * The pane reads this off the settings document as soon as it has a route to ask
+ * about, which is long before the card's own 保存 can declare anything — so the
+ * answer tells the drain whether the declaration it later sees is this card's
+ * doing or someone else's provider. Kept per session, so a draft restaged after
+ * the drain retired its intent does not ask twice.
+ * @param state - the session's ledger.
+ * @param route - the route to record.
+ * @param declared - whether the route was declared at that moment.
+ */
+export declare function markRouteBaseline(state: StagedHeadersState, route: string, declared: boolean): void;
+/**
+ * Whether `route` still needs its baseline read, and has no draft to wait on.
+ * @param state - the session's ledger.
+ * @param route - the route the pane's id field currently reads.
+ * @returns True when the pane should ask the settings document.
+ */
+export declare function needsRouteBaseline(state: StagedHeadersState, route: string): boolean;
+/**
+ * Write every held draft whose route is now declared.
+ *
+ * Runs on the debounced scan, which is the only place that already does wire
+ * work — the synchronous pass in the mutation microtask must stay wire-free.
+ * @param state - the session's ledger.
+ * @param api - the settings Remote.
+ * @returns How many RELEASED drafts are still waiting for their route. The
+ * caller keeps the scan coming while that is non-zero: the card's own 保存 may
+ * declare the route after the card — and its pane — are gone, and by then no
+ * further DOM mutation is left to trigger a scan.
+ */
+export declare function flushStagedRequestHeaders(state: StagedHeadersState, api: RemoteApi): Promise<number>;

package/lib/client/ops.d.ts

@@ -175,6 +175,22 @@ export declare function providerHeadersOf(namespace: SettingsNamespaceView | und
  * @returns whether the write landed, and the refusal text when it did not.
  */
 export declare function writeProviderHeaders(api: RemoteApi, route: string, headers: Record<string, string>): Promise<ProviderHeadersReply>;
+/**
+ * Whether this document declares the route: its RESOLVED providers map, or
+ * either raw layer, holding the key itself (own key, never a prototype name).
+ *
+ * The resolved map is the one the models-page editor stages against, and it is
+ * the only one a settings join is guaranteed to carry — a mirror-backed join can
+ * hand back `value` with the raw layers absent or thin, and a check that reads
+ * only the raw layers then answers "not declared" for a provider that plainly
+ * exists. The raw layers are still asked first-class, because they are where the
+ * official card's own save lands.
+ *
+ * Exported for the deferred-header ledger, which asks the same question for the
+ * same reason `writeProviderHeaders` does: a route nothing declares is a route
+ * nothing may be written to yet.
+ */
+export declare function routeIsDeclared(namespace: SettingsNamespaceView | undefined, route: string): boolean;
 /**
  * Describe the pi-ai namespace plus writability.
  *