@fonlan/dsh-model-parameters 0.1.4 → 0.1.6

package/lib/index.js

@@ -6,13 +6,16 @@ import { join } from "node:path";
 /**
 * Plugin configuration and shared constants for @fonlan/dsh-model-parameters.
 *
-* The plugin owns the `model-parameters` settings namespace (stored in
-* settings.yaml) and OBSERVES the `llm-pi-ai` namespace: whenever provider
-* models are written there with missing capability fields (which is the norm
-* for a freshly synced gateway), it patches the missing fields from the cached
-* models.dev catalog.
+* The plugin's own settings ARE its loader entry config (DSH >= 0.1.7): the
+* profile entry whose id is `model-parameters` (see cordis.patch.yml) is
+* validated with {@link Config}, the resolved document is handed to
+* `apply(ctx, config)`, and the settings page is derived from that schema. The
+* plugin OBSERVES the `llm-pi-ai` namespace: whenever provider models are
+* written there with missing capability fields (which is the norm for a freshly
+* synced gateway), it patches the missing fields from the cached models.dev
+* catalog.
 */
-/** This plugin's own settings namespace. */
+/** This plugin's own settings namespace: its profile entry id. */
 const PLUGIN_NS = "model-parameters";
 /** The namespace whose models this plugin completes: pi-ai provider profiles. */
 const TARGET_NS = "llm-pi-ai";
@@ -56,16 +59,17 @@ const REASONING_LEVELS = [
 	"xhigh",
 	"max"
 ];
+/** The plugin's `Config` schema, exported for the loader and the settings page. */
 const Config = z.object({
-	enabled: z.boolean().default(true),
-	ttlDays: z.number().min(1).max(90).default(7),
-	fillName: z.boolean().default(true),
-	fillContext: z.boolean().default(true),
-	fillMaxTokens: z.boolean().default(true),
-	fillReasoning: z.boolean().default(true),
-	fillInput: z.boolean().default(true),
-	providerMap: z.dict(z.string()).default({}),
-	officialProviders: z.array(z.string()).default([...DEFAULT_OFFICIAL_PROVIDERS])
+	enabled: z.boolean().default(true).volatile(),
+	ttlDays: z.number().min(1).max(90).default(7).volatile(),
+	fillName: z.boolean().default(true).volatile(),
+	fillContext: z.boolean().default(true).volatile(),
+	fillMaxTokens: z.boolean().default(true).volatile(),
+	fillReasoning: z.boolean().default(true).volatile(),
+	fillInput: z.boolean().default(true).volatile(),
+	providerMap: z.dict(z.string()).default({}).volatile(),
+	officialProviders: z.array(z.string()).default([...DEFAULT_OFFICIAL_PROVIDERS]).volatile()
 });
 const DEFAULT_CONFIG = {
 	enabled: true,
@@ -78,6 +82,44 @@ const DEFAULT_CONFIG = {
 	providerMap: {},
 	officialProviders: [...DEFAULT_OFFICIAL_PROVIDERS]
 };
+/**
+* Read a config node that may be a plain value or a live (`.volatile()`) node.
+*
+* A plugin whose Config declares volatile fields receives a reactive config
+* whose fields expose `get()`, while hand-written config objects and tests pass
+* plain values. Both shapes are supported here so the same code path serves the
+* settings page, `cordis.patch.yml`, and the unit tests.
+*/
+function liveValue(node, fallback) {
+	if (node === void 0 || node === null) return fallback;
+	const getter = node.get;
+	if (typeof getter === "function") {
+		const value = getter.call(node);
+		return value === void 0 ? fallback : value;
+	}
+	return node;
+}
+/**
+* Project the loader entry config into the plain document shape, per field
+* falling back to {@link DEFAULT_CONFIG}. The config is re-read on EVERY call,
+* so settings-page edits (which the loader swaps into the live cells in place)
+* take effect immediately. Container fields are copied so callers can never
+* mutate the live document through a returned reference.
+*/
+function readConfig(config) {
+	const section = config ?? {};
+	return {
+		enabled: liveValue(section.enabled, DEFAULT_CONFIG.enabled),
+		ttlDays: liveValue(section.ttlDays, DEFAULT_CONFIG.ttlDays),
+		fillName: liveValue(section.fillName, DEFAULT_CONFIG.fillName),
+		fillContext: liveValue(section.fillContext, DEFAULT_CONFIG.fillContext),
+		fillMaxTokens: liveValue(section.fillMaxTokens, DEFAULT_CONFIG.fillMaxTokens),
+		fillReasoning: liveValue(section.fillReasoning, DEFAULT_CONFIG.fillReasoning),
+		fillInput: liveValue(section.fillInput, DEFAULT_CONFIG.fillInput),
+		providerMap: { ...liveValue(section.providerMap, DEFAULT_CONFIG.providerMap) },
+		officialProviders: [...liveValue(section.officialProviders, DEFAULT_CONFIG.officialProviders)]
+	};
+}
 //#endregion
 //#region src/server/catalog.ts
 /**
@@ -309,6 +351,7 @@ const TARGET = TARGET_NS;
 const OWN = PLUGIN_NS;
 var ModelParametersService = class {
 	ctx;
+	entryConfig;
 	/**
 	* The settings service value captured from the inject callback. The plugin
 	* itself declares `inject: []` (settings is optional — headless profiles
@@ -317,42 +360,45 @@ var ModelParametersService = class {
 	* a sibling fiber. The injected child ctx itself is only valid while its
 	* fiber is active — the provider can be reloaded (and every dependent
 	* fiber torn down) while an async reconcile is in flight — so all reads
-	* and writes go through the captured service value, which is a plain
-	* object and never walks the fiber chain.
+	* and writes of the `llm-pi-ai` namespace go through the captured service
+	* value, which is a plain object and never walks the fiber chain.
 	*/
 	settings;
-	scope;
 	lastReport = null;
 	catalog;
 	reconciling = null;
-	constructor(ctx) {
+	/**
+	* @param ctx the plugin context.
+	* @param entryConfig this plugin's own live entry config (the profile entry
+	*   `model-parameters`): the resolved `Config` document, whose `.volatile()`
+	*   fields are live cells that the loader swaps in place on every settings
+	*   write. Read through {@link readConfig} on each access, never cached.
+	*/
+	constructor(ctx, entryConfig) {
 		this.ctx = ctx;
+		this.entryConfig = entryConfig;
 		this.catalog = new CatalogManager(ctx.logger);
 	}
 	start() {
 		this.ctx.inject(["settings"], (sctx) => {
 			this.settings = sctx.settings;
-			this.scope = this.settings.register(OWN, Config);
 			this.reconcile();
 		});
-		this.ctx.on("settings/updated", (ns) => {
+		this.ctx.on("settings/document-updated", (ns) => {
 			if (ns !== TARGET) return;
 			this.reconcile();
 		});
 	}
 	stop() {
-		this.scope = void 0;
 		this.settings = void 0;
 	}
+	/**
+	* The plugin's current settings, projected from the live entry config.
+	* Works with no settings service at all (headless), which is why the plain
+	* {@link DEFAULT_CONFIG} fallback lives in {@link readConfig}.
+	*/
 	config() {
-		if (this.scope !== void 0) try {
-			return this.scope.get();
-		} catch {}
-		return {
-			...DEFAULT_CONFIG,
-			providerMap: {},
-			officialProviders: [...DEFAULT_CONFIG.officialProviders]
-		};
+		return readConfig(this.entryConfig);
 	}
 	catalogSnapshot() {
 		return this.catalog.snapshotOf();
@@ -365,14 +411,21 @@ var ModelParametersService = class {
 		await this.catalog.refresh(this.config().ttlDays);
 		await this.reconcile();
 	}
-	/** Update plugin config toggles from the settings page. */
+	/**
+	* Update the plugin's own settings from the settings page. `dsh-settings`
+	* addresses the plugin's loader entry by its id and refuses any path the
+	* `Config` schema did not mark volatile — every field here is volatile.
+	*/
 	async updateConfig(patch) {
-		if (this.scope === void 0) throw new Error("model-parameters: settings service is not available in this profile");
-		const current = this.config();
-		await this.scope.update({
-			...current,
-			...patch
-		});
+		const settings = this.settings;
+		if (settings === void 0) throw new Error("model-parameters: settings service is not available in this profile");
+		const { providerMap, ...rest } = patch;
+		if (Object.keys(rest).length > 0) await settings.update(OWN, rest);
+		if (providerMap !== void 0) await settings.mutate(OWN, [{
+			op: "set",
+			path: ["providerMap"],
+			value: providerMap
+		}]);
 	}
 	/**
 	* Fill missing fields on every provider model from the catalog. Serialized:
@@ -622,8 +675,8 @@ function stateOf(service) {
 //#region src/index.ts
 const name = "@fonlan/dsh-model-parameters";
 const inject = [];
-function apply(ctx) {
-	const service = new ModelParametersService(ctx);
+function apply(ctx, config = {}) {
+	const service = new ModelParametersService(ctx, config);
 	ctx.effect(() => {
 		service.start();
 		return () => service.stop();

package/lib/types/index.d.ts

@@ -6,15 +6,15 @@
  * tokens / reasoning efforts / input modalities (the norm for a freshly
  * synced gateway), it fills the missing fields from a cached models.dev
  * catalog (TTL-refreshed), and serves the fenced JSON API the web settings
- * page calls. The plugin's own toggles live in the `model-parameters`
- * settings namespace (settings.yaml).
+ * page calls. The plugin's own toggles are its loader entry config (the
+ * `model-parameters` profile entry, schema {@link Config}).
  */
 import type { Context } from '@deepseek-ai/cordis';
-import { Config } from './shared/config.js';
+import { Config, type ModelParametersLiveConfig } from './shared/config.js';
 import { CatalogManager, acceptedInputModalities, identityReasoningEfforts, type CatalogEntry, type CatalogSnapshot } from './server/catalog.js';
 export declare const name = "@fonlan/dsh-model-parameters";
 export declare const inject: string[];
 export { Config };
 export { CatalogManager, acceptedInputModalities, identityReasoningEfforts };
 export type { CatalogEntry, CatalogSnapshot };
-export declare function apply(ctx: Context): void;
+export declare function apply(ctx: Context, config?: ModelParametersLiveConfig): void;

package/lib/types/server/service.d.ts

@@ -1,19 +1,19 @@
 /**
- * The model-parameters service: owns the plugin settings namespace, watches
- * the `llm-pi-ai` namespace for provider model writes, reconciles missing
- * fields from the cached models.dev catalog, and tracks a fill report.
+ * The model-parameters service: completes missing model fields in the
+ * `llm-pi-ai` settings namespace from the cached models.dev catalog and tracks
+ * a fill report. Its own settings ARE this plugin's loader entry config (see
+ * shared/config.ts), so there is no per-plugin settings scope to own here.
  *
  * Trigger model:
  *  - any committed `llm-pi-ai` settings change (settings UI apply, manual
- *    settings.yaml edit published by the file provider, model-router-style
- *    external writes) runs a reconcile;
+ *    profile-patch edit, model-router-style external writes) runs a reconcile;
  *  - plugin start runs a backfill reconcile over the existing configuration.
  * Reconcile is fill-only: it never overwrites a present field, and it writes
  * nothing when nothing is missing — so its own writes cannot re-trigger a
  * second patch (the next event sees the fields present and produces no ops).
  */
 import type { Context } from '@deepseek-ai/cordis';
-import { type ModelParametersConfig } from '../shared/config.js';
+import { type ModelParametersConfig, type ModelParametersLiveConfig } from '../shared/config.js';
 import { type CatalogSnapshot } from './catalog.js';
 /** One reconcile run's outcome, surfaced to the settings page. */
 export interface FillReport {
@@ -27,6 +27,7 @@ export interface FillReport {
 }
 export declare class ModelParametersService {
     private readonly ctx;
+    private readonly entryConfig;
     /**
      * The settings service value captured from the inject callback. The plugin
      * itself declares `inject: []` (settings is optional — headless profiles
@@ -35,23 +36,38 @@ export declare class ModelParametersService {
      * a sibling fiber. The injected child ctx itself is only valid while its
      * fiber is active — the provider can be reloaded (and every dependent
      * fiber torn down) while an async reconcile is in flight — so all reads
-     * and writes go through the captured service value, which is a plain
-     * object and never walks the fiber chain.
+     * and writes of the `llm-pi-ai` namespace go through the captured service
+     * value, which is a plain object and never walks the fiber chain.
      */
     private settings;
-    private scope;
     private lastReport;
     private readonly catalog;
     private reconciling;
-    constructor(ctx: Context);
+    /**
+     * @param ctx the plugin context.
+     * @param entryConfig this plugin's own live entry config (the profile entry
+     *   `model-parameters`): the resolved `Config` document, whose `.volatile()`
+     *   fields are live cells that the loader swaps in place on every settings
+     *   write. Read through {@link readConfig} on each access, never cached.
+     */
+    constructor(ctx: Context, entryConfig: ModelParametersLiveConfig | undefined);
     start(): void;
     stop(): void;
+    /**
+     * The plugin's current settings, projected from the live entry config.
+     * Works with no settings service at all (headless), which is why the plain
+     * {@link DEFAULT_CONFIG} fallback lives in {@link readConfig}.
+     */
     config(): ModelParametersConfig;
     catalogSnapshot(): CatalogSnapshot;
     report(): FillReport | null;
     /** Force a catalog refresh, then reconcile and report. */
     refreshAndReconcile(): Promise<void>;
-    /** Update plugin config toggles from the settings page. */
+    /**
+     * Update the plugin's own settings from the settings page. `dsh-settings`
+     * addresses the plugin's loader entry by its id and refuses any path the
+     * `Config` schema did not mark volatile — every field here is volatile.
+     */
     updateConfig(patch: Partial<ModelParametersConfig>): Promise<void>;
     /**
      * Fill missing fields on every provider model from the catalog. Serialized:

package/lib/types/shared/config.d.ts

@@ -1,14 +1,17 @@
 /**
  * Plugin configuration and shared constants for @fonlan/dsh-model-parameters.
  *
- * The plugin owns the `model-parameters` settings namespace (stored in
- * settings.yaml) and OBSERVES the `llm-pi-ai` namespace: whenever provider
- * models are written there with missing capability fields (which is the norm
- * for a freshly synced gateway), it patches the missing fields from the cached
- * models.dev catalog.
+ * The plugin's own settings ARE its loader entry config (DSH >= 0.1.7): the
+ * profile entry whose id is `model-parameters` (see cordis.patch.yml) is
+ * validated with {@link Config}, the resolved document is handed to
+ * `apply(ctx, config)`, and the settings page is derived from that schema. The
+ * plugin OBSERVES the `llm-pi-ai` namespace: whenever provider models are
+ * written there with missing capability fields (which is the norm for a freshly
+ * synced gateway), it patches the missing fields from the cached models.dev
+ * catalog.
  */
 import z from '@deepseek-ai/schemastery';
-/** This plugin's own settings namespace. */
+/** This plugin's own settings namespace: its profile entry id. */
 export declare const PLUGIN_NS = "model-parameters";
 /** The namespace whose models this plugin completes: pi-ai provider profiles. */
 export declare const TARGET_NS = "llm-pi-ai";
@@ -28,7 +31,7 @@ export declare const ACCEPTED_INPUT_MODALITIES: readonly string[];
  * this set are written.
  */
 export declare const REASONING_LEVELS: readonly string[];
-/** Plugin configuration shape. */
+/** Plugin configuration shape: the PLAIN document, with no live handles in it. */
 export interface ModelParametersConfig {
     /** Master switch: when off, no fills happen (listener is inert). */
     enabled: boolean;
@@ -49,5 +52,84 @@ export interface ModelParametersConfig {
     /** models.dev provider ids treated as first-party vendors for tie-breaking. */
     officialProviders: string[];
 }
-export declare const Config: z<ModelParametersConfig>;
+/**
+ * Recursively readonly value a live handle returns — cosmokit's
+ * `VolatileSnapshot<T>`, spelled locally for the same reason as
+ * {@link LiveSettingsField}.
+ */
+export type LiveSettingsSnapshot<T> = T extends object ? {
+    readonly [K in keyof T]: LiveSettingsSnapshot<T[K]>;
+} : T;
+/**
+ * One `volatile()` config field as the loader hands it to `apply()`: a live
+ * handle, not the value it currently holds. Spelled structurally rather than as
+ * cosmokit's `Volatile<T>` on purpose — cosmokit is a transitive dependency
+ * here, and importing it would put a second schemastery/cosmokit pair into the
+ * emitted declaration.
+ */
+export interface LiveSettingsField<T> {
+    get(): LiveSettingsSnapshot<T>;
+}
+/** A hand-written entry config (profile patch / test fixture): every field is optional. */
+export type ModelParametersConfigInput = {
+    enabled?: boolean | null;
+    ttlDays?: number | null;
+    fillName?: boolean | null;
+    fillContext?: boolean | null;
+    fillMaxTokens?: boolean | null;
+    fillReasoning?: boolean | null;
+    fillInput?: boolean | null;
+    providerMap?: Record<string, string> | null;
+    officialProviders?: string[] | null;
+};
+/** The resolved entry config `apply()` receives: every field is a live handle. */
+export type ResolvedModelParametersConfig = {
+    enabled: LiveSettingsField<boolean>;
+    ttlDays: LiveSettingsField<number>;
+    fillName: LiveSettingsField<boolean>;
+    fillContext: LiveSettingsField<boolean>;
+    fillMaxTokens: LiveSettingsField<boolean>;
+    fillReasoning: LiveSettingsField<boolean>;
+    fillInput: LiveSettingsField<boolean>;
+    providerMap: LiveSettingsField<Record<string, string>>;
+    officialProviders: LiveSettingsField<string[]>;
+};
+/**
+ * Entry config schema. Deliberately NOT annotated `z<ModelParametersConfig>`:
+ * schemastery >= 3.18.3 carries a third `Mode` type parameter, so a
+ * `.volatile()` field's OUTPUT type is `Volatile<T>` (a live `{ get() }` cell),
+ * and that annotation no longer compiles. The plain document shape stays
+ * {@link ModelParametersConfig} and is what {@link readConfig} projects to.
+ *
+ * The annotation below names the type through the package's own default export
+ * (`z<...>`), with locally declared type arguments: the bare inferred type of a
+ * volatile schema resolves through a schemastery copy this package does not
+ * import, so `tsc -p tsconfig.build.json` (`declaration: true`) could not name
+ * it (TS2742) — the emitted declaration stays portable this way.
+ *
+ * `.volatile()` is REQUIRED on every field the settings page may write, not
+ * cosmetic: `dsh-settings` derives `volatileForm(schema)` from this schema, and
+ * with no volatile field at all it SKIPS this entry in `describe()` (the
+ * settings page disappears) and REJECTS every write as a non-volatile path.
+ * The profile entry id (`model-parameters`, see cordis.patch.yml) is the
+ * namespace those writes address.
+ */
+export type ModelParametersConfigSchema = z<ModelParametersConfigInput, ResolvedModelParametersConfig>;
+/** The plugin's `Config` schema, exported for the loader and the settings page. */
+export declare const Config: ModelParametersConfigSchema;
 export declare const DEFAULT_CONFIG: ModelParametersConfig;
+/**
+ * The entry config as `apply()` receives it. Every field may arrive either as a
+ * live `Volatile` cell or as a plain value (a hand-built config object, a
+ * profile patch written before the volatile marker existed, or a host that
+ * resolves the document without the wrapper).
+ */
+export type ModelParametersLiveConfig = Partial<Record<keyof ModelParametersConfig, unknown>>;
+/**
+ * Project the loader entry config into the plain document shape, per field
+ * falling back to {@link DEFAULT_CONFIG}. The config is re-read on EVERY call,
+ * so settings-page edits (which the loader swaps into the live cells in place)
+ * take effect immediately. Container fields are copied so callers can never
+ * mutate the live document through a returned reference.
+ */
+export declare function readConfig(config: ModelParametersLiveConfig | undefined): ModelParametersConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonlan/dsh-model-parameters",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "DSH plugin: when a provider's model sync returns only ids, automatically fill display name, context window, max output tokens, reasoning efforts, and input modalities from the models.dev catalog (cached, TTL-refreshed), and surface a settings page with toggles, refresh, and a fill report.",
   "license": "MIT",
   "repository": {
@@ -69,13 +69,13 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/schemastery": "^3.18.2",
-    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-llm-pi-ai": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.4",
+    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm-pi-ai": "^0.1.2-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-locale": "^0.1.2-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-alpha.2 || ^0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.2-alpha.2 || ^0.2.0-rc.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
@@ -86,13 +86,13 @@
     "tsdown": "^0.22.14",
     "typescript": "^5.9.0",
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/schemastery": "^3.18.2",
-    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-llm-pi-ai": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-alpha.2",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.2-alpha.2"
+    "@deepseek-ai/schemastery": "^3.18.4",
+    "@deepseek-ai/dsh-settings": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm-pi-ai": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-settings": "0.2.0-rc.1"
   },
   "packageManager": "pnpm@11.21.0"
 }

package/src/client/index.tsx

@@ -1,12 +1,9 @@
 /**
- * @fonlan/dsh-model-parameters client half: the plugin's own Settings Card.
+ * @fonlan/dsh-model-parameters client half: the plugin's own Settings section.
  *
- * Registers into the `settings.plugin.item` slot keyed by the `model-parameters`
- * settings namespace (the same string the host half registers), so the card
- * appears inside 设置 → 插件 → 插件配置, paired with the namespace by the tab —
- * exactly like @fonlan/dsh-web-auth. The card draws its own expandable chrome
- * (external plugins cannot import the built-in PluginCard) with styles aligned
- * to the built-in plugin cards.
+ * Registers into the settings.section slot, so the page owns one entry in the
+ * settings sidebar and renders in the panel's content column. The page itself
+ * lives in ./settings-section.
  *
  * Deps resolved from the browser module table: react only. The slots service
  * is reached through the cordis context; types come from devDependencies and
@@ -17,16 +14,18 @@ type ClientContext = Context
 import type {} from '@deepseek-ai/dsh-client-locale/client'
 import type {} from '@deepseek-ai/dsh-client-ui-slots'
 import { LOCALE_NS, zh, en } from './locales'
-import { makeSettingsCard } from './settings-card'
+import { makeSettingsSection } from './settings-section'
 
-/** The settings namespace this card edits (must match the host half). */
-const PLUGIN_NS = 'model-parameters'
+/** The settings sidebar entry this page owns (must stay stable). */
+const SECTION_ID = 'model-parameters'
 
 /** The slots service face (subset of @deepseek-ai/dsh-client-ui-slots). */
 interface SlotEntry {
   name: string
-  key?: string
-  inject?: () => unknown
+  id?: string
+  order?: number
+  label?: () => string
+  locale?: string
 }
 
 interface Slots {
@@ -44,12 +43,16 @@ export function apply(ctx: ClientContext): void {
     return () => off()
   }, 'model-parameters: dictionaries')
 
-  const Card = makeSettingsCard(ctx)
+  const t = ctx.locale.bind(LOCALE_NS) as unknown as (key: string) => string
+  const Section = makeSettingsSection(ctx)
   const slots = (ctx as unknown as { slots: Slots }).slots
-  slots.inject('settings.plugin.item', () =>
+  slots.inject('settings.section', () =>
     slots.register({
-      name: 'settings.plugin.item',
-      key: PLUGIN_NS,
-    }, Card),
+      name: 'settings.section',
+      id: SECTION_ID,
+      order: 320,
+      label: () => t('settingsTitle'),
+      locale: LOCALE_NS,
+    }, Section),
   )
 }

package/src/client/locales.ts

@@ -6,9 +6,7 @@ export const LOCALE_NS = 'model-parameters'
 
 export const zh = {
   settingsTitle: '模型参数补全',
-  cardSub: '补全字段、目录刷新、Provider 映射与补全报告。',
-  collapse: '收起',
-  expand: '展开',
+  sectionSub: '补全字段、目录刷新、Provider 映射与补全报告。',
   master: '启用自动补全',
   masterDesc: '关闭后不再自动补全任何字段（已补全的值保留）。',
   fields: '补全字段',
@@ -53,9 +51,7 @@ export const zh = {
 
 export const en: Record<keyof typeof zh, string> = {
   settingsTitle: 'Model Parameters',
-  cardSub: 'Field toggles, catalog refresh, provider mapping and the fill report.',
-  collapse: 'Collapse',
-  expand: 'Expand',
+  sectionSub: 'Field toggles, catalog refresh, provider mapping and the fill report.',
   master: 'Enable auto-fill',
   masterDesc: 'When off, no fields are filled (already-filled values are kept).',
   fields: 'Fields to fill',