@x1a0f3n9/dsh-client-ui-settings-models 0.1.5-rc.3

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Host loader entry for the browser implementation exported from `./client`. */
+/** Host plugin body — no host-side behavior for the models settings plugin. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/types/client/CustomProviderCard.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The card that declares a provider pi-ai does not ship — an OpenAI-compatible
+ * gateway, a self-hosted server, or a provider newer than the installed
+ * catalog.
+ *
+ * This is a create, not an edit, which is why it is its own card rather than
+ * the provider editor with extra fields: the route id is being *chosen* here,
+ * and the settings address does not exist until it is. One `settings.mutate`
+ * sets the whole profile at `providers.<route>`; the key travels separately
+ * through `credentials/set` under the reference the profile records, exactly as
+ * an existing provider's key does.
+ *
+ * The three fields a hand-declared route cannot default — endpoint, protocol,
+ * and at least one model — are required here rather than at load, so the
+ * failure names the field while the user is still looking at it.
+ *
+ * There is no provider-scoped reasoning-effort control: effort is a per-MODEL
+ * capability, and the models under one provider disagree about it. Each model
+ * row offers Default (none) or Custom levels written as `reasoningEfforts`.
+ * Retry count and delay are provider-route fields: Default omits `retryPolicy`,
+ * and Custom writes a normal-mode policy with those two values.
+ */
+import type { ReactNode } from 'react';
+import type { ModelsOperations } from './operations.ts';
+import type { en } from './locales.ts';
+/** Props of {@link CustomProviderCard}. */
+export interface CustomProviderCardProps {
+    /** Route ids already declared, so the card refuses to shadow one. */
+    taken: readonly string[];
+    /** Wire protocols the adapter can serve, in the order it reports them. */
+    protocols: readonly string[];
+    /**
+     * Revision of the `llm-pi-ai` user section this card opened at, sent with
+     * the create so a route another tab declared meanwhile is a refusal rather
+     * than a silent overwrite of its whole profile.
+     */
+    revision: number;
+    /** The Host operations this card writes and interrogates through. */
+    operations: ModelsOperations;
+    /** Section copy. */
+    t: (key: keyof typeof en) => string;
+    /** Disable writes (read-only settings provider). */
+    readOnly: boolean;
+    /** Close the card; `changed` reports whether a provider was created. */
+    onClose: (changed: boolean) => void;
+}
+/**
+ * Render the custom-provider creation card.
+ * @param props - existing routes, protocol choices, wire faces, and copy.
+ * @returns the creation card.
+ */
+export declare function CustomProviderCard(props: CustomProviderCardProps): ReactNode;
+//# sourceMappingURL=CustomProviderCard.d.ts.map

package/lib/types/client/DeepSeekModelsEditor.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Curated editor for the direct DeepSeek adapter's advisory model catalog.
+ * The settings layer replaces `models` as one array, so the parent supplies
+ * the effective inherited rows until the first edit materializes a user
+ * override; reset removes that override instead of copying defaults into it.
+ */
+import type { ReactNode } from 'react';
+import type { en } from './locales.ts';
+/** One catalog entry kept structurally open so hidden or future fields survive an edit. */
+export type DeepSeekModelDraft = Record<string, unknown>;
+/**
+ * Read a typed capacity, so a user can write `256K` or `1M` instead of counting
+ * zeroes. The stored value stays a plain token count.
+ * @param text - raw field text.
+ * @returns the count; `undefined` when blank (inherit), `NaN` when unreadable
+ * (rejected by {@link validateDeepSeekModels} before any write).
+ */
+export declare function parseCapacity(text: string): number | undefined;
+/**
+ * Spell a stored count back in the shortest form that survives a round trip
+ * through {@link parseCapacity}; a count that is not a whole number of
+ * thousands stays written out.
+ * @param value - stored capacity.
+ * @returns the field text.
+ */
+export declare function formatCapacity(value: number): string;
+/** A localized validation failure for one user-owned model array. */
+export interface DeepSeekModelsValidationFailure {
+    /** Zero-based model position. */
+    index: number;
+    /** Message key owned by the Models settings section. */
+    key: 'modelIdRequired' | 'modelIdDuplicate' | 'modelNameInvalid' | 'modelContextInvalid' | 'modelMaxTokensInvalid' | 'modelReasoningEmpty' | 'modelReasoningWireRequired';
+}
+/** Convert a schema-validated catalog value into records without dropping hidden fields. */
+export declare function modelDrafts(value: unknown): DeepSeekModelDraft[];
+/**
+ * Validate adapter constraints that the serialized schema cannot express.
+ * @param value - user-owned `models` value, or undefined while inherited.
+ * @returns the first invalid row, or undefined when the adapter will accept it.
+ */
+export declare function validateDeepSeekModels(value: unknown): DeepSeekModelsValidationFailure | undefined;
+/** Props of {@link DeepSeekModelsEditor}. */
+export interface DeepSeekModelsEditorProps {
+    /** Effective rows: inherited until the parent materializes an override. */
+    models: readonly DeepSeekModelDraft[];
+    /** Whether the user layer currently owns the whole array. */
+    overridden: boolean;
+    /** Fallback context capacity used when a row omits its exact value. */
+    defaultContextWindow: number | undefined;
+    /** Fallback output cap used when a row omits its exact value. */
+    defaultMaxTokens: number | undefined;
+    /** Section copy. */
+    t: (key: keyof typeof en) => string;
+    /** Disable every mutation. */
+    disabled: boolean;
+    /** Replace the user-owned array after one visible edit. */
+    onChange: (models: DeepSeekModelDraft[]) => void;
+    /** Remove the user-owned array and return to inheritance. */
+    onReset: () => void;
+}
+/**
+ * Render the direct DeepSeek adapter's model catalog: id and display name on
+ * each row, image-input and capacities behind the row's own disclosure.
+ * @param props - effective rows plus the array-level override actions.
+ * @returns the catalog editor.
+ */
+export declare function DeepSeekModelsEditor(props: DeepSeekModelsEditorProps): ReactNode;
+//# sourceMappingURL=DeepSeekModelsEditor.d.ts.map

package/lib/types/client/DeepSeekOnboardingDialog.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Official-DeepSeek first-run step. Readiness comes from the same
+ * provider/settings/credential join as the Models page: any provider the user
+ * can already talk to ends the step, and only a user with none is offered the
+ * official DeepSeek route. The step reuses that page's credential editor in
+ * the onboarding plugin's shared modal, so the key is entered once.
+ */
+import type { ReactNode } from 'react';
+import type { SnapshotStore } from '@x1a0f3n9/dsh-client-store';
+import type { InjectFace, PropsRuntime } from '@x1a0f3n9/dsh-client-ui-slots';
+import type { ModelsSettingsState, ModelsSettingsStore } from './store.ts';
+import type { ModelsOperations } from './operations.ts';
+import type { SettingsSchemaOperations } from './schema-operations.ts';
+import type { en } from './locales.ts';
+/** Registration-side dependencies of {@link DeepSeekOnboardingDialog}. */
+export interface DeepSeekOnboardingInjected {
+    hooks: {
+        /** Shared Models-page join state, bound by the slot renderer. */
+        models: SnapshotStore<ModelsSettingsState>;
+    };
+    /** Shared Models-page join controller. */
+    controller: ModelsSettingsStore;
+    /** The Host operations the reused Models credential editor writes through. */
+    operations: ModelsOperations;
+    /** Settings schema and immutable path callbacks. */
+    schema: SettingsSchemaOperations;
+    /** Feature copy. */
+    t: (key: keyof typeof en) => string;
+}
+/** Slot owner props plus the feature's injected dependencies. */
+export type DeepSeekOnboardingDialogProps = PropsRuntime<'settings.onboarding'> & InjectFace<DeepSeekOnboardingInjected>;
+/**
+ * Prompt a first-run user for the official DeepSeek credential while no
+ * provider can serve requests and that credential is writable.
+ * @param props - settings-shell owner state and Models feature dependencies.
+ * @returns the onboarding modal or null when onboarding needs no intervention.
+ */
+export declare function DeepSeekOnboardingDialog(props: DeepSeekOnboardingDialogProps): ReactNode;
+//# sourceMappingURL=DeepSeekOnboardingDialog.d.ts.map

package/lib/types/client/EditorFooter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The action row every provider card ends with: dismiss on the left, commit on
+ * the right.
+ *
+ * The two cards commit different things — one creates a route, one edits an
+ * existing profile — but the row itself carries no such knowledge. It renders
+ * what it is handed, so the cards keep sole ownership of when a commit is
+ * allowed and what the in-flight wording is.
+ *
+ * Cancel refuses input only while a commit is in flight, never because the card
+ * is disabled: a card the deployment cannot write to must still be dismissable.
+ *
+ * @module dsh-client-ui-settings-models/client/EditorFooter
+ */
+import type { ReactNode } from 'react';
+import type { en } from './locales.ts';
+/** Props of {@link EditorFooter}. */
+export interface EditorFooterProps {
+    /** Localizer for the row's own labels. */
+    t: (key: keyof typeof en) => string;
+    /** Whether a commit is in flight; holds Cancel and swaps the commit label. */
+    busy: boolean;
+    /** Whether the commit is refused, as judged by the owning card. */
+    submitDisabled: boolean;
+    /** Commit label while idle. */
+    submitLabelKey: keyof typeof en;
+    /** Commit label while a commit is in flight. */
+    submitBusyLabelKey: keyof typeof en;
+    /** Dismiss label; defaults to the settings editor copy. */
+    cancelLabelKey?: keyof typeof en;
+    /** Dismiss the card without committing. */
+    onCancel: () => void;
+    /** Run the card's commit. */
+    onSubmit: () => void;
+}
+/**
+ * Render one provider card's action row.
+ * @param props - the labels, commit gating, and handlers the owning card supplies.
+ * @returns the cancel/commit row.
+ */
+export declare function EditorFooter(props: EditorFooterProps): ReactNode;
+//# sourceMappingURL=EditorFooter.d.ts.map

package/lib/types/client/ModelListEditor.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The model list of one pi-ai provider profile, plus the action that asks the
+ * provider what it serves.
+ *
+ * The list is the profile's `models` array as the card holds it: an empty list
+ * means "serve this route's built-in catalog", and any entry replaces that
+ * catalog, so a row is only ever added deliberately. Fetching asks the endpoint
+ * **the form currently shows** — including a key typed but not yet saved — so
+ * adding a provider is one pass instead of save-then-return; the reply is
+ * candidates the user picks from, never configuration written behind them.
+ *
+ * A provider that cannot be interrogated (an unreachable endpoint, a protocol
+ * with no readable listing) is not a dead end: the failure is shown next to the
+ * rows the user can still fill in by hand.
+ */
+import type { ReactNode } from 'react';
+import type { ModelsOperations } from './operations.ts';
+import type { DeepSeekModelDraft } from './DeepSeekModelsEditor.tsx';
+import type { en } from './locales.ts';
+/**
+ * One configured model row. Fields this card does not edit must survive an
+ * edit rather than being dropped by a rebuild.
+ */
+export type ModelDraft = DeepSeekModelDraft;
+/** What an interrogation needs, taken from the live form. */
+export interface ProbeTarget {
+    /** Settings namespace whose adapter family answers. */
+    settingsNs: string;
+    /**
+     * Route being edited, when the card edits one. An adapter that already
+     * describes it answers from its own registry, so such a card can ask without
+     * an endpoint at all.
+     */
+    provider?: string;
+    /** Endpoint as the form currently shows it. */
+    baseURL?: string;
+    /** Wire protocol the form names, when it names one. */
+    api?: string;
+    /** Key typed into the form and not yet stored, when there is one. */
+    apiKey?: string;
+}
+/** Props of {@link ModelListEditor}. */
+export interface ModelListEditorProps {
+    /** The rows as currently drafted. */
+    models: readonly ModelDraft[];
+    /** Whether the user layer currently owns the whole array; absent on a create. */
+    overridden?: boolean;
+    /** Replace the drafted rows. */
+    onChange: (models: ModelDraft[]) => void;
+    /** Remove the user-owned array and return to inheritance; absent on a create. */
+    onReset?: () => void;
+    /** Endpoint facts for the fetch action. */
+    probe: ProbeTarget;
+    /**
+     * Copy key naming why the fetch action is unavailable, or `undefined` when
+     * it is. The card owns this because the key it would send is judged there:
+     * asking with a key the form has already refused spends a round trip to be
+     * told what the field already says.
+     */
+    probeBlocked?: keyof typeof en | undefined;
+    /** The Host operations whose interrogation answers the fetch action. */
+    operations: ModelsOperations;
+    /** Section copy. */
+    t: (key: keyof typeof en) => string;
+    /** Disable every control (read-only deployment or a pending write). */
+    disabled: boolean;
+}
+/**
+ * Render the model list with its fetch action.
+ * @param props - the drafted rows, probe target, wire face, and copy.
+ * @returns the model-list editor.
+ */
+export declare function ModelListEditor(props: ModelListEditorProps): ReactNode;
+//# sourceMappingURL=ModelListEditor.d.ts.map

package/lib/types/client/ModelsSection.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Models settings section: the provider rows joined from the configurable
+ * directory, settings namespaces, and credential states, with one editor
+ * card at a time. Rows expose only confirmed API-key state through accessible
+ * solid configured or missing dots. A whole-section provider without a
+ * configured key renders as its open setup card instead of a row, but only in
+ * the first-run posture — no provider on the page can serve requests yet — and
+ * only until the user closes that card; the add flow is a card carrying the
+ * dormant-provider select. Each card kind owns its own open state, so closing
+ * one never discards a draft in another. Every mutation writes through the
+ * wire, while a provider removal first requires confirmation; the page
+ * re-renders from pushed invalidations or the post-apply reload.
+ */
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsRenderSlots } from '@x1a0f3n9/dsh-client-ui-slots';
+import type { ModelsSettingsStore, ProviderRow } from './store.ts';
+import type { ModelsOperations } from './operations.ts';
+import type { SettingsSchemaOperations } from './schema-operations.ts';
+import type { en } from './locales.ts';
+/** Injected dependencies of {@link ModelsSection} (slot `inject`). */
+export interface ModelsSectionInjected {
+    /** The page store (loaded on mount, refreshed on pushed invalidations). */
+    controller: ModelsSettingsStore;
+    hooks: {
+        /** Page snapshot bound by the UI renderer as useSnapshot. */
+        snapshot: ModelsSettingsStore['store'];
+    };
+    /** The Host operations the section and its cards invoke. */
+    operations: ModelsOperations;
+    /** Settings schema and immutable path callbacks. */
+    schema: SettingsSchemaOperations;
+    /** Section copy. */
+    t: (key: keyof typeof en) => string;
+}
+/** The child slots this section declares and dispatches (see ./slot-contract.ts). */
+type ModelsChildSlots = 'settings.models.provider-card' | 'settings.models.footer';
+/**
+ * Props delivered by the slot outlet: the inject face spread flat (the
+ * renderer erases the share boundary at the render call) plus the child-slot
+ * dispatch seat. The seat is required: the renderer binds it at the render
+ * call itself — unlike the inject face it is never absent at runtime — and a
+ * direct render that forgets it fails to compile instead of mounting nothing.
+ */
+export type ModelsSectionProps = Partial<InjectFace<ModelsSectionInjected>> & PropsRenderSlots<ModelsChildSlots>;
+/** Provider identity shared by row actions and confirmation copy. */
+export interface ProviderIdentity {
+    /** Stable provider route id. */
+    provider: string;
+    /** Human-facing provider name. */
+    displayName: string;
+}
+/**
+ * Remove one user-added provider and its page-managed credential. Credential
+ * removal comes first so a second-step failure leaves the provider row visible
+ * and the whole operation safely retryable; both unsets are idempotent.
+ * The settings removal names the profile rather than rebuilding its whole
+ * namespace from a partial view.
+ * @param operations - the page's Host operations.
+ * @param controller - the page store to refresh.
+ * @param target - the provider's settings address and optional managed credential.
+ * @returns the failure message, or undefined once the write and reload landed.
+ */
+export declare function removeProviderProfile(operations: ModelsOperations, controller: ModelsSettingsStore, target: {
+    settingsNs: string;
+    settingsPath: readonly string[];
+    credentialRef?: string;
+}): Promise<string | undefined>;
+/**
+ * Whether a whole-section provider still needs its first key: an unconfigured
+ * credential opens the setup card instead of showing a row. This is the
+ * first-run posture alone — a user who can already reach some provider gets an
+ * ordinary row with the missing-key dot, since nothing here is blocking them.
+ * @param row - the joined provider row.
+ * @param anyUsable - whether any joined row can already serve requests.
+ * @returns whether to render the setup card.
+ */
+export declare function needsSetup(row: ProviderRow, anyUsable: boolean): boolean;
+/** Stable visible and accessible identity for one provider target. */
+export declare function providerTargetLabel(target: ProviderIdentity): string;
+/** Replace the one provider placeholder in localized destructive-action copy. */
+export declare function providerCopy(template: string, target: ProviderIdentity): string;
+/**
+ * Render the Models section content column.
+ * @param props - slot-delivered injected dependencies.
+ * @returns the section, or null while the shell has not injected yet.
+ */
+export declare function ModelsSection(props: ModelsSectionProps): ReactNode;
+export {};
+//# sourceMappingURL=ModelsSection.d.ts.map

package/lib/types/client/OnboardingModal.d.ts

@@ -0,0 +1,15 @@
+/** Shared modal chrome for every step registered by this onboarding plugin. */
+import type { ReactNode } from 'react';
+/**
+ * Render a blocking onboarding dialog and keep the application root inert.
+ * @param props.title - accessible and visible dialog title.
+ * @param props.focusTitle - focus the title when the step has no form control.
+ * @param props.children - step-owned body and actions.
+ * @returns the body-portaled modal.
+ */
+export declare function OnboardingModal({ title, focusTitle, children, }: {
+    title: string;
+    focusTitle?: boolean;
+    children: ReactNode;
+}): ReactNode;
+//# sourceMappingURL=OnboardingModal.d.ts.map

package/lib/types/client/ProviderEditor.d.ts

@@ -0,0 +1,88 @@
+/**
+ * One provider's editor card, hand-written per adapter family: the primary
+ * field is a single write-only **API key** input (the page never asks for an
+ * environment-variable name — a typed key stores through `credentials/set`
+ * under the profile's reference, deriving `<ROUTE>_API_KEY` when the profile
+ * has none. The pi-ai profile records that derivation as `apiKeyEnv` only when
+ * a key is entered; a blank key materializes a reference-free profile for
+ * provider-native authentication);
+ * the collapsed 自定义设置 area carries the per-family extras (`baseURL` for
+ * both families, DeepSeek's id/name/context-window model catalog, and the
+ * display name and wire protocol of a pi-ai route the adapter does not ship —
+ * the two fields the create card asked that route for, editable here for the
+ * same reason).
+ * Provider-scoped reasoning effort stays absent: it is a per-MODEL capability.
+ * Each custom model row offers Default (none) or Custom `reasoningEfforts`.
+ * Retry count and delay are provider-route fields on this card: Default omits
+ * `retryPolicy`, and Custom writes a normal-mode policy with those two values.
+ * Everything else stays owned by `settings.yaml`. Profile edits land as
+ * minimal `settings.mutate` path ops against the stored section — the card
+ * names only the fields it can see instead of rebuilding the whole subtree
+ * from a partial descriptor.
+ */
+import type { ReactNode } from 'react';
+import type { SettingsNamespaceView, SettingsPathOpView } from '@x1a0f3n9/dsh-api-remotes/client';
+import type { ModelsOperations } from './operations.ts';
+import type { SettingsSchemaOperations } from './schema-operations.ts';
+import type { en } from './locales.ts';
+/** Props of {@link ProviderEditor}. */
+export interface ProviderEditorProps {
+    /** Provider route id. */
+    provider: string;
+    /** Display name for the card title. */
+    displayName: string;
+    /** Hide the title row (the add card renders its own provider select). */
+    hideTitle?: boolean;
+    /**
+     * Whether the adapter reports this route as hand-declared — absent from its
+     * installed catalog. Such a route carries its own wire protocol, chosen when
+     * it was created and editable here for the same reason; a catalog route's
+     * models each carry theirs, so a route-level protocol there could only
+     * override every one of them and the card does not offer it.
+     */
+    declared?: boolean;
+    /** The owning namespace view (schema, layers, secrets). */
+    namespace: SettingsNamespaceView;
+    /** Settings-owned synchronous schema and immutable path operations. */
+    schema: SettingsSchemaOperations;
+    /** Path from the section root to this provider's profile. */
+    settingsPath: readonly string[];
+    /** The Host operations this card writes and interrogates through. */
+    operations: ModelsOperations;
+    /** Section copy. */
+    t: (key: keyof typeof en) => string;
+    /** Disable writes (read-only settings provider). */
+    readOnly: boolean;
+    /** Render only the credential field and actions, without provider settings. */
+    credentialOnly?: boolean;
+    /** Require a newly entered credential before this editor can submit. */
+    credentialRequired?: boolean;
+    /** Give the credential field initial focus when this editor mounts. */
+    autoFocusCredential?: boolean;
+    /** Override the dismiss action copy. */
+    cancelLabelKey?: keyof typeof en;
+    /** Override the idle commit action copy. */
+    submitLabelKey?: keyof typeof en;
+    /** Override the in-flight commit action copy. */
+    submitBusyLabelKey?: keyof typeof en;
+    /** Close the editor; `changed` reports whether an Apply committed. */
+    onClose: (changed: boolean) => void;
+}
+/**
+ * The minimal path ops carrying `after` over `before`, both as the card sees
+ * them. Only keys the card observed are named; fields absent from both sides
+ * produce no op, which is why edits are path-addressed rather than a rebuilt
+ * section.
+ * @param base - path of the edited subtree inside the user section.
+ * @param before - the subtree as loaded, or undefined when it is new.
+ * @param after - the subtree as edited.
+ * @returns ordered set/unset ops; empty when nothing changed.
+ */
+export declare function pathOps(base: readonly string[], before: unknown, after: Record<string, unknown>): SettingsPathOpView[];
+/**
+ * Render one provider's editing card.
+ * @param props - the addressed profile plus wire faces and copy.
+ * @returns the editor card.
+ */
+export declare function ProviderEditor(props: ProviderEditorProps): ReactNode;
+//# sourceMappingURL=ProviderEditor.d.ts.map

package/lib/types/client/WelcomeNotice.d.ts

@@ -0,0 +1,26 @@
+/** Product-wide, versioned internal-testing notice. */
+import type { ReactNode } from 'react';
+import type { SnapshotStore } from '@x1a0f3n9/dsh-client-store';
+import type { InjectFace, PropsRuntime } from '@x1a0f3n9/dsh-client-ui-slots';
+import type { WelcomeNoticeState, WelcomeNoticeStore } from './welcome-store.ts';
+import type { en } from './locales.ts';
+/** Registration-side dependencies of {@link WelcomeNotice}. */
+export interface WelcomeNoticeInjected {
+    hooks: {
+        /** Durable or process-local acknowledgement state. */
+        welcome: SnapshotStore<WelcomeNoticeState>;
+    };
+    /** Welcome acknowledgement controller. */
+    controller: WelcomeNoticeStore;
+    /** Onboarding copy. */
+    t: (key: keyof typeof en) => string;
+}
+/** Coordinator owner props plus this step's injected face. */
+export type WelcomeNoticeProps = PropsRuntime<'settings.onboarding'> & InjectFace<WelcomeNoticeInjected>;
+/**
+ * Render the current notice until its exact copy version is acknowledged.
+ * @param props - settings-shell owner state and welcome dependencies.
+ * @returns the welcome modal or null while the step decides not to show.
+ */
+export declare function WelcomeNotice(props: WelcomeNoticeProps): ReactNode;
+//# sourceMappingURL=WelcomeNotice.d.ts.map

package/lib/types/client/apiKey.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Browser-side judgement of a typed API key.
+ * @module @x1a0f3n9/dsh-client-ui-settings-models/apiKey
+ */
+/**
+ * Copy key naming why a typed key cannot be saved. A wrapped paste reports the
+ * same format failure as an illegal character: the reader's next move is the
+ * same either way — look at the key and paste it again — so naming the two
+ * causes apart would spend the field's one line on a distinction that changes
+ * nothing about what to do.
+ */
+export type ApiKeyFailureKey = 'keyBlank' | 'keyIllegalCharacters';
+/**
+ * Judge the key input's current value.
+ *
+ * An empty field is not a failure: every card opens with it empty even when a
+ * key is already stored, where it means keep that one. A field holding only
+ * whitespace is a failure rather than an empty field, so typed input is never
+ * silently discarded.
+ * @param draft - the key input's current value, untrimmed.
+ * @returns the copy key for a field-level failure, or `undefined` to allow submit.
+ */
+export declare function apiKeyFailure(draft: string): ApiKeyFailureKey | undefined;
+//# sourceMappingURL=apiKey.d.ts.map

package/lib/types/client/image-input.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-model image-input declaration edited on the Models cards.
+ *
+ * pi-ai stores the field as `input`; the DeepSeek adapter stores it as
+ * `inputModalities`. Both accept `text` and `image`. A missing field is not
+ * "text only": resolution may still inherit a catalog or route default.
+ */
+/** The stored list that admits both text and images. */
+export declare const IMAGE_INPUT: readonly ["text", "image"];
+/** Settings field each adapter family uses for request modalities. */
+export type ImageInputField = 'input' | 'inputModalities';
+/**
+ * Whether a stored modality list currently includes `image`.
+ * @param value - a model draft's `input` or `inputModalities` field.
+ * @returns true only when the value is an array that contains `image`.
+ */
+export declare function acceptsImages(value: unknown): boolean;
+/**
+ * Copy a model draft with image input declared or cleared on one field.
+ * @param model - the row as currently drafted.
+ * @param field - adapter-owned modality field name.
+ * @param enabled - whether the row should declare image input.
+ * @returns a new draft; other fields are unchanged.
+ */
+export declare function withImageInput(model: Record<string, unknown>, field: ImageInputField, enabled: boolean): Record<string, unknown>;
+//# sourceMappingURL=image-input.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Models settings and product-onboarding plugin, browser half. It registers
+ * the Models page plus the ordered internal-testing and official-DeepSeek
+ * onboarding dialogs, whose UI shares this package's modal wrapper. The Host
+ * settings and credential contracts stay behind their existing wire APIs.
+ * Export discipline:
+ * packages/client/AGENTS.md.
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import { ModelsSettingsStore } from './store.ts';
+import { type ModelsKey } from './locales.ts';
+export type { ModelsSectionInjected, ModelsSectionProps } from './ModelsSection.tsx';
+export type { ModelsFooterOwnerProps, ProviderCardExtrasOwnerProps } from './slot-contract.ts';
+export type { ModelsKey } from './locales.ts';
+declare module '@x1a0f3n9/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The Models page + product-onboarding copy. */
+        'settings.models': ModelsKey;
+    }
+}
+export type { ModelsSettingsState, ProviderDirectoryEntry, ProviderRow, } from './store.ts';
+export type { ModelDiscoveryOutcome, ModelsOperations, SettingsWriteOutcome } from './operations.ts';
+/**
+ * Refetch the page snapshot only after its first load: an unopened Models
+ * page must not fetch on background invalidations.
+ * @param controller - the page store.
+ */
+export declare function refreshIfLoaded(controller: ModelsSettingsStore): void;
+/**
+ * Required services (cordis fiber inject). The target slot is declared by
+ * ui-settings' apply, whose activation order relative to this one is NOT
+ * constrained; registration depends on each slot through `slots.inject()`.
+ */
+export declare const inject: string[];
+/**
+ * Register the Models section once the `settings.section` declaration is on
+ * the ledger, wire its store to the connection, and keep it fresh on every
+ * pushed invalidation (settings, credentials, or provider topology).
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map