dsh-model-switch 0.4.20 → 0.4.22

package/lib/compaction.js

@@ -0,0 +1,205 @@
+//#region lib/types/compaction.js
+/** Official compaction row this module supersedes. */
+const OFFICIAL_COMPACTION_ROW = "compaction-basic";
+/** Official compaction package this module mounts in its place. */
+const OFFICIAL_COMPACTION_PACKAGE = "@deepseek-ai/dsh-compaction-basic";
+/** Cordis plugin identity; matches the cordis.patch.yml insert row id. */
+const name = "model-switch-compaction";
+/** The loader is awaited at row activation; settings and the official row are still read structurally so stock compaction survives a disabled Model Switch row. */
+const inject = ["loader"];
+/**
+* Resolve the configurable summarization route from live settings.
+* @param settings - Model Switch settings carrying the optional compaction pair.
+* @returns Both identifiers trimmed and non-empty, or undefined (official default).
+*/
+function compactionRouteOf(settings) {
+	const provider = settings?.compactProvider?.trim();
+	const model = settings?.compactModel?.trim();
+	if (provider === void 0 || provider === "" || model === void 0 || model === "") return void 0;
+	return {
+		provider,
+		model
+	};
+}
+/**
+* Merge the resolved route over the official row's own config.
+* @param forwarded - config the official compaction-basic row was configured with.
+* @param route - resolved summarization route; undefined keeps official behavior.
+* @returns A detached config safe to hand to a fresh engine construction.
+*/
+function composeCompactionConfig(forwarded, route) {
+	if (!route) return { ...forwarded };
+	return {
+		...forwarded,
+		summarizationProvider: route.provider,
+		summarizationModel: route.model
+	};
+}
+/**
+* Locate the official compaction row in the loader tree.
+* Disabled entries stay in the tree, so a name-matched disable still matches.
+* @param loader - the host loader, when one is reachable.
+* @returns The official entry, or undefined when this profile has no such row.
+*/
+function officialCompactionEntry(loader) {
+	if (!loader) return void 0;
+	for (const entry of loader.entries()) {
+		if (entry.id === OFFICIAL_COMPACTION_ROW) return entry;
+		if (entry.options?.name === OFFICIAL_COMPACTION_PACKAGE) return entry;
+	}
+}
+/**
+* Copy the official row's stored config, ignoring non-object payloads.
+* @param entry - the official compaction entry.
+* @returns A plain object spread; missing or invalid configs become `{}`.
+*/
+function forwardedConfig(entry) {
+	const raw = entry.options?.config;
+	if (raw && typeof raw === "object" && !Array.isArray(raw)) return raw;
+	return {};
+}
+/**
+* Read the live summarization route from the Model Switch host.
+*
+* The host is read structurally instead of injected so this row keeps mounting
+* the official engine (on official defaults) when the `model-switch` row is
+* disabled.
+* @param ctx - this row's context.
+* @returns The configured route, or undefined when unset or host-unavailable.
+*/
+function currentCompactionRoute(ctx) {
+	let settings;
+	try {
+		settings = ctx.get("modelSwitch", false)?.currentSettings();
+	} catch {
+		settings = void 0;
+	}
+	if (!settings) {
+		ctx.logger.info("model-switch: host settings unavailable; compaction uses the official summarization default");
+		return;
+	}
+	return compactionRouteOf(settings);
+}
+/**
+* Load and mount the official basic compaction engine under `config`.
+* @param ctx - this row's context; the engine mounts unisolated so `/compact` sees it.
+* @param config - composed engine config.
+* @param label - which config attempt failed, for the error message.
+* @returns The mounted fiber, or undefined with an explicit error log.
+*/
+async function mountEngine(ctx, config, label) {
+	let loaded;
+	try {
+		loaded = await import("@deepseek-ai/dsh-compaction-basic");
+	} catch (cause) {
+		ctx.logger.error("model-switch: failed to load the official compaction engine package");
+		ctx.logger.error(cause);
+		return;
+	}
+	let fiber;
+	try {
+		fiber = ctx.plugin(loaded.default, config);
+		await fiber;
+		return fiber;
+	} catch (cause) {
+		if (fiber) try {
+			await fiber.dispose();
+		} catch {}
+		ctx.logger.error(`model-switch: failed to mount the compaction engine with ${label}`);
+		ctx.logger.error(cause);
+		return;
+	}
+}
+/**
+* Dispose the live engine, keeping the ledger clean for the next mount.
+* @param ctx - this row's context.
+* @param state - the row's reconcile ledger.
+*/
+async function disposeEngine(ctx, state) {
+	const previous = state.engine;
+	state.engine = void 0;
+	if (!previous) return;
+	try {
+		await previous.dispose();
+	} catch (cause) {
+		ctx.logger.error("model-switch: failed to dispose the previous compaction engine");
+		ctx.logger.error(cause);
+	}
+}
+/**
+* Reconcile one compaction mount: remount only when the composed config changed.
+*
+* Failure ladder: configured config → official defaults (`{}`) → unmounted with
+* explicit errors, so the next settings event retries the whole ladder.
+* @param ctx - this row's context.
+* @param state - the row's reconcile ledger.
+*/
+async function runReconcile(ctx, state) {
+	const entry = officialCompactionEntry(ctx.get("loader", false));
+	if (!entry) {
+		if (!state.missingRow) {
+			state.missingRow = true;
+			ctx.logger.info("model-switch: no official compaction-basic row in this profile; the compaction engine stays unmounted");
+		}
+		return;
+	}
+	state.missingRow = false;
+	const config = composeCompactionConfig(forwardedConfig(entry), currentCompactionRoute(ctx));
+	const signature = JSON.stringify(config);
+	if (state.signature === signature && state.engine) return;
+	await disposeEngine(ctx, state);
+	state.signature = signature;
+	const fiber = await mountEngine(ctx, config, "the configured summarization route");
+	if (fiber) {
+		state.engine = fiber;
+		return;
+	}
+	ctx.logger.error("model-switch: retrying the compaction engine on the official defaults");
+	const fallback = await mountEngine(ctx, {}, "the official defaults");
+	if (fallback) {
+		state.engine = fallback;
+		return;
+	}
+	ctx.logger.error("model-switch: compaction engine is unmounted; /compact and automatic compaction are unavailable until settings change");
+}
+/**
+* Queue a reconcile behind the row's serialized chain, absorbing failures.
+* @param ctx - this row's context.
+* @param state - the row's reconcile ledger.
+* @returns The chain tail; never rejects.
+*/
+function scheduleReconcile(ctx, state) {
+	state.chain = state.chain.then(() => runReconcile(ctx, state)).catch((cause) => {
+		ctx.logger.error("model-switch: compaction engine reconcile failed");
+		ctx.logger.error(cause);
+	});
+	return state.chain;
+}
+/**
+* Mount the Model Switch compaction engine for this profile.
+*
+* Installs a sibling row that replaces the official compaction-basic engine
+* with the same package under the configurable summarization route. Host
+* settings and the loader are read structurally so a disabled `model-switch`
+* row leaves official compaction untouched. Reconciles run on
+* `model-switch/settings-update` (emitted by the host on volatile commits and
+* ordinary saves); the listener is global so instances of this row inside
+* agent-preset realms still hear the host row's emission. The initial
+* reconcile is awaited so `/compact` resolves the service as soon as this row
+* completes.
+* @param ctx - this row's context.
+*/
+async function apply(ctx) {
+	const state = {
+		chain: Promise.resolve(),
+		signature: null,
+		engine: void 0,
+		missingRow: false
+	};
+	ctx.on("model-switch/settings-update", () => {
+		scheduleReconcile(ctx, state);
+	}, { global: true });
+	await scheduleReconcile(ctx, state);
+}
+//#endregion
+export { apply, compactionRouteOf, composeCompactionConfig, forwardedConfig, inject, name, officialCompactionEntry };

package/lib/index.js

@@ -12,7 +12,83 @@ import { dirname, join } from "node:path";
 import { renderPrompt } from "@deepseek-ai/dsh-system-prompt";
 import { boundContextSummary, createMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { canonicalHeader } from "@deepseek-ai/dsh-session";
+//#region lib/types/provider-group.js
+/**
+* Provider configuration groups: per-provider presets for the compaction,
+* subagent, and auto-review routes.
+*
+* A group stores the exact flat settings fields it will write, so applying a
+* group is a plain settings-layer write: every capability consumer keeps
+* reading the live values unchanged. All functions here are pure and never
+* throw on malformed storage.
+*/
+const ROUTE_FIELDS = Object.freeze([
+	"compactProvider",
+	"compactModel",
+	"autoReviewProvider",
+	"autoReviewModel",
+	"subagentProvider",
+	"subagentModel",
+	"subagentReasoningEffort"
+]);
+/** Own data property, so a literal '__proto__' provider id can never touch a prototype. */
+function setKey(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+/** A non-blank string. Blank values behave exactly like an absent field. */
+function present(value) {
+	return typeof value === "string" && value.trim() !== "";
+}
+/** Normalize one raw entry to its owning provider and route view; undefined for non-object junk. */
+function normalizeEntry(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const source = value;
+	const group = {};
+	for (const field of ROUTE_FIELDS) {
+		const item = source[field];
+		if (present(item)) group[field] = item;
+	}
+	return {
+		provider: present(source.provider) ? source.provider : "",
+		group
+	};
+}
+/**
+* Strip a raw stored value to well-formed groups; never throws. Both storage
+* shapes are accepted: the stored entry array (keys live in each entry's
+* `provider` field) and a hand-written provider → routes map (keys are the
+* providers). All-empty entries stay: they pin a provider to every default.
+*/
+function normalizeProviderGroups(raw) {
+	const groups = {};
+	if (Array.isArray(raw)) {
+		for (const entry of raw) {
+			const view = normalizeEntry(entry);
+			if (view === void 0 || view.provider === "") continue;
+			setKey(groups, view.provider, view.group);
+		}
+		return groups;
+	}
+	if (raw !== null && typeof raw === "object") for (const [key, value] of Object.entries(raw)) {
+		if (key.trim() === "") continue;
+		const view = normalizeEntry(value);
+		if (view === void 0) continue;
+		setKey(groups, key, view.group);
+	}
+	return groups;
+}
+//#endregion
 //#region lib/types/host-settings.js
+/**
+* Annotated rather than inferred: the nested entry schema's inferred type
+* expands to cosmokit internals (`Dict`) that cannot be named in the emitted
+* declaration, and the annotation pins the output shape to this interface.
+*/
 const Config = z.object({
 	subagentMode: z.union(["follow-main", "fixed"]).default("follow-main").volatile(),
 	subagentProvider: z.string().volatile(),
@@ -25,7 +101,18 @@ const Config = z.object({
 	compactOnSwitch: z.boolean().default(true).volatile(),
 	autoReviewProvider: z.string().volatile(),
 	autoReviewModel: z.string().volatile(),
-	planCompactThreshold: z.number().default(2e5).volatile()
+	compactProvider: z.string().volatile(),
+	compactModel: z.string().volatile(),
+	providerGroups: z.array(z.object({
+		provider: z.string().default(""),
+		compactProvider: z.string().default(""),
+		compactModel: z.string().default(""),
+		autoReviewProvider: z.string().default(""),
+		autoReviewModel: z.string().default(""),
+		subagentProvider: z.string().default(""),
+		subagentModel: z.string().default(""),
+		subagentReasoningEffort: z.string().default("")
+	})).default([]).volatile()
 });
 function readConfig(config) {
 	const subagentProvider = config.subagentProvider.get();
@@ -37,6 +124,9 @@ function readConfig(config) {
 	const imageModel = config.imageModel.get();
 	const autoReviewProvider = config.autoReviewProvider.get();
 	const autoReviewModel = config.autoReviewModel.get();
+	const compactProvider = config.compactProvider.get();
+	const compactModel = config.compactModel.get();
+	const providerGroups = normalizeProviderGroups(config.providerGroups.get());
 	return {
 		subagentMode: config.subagentMode.get(),
 		...subagentProvider === void 0 ? {} : { subagentProvider },
@@ -49,7 +139,9 @@ function readConfig(config) {
 		compactOnSwitch: config.compactOnSwitch.get(),
 		...autoReviewProvider === void 0 || autoReviewProvider === "" ? {} : { autoReviewProvider },
 		...autoReviewModel === void 0 || autoReviewModel === "" ? {} : { autoReviewModel },
-		planCompactThreshold: config.planCompactThreshold.get()
+		...compactProvider === void 0 || compactProvider === "" ? {} : { compactProvider },
+		...compactModel === void 0 || compactModel === "" ? {} : { compactModel },
+		...Object.keys(providerGroups).length === 0 ? {} : { providerGroups }
 	};
 }
 //#endregion
@@ -347,28 +439,8 @@ async function handleFetchRpc(request, handler, operator) {
 		return statusResponse(500);
 	}
 }
-/** Validate one plan-compact payload; returns the request or an error string. */
-function planCompactRequest(payload) {
-	if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return {
-		ok: false,
-		message: "Expected an object payload"
-	};
-	const { sessionId, provider, model } = payload;
-	if (typeof sessionId !== "string" || sessionId.length === 0 || typeof provider !== "string" || provider.length === 0 || typeof model !== "string" || model.length === 0) return {
-		ok: false,
-		message: "Expected sessionId, provider, and model strings"
-	};
-	return {
-		ok: true,
-		request: {
-			sessionId,
-			provider,
-			model
-		}
-	};
-}
 /** Bounded long-poll on the existing registry; each caller owns and disposes its subscription. */
-function capabilitiesRpc(registry, snapshot, lifetime, planCompact) {
+function capabilitiesRpc(registry, snapshot, lifetime) {
 	let revision = 0;
 	let previous;
 	const read = () => {
@@ -382,39 +454,6 @@ function capabilitiesRpc(registry, snapshot, lifetime, planCompact) {
 		};
 	};
 	return async (endpoint, payload, signal) => {
-		if (endpoint === "plan-compact") {
-			if (planCompact === void 0) return {
-				ok: false,
-				error: {
-					details: {},
-					code: "unavailable",
-					message: "Plan compaction is not mounted on this Host"
-				}
-			};
-			const request = planCompactRequest(payload);
-			if (!request.ok) return {
-				ok: false,
-				error: {
-					details: {},
-					code: "invalid-request",
-					message: request.message
-				}
-			};
-			try {
-				return {
-					ok: true,
-					value: await planCompact(request.request, signal)
-				};
-			} catch (cause) {
-				return {
-					ok: true,
-					value: {
-						status: "error",
-						message: cause instanceof Error ? cause.message : String(cause)
-					}
-				};
-			}
-		}
 		if (endpoint !== "capabilities") return {
 			ok: false,
 			error: {
@@ -467,10 +506,10 @@ function capabilitiesRpc(registry, snapshot, lifetime, planCompact) {
 		};
 	};
 }
-function installCapabilitiesRpc(ctx, registry, snapshot, planCompact) {
+function installCapabilitiesRpc(ctx, registry, snapshot) {
 	ctx.inject(["connection"], (scope) => scope.effect(() => {
 		const lifetime = new AbortController();
-		const handler = capabilitiesRpc(registry, snapshot, lifetime.signal, planCompact);
+		const handler = capabilitiesRpc(registry, snapshot, lifetime.signal);
 		const dispose = scope.connection.fetch.register({
 			path: "/api/plugin-rpc/model-switch",
 			methods: ["POST"],
@@ -925,189 +964,6 @@ async function compactWithPrevious(ctx, agent, previous, signal) {
 	}
 }
 //#endregion
-//#region lib/types/picker/plan-compact.js
-/**
-* Plan-exit compaction vocabulary shared by the card and the Host RPC.
-*
-* The card decides *when* to ask (only an approval that switches the execution
-* model); the Host owns measurement, threshold policy, and the compaction
-* itself. Failures are explicit: the Plan stays pending and can be retried,
-* while an empty history is a completed attempt that may proceed.
-*
-* @module dsh-model-switch/picker/plan-compact
-*/
-/** Whether the user's threshold arms the plan-exit mechanism at all. */
-function planCompactEnabled(threshold) {
-	return Number.isFinite(threshold) && threshold > 0;
-}
-/**
-* Decide whether a plan exit must compact before it switches models.
-* @param threshold — user-configured token threshold; 0 disables the mechanism.
-* @param estimate — measured next-request input tokens.
-* @returns `disabled` when off, `compact` only above the threshold, else `skip`.
-*/
-function planCompactDecision(threshold, estimate) {
-	if (!planCompactEnabled(threshold)) return "disabled";
-	if (!Number.isFinite(estimate) || estimate < 0) return "skip";
-	return estimate > threshold ? "compact" : "skip";
-}
-//#endregion
-//#region lib/types/plan-compact.js
-/**
-* Plan-exit compaction on the Host: measure, threshold, then summarize the
-* history with the switched-to model before the approval resumes the session.
-*
-* The approval answer lands inside a still-open `exit_plan_mode` tool call, so
-* the agent phase is `running` and the idle-only `compactNow` seam is off
-* limits. This module therefore uses `compactIfNeeded(agent, 'context-overflow')`
-* — the same turn-safe, threshold-free operation official overflow recovery
-* uses — under an isolated `compaction-basic` engine configured to summarize
-* with the route the human just chose. The user's threshold decides *whether*
-* to call it; the engine's overflow policy guarantees one useful balanced
-* reduction whenever a safe range exists.
-*
-* @module dsh-model-switch/plan-compact
-*/
-/**
-* Estimate the next request's input tokens under both envelopes.
-*
-* Takes the larger of the target-route heuristic price and the previous
-* envelope's anchored price — the same conservative stance the send-time
-* switch guard takes, so dense histories cannot under-trigger the threshold.
-*
-* @param meter — replay token meter.
-* @param session — session about to resume.
-* @param route — the switched-to provider/model.
-* @returns Estimated tokens, or undefined when no prior request exists to price.
-*/
-function estimatePlanExitTokens(meter, session, route) {
-	const previousHeader = session.requestHeader();
-	if (previousHeader === void 0) return void 0;
-	try {
-		const targetHeader = canonicalHeader({ config: {
-			provider: route.provider,
-			model: route.model
-		} });
-		return Math.max(meter.measure(session, targetHeader).totalTokens, meter.measure(session, previousHeader).totalTokens);
-	} catch {
-		return;
-	}
-}
-/**
-* Drive one compaction through an already-mounted isolated engine.
-* @param engine — engine whose overflow policy selects the range.
-* @param agent — live agent owning the session.
-* @param signal — cancellation scoped to this request.
-* @returns `empty` when no safe range exists, `compacted` after a summary, `error` on failure.
-*/
-async function planCompactWithEngine(engine, agent, signal) {
-	try {
-		const result = await engine.compactIfNeeded(agent, "context-overflow", signal);
-		return result === null || result === void 0 ? { status: "empty" } : { status: "compacted" };
-	} catch (cause) {
-		if (signal.aborted) return {
-			status: "error",
-			message: "compaction was cancelled"
-		};
-		return {
-			status: "error",
-			message: cause instanceof Error ? cause.message : String(cause)
-		};
-	}
-}
-/**
-* Mount an isolated compaction-basic engine pinned to the switched-to route
-* and run one overflow-policy reduction over the agent's session.
-* @param ctx — host context that owns token metering and session state.
-* @param agent — live agent about to resume the approved plan.
-* @param route — provider/model whose model must write the summary.
-* @param signal — cancellation scoped to this request.
-* @param loadEngine — dynamic import seam (tests inject the fake module).
-* @returns The compaction outcome for this request.
-*/
-async function runPlanCompaction(ctx, agent, route, signal, loadEngine) {
-	const load = loadEngine ?? (async () => import("@deepseek-ai/dsh-compaction-basic"));
-	let loaded;
-	try {
-		loaded = await load();
-	} catch (cause) {
-		return {
-			status: "error",
-			message: cause instanceof Error ? cause.message : String(cause)
-		};
-	}
-	const isolated = ctx.isolate("plan-compaction");
-	const fiber = isolated.plugin(loaded.default, {
-		auto: false,
-		summarizationProvider: route.provider,
-		summarizationModel: route.model,
-		compactionRetries: 0
-	});
-	try {
-		await fiber;
-		const engine = isolated.get("compaction", false);
-		if (engine === void 0 || typeof engine.compactIfNeeded !== "function") return {
-			status: "error",
-			message: "private compaction engine is unavailable"
-		};
-		return await planCompactWithEngine(engine, agent, signal);
-	} finally {
-		await fiber.dispose();
-	}
-}
-/**
-* Build the `plan-compact` RPC runner bound to this host's live settings.
-* @param ctx — host context resolving the live agent registry.
-* @param settings — live Model Switch settings (`planCompactThreshold`).
-* @param loadEngine — dynamic import seam (tests inject the fake module).
-* @returns The runner the connection RPC dispatches to.
-*/
-function planCompactRunner(ctx, settings, loadEngine) {
-	return async (request, signal) => {
-		const threshold = settings().planCompactThreshold;
-		if (!planCompactEnabled(threshold)) return {
-			status: "disabled",
-			threshold
-		};
-		const provider = request.provider.trim();
-		const model = request.model.trim();
-		if (provider === "" || model === "") return {
-			status: "error",
-			message: "the execution route is incomplete"
-		};
-		const route = {
-			provider,
-			model
-		};
-		const meter = ctx.get("tokenMeter", false);
-		const agent = ctx.get("agents", false)?.get(request.sessionId);
-		if (agent === void 0) return {
-			status: "error",
-			message: "the session has no live agent"
-		};
-		if (meter === void 0) return {
-			status: "error",
-			message: "token metering is unavailable"
-		};
-		const estimate = estimatePlanExitTokens(meter, agent.session, route);
-		const decision = planCompactDecision(threshold, estimate ?? NaN);
-		if (decision === "disabled") return {
-			status: "disabled",
-			threshold
-		};
-		if (decision === "skip") return {
-			status: "skipped",
-			threshold,
-			...estimate === void 0 ? {} : { estimate }
-		};
-		return {
-			...await runPlanCompaction(ctx, agent, route, signal, loadEngine),
-			threshold,
-			...estimate === void 0 ? {} : { estimate }
-		};
-	};
-}
-//#endregion
 //#region lib/types/host-runtime.js
 /** Host owner for Model Switch settings and the released Main-default adapter. */
 var ModelSwitchRuntime = class extends Service {
@@ -1134,14 +990,16 @@ var ModelSwitchRuntime = class extends Service {
 		installSwitchCompaction(ctx, () => this.source(), (provider) => this.adapters.get(provider)?.role);
 		installDeepSeekSearchAdapter(ctx);
 		installModelSwitchSearchProvider(ctx, this);
-		installCapabilitiesRpc(ctx, this.adapters, () => this.capabilities, planCompactRunner(ctx, () => this.source()));
+		installCapabilitiesRpc(ctx, this.adapters, () => this.capabilities);
 		const imageTool = installGenerateImageTool(ctx, this);
 		ctx.on("loader/volatile-update", () => {
 			imageTool.reconcile().catch((error) => {
 				ctx.logger.error("Model Switch: failed to regenerate generate_image schema");
 				ctx.logger.error(error);
 			});
+			ctx.emit("model-switch/settings-update");
 		});
+		ctx.emit("model-switch/settings-update");
 	}
 	currentSettings() {
 		return { ...this.source() };

package/lib/types/capabilities-rpc.d.ts

@@ -2,12 +2,11 @@ import type { Context } from '@deepseek-ai/cordis';
 import { type ConnectionRpcHandler } from '@deepseek-ai/dsh-client-connection';
 import type { ModelSwitchAdapterRegistry } from './adapter-registry.js';
 import type { RuntimeCapabilities } from './runtime-capabilities.js';
-import type { PlanCompactRunner } from './plan-compact.js';
 export declare const CAPABILITIES_RPC_METHOD = "plugin-rpc/model-switch";
 export interface CapabilitiesSnapshot {
     readonly revision: number;
     readonly capabilities: RuntimeCapabilities;
 }
 /** Bounded long-poll on the existing registry; each caller owns and disposes its subscription. */
-export declare function capabilitiesRpc(registry: ModelSwitchAdapterRegistry, snapshot: () => RuntimeCapabilities, lifetime: AbortSignal, planCompact?: PlanCompactRunner): ConnectionRpcHandler;
-export declare function installCapabilitiesRpc(ctx: Context, registry: ModelSwitchAdapterRegistry, snapshot: () => RuntimeCapabilities, planCompact?: PlanCompactRunner): void;
+export declare function capabilitiesRpc(registry: ModelSwitchAdapterRegistry, snapshot: () => RuntimeCapabilities, lifetime: AbortSignal): ConnectionRpcHandler;
+export declare function installCapabilitiesRpc(ctx: Context, registry: ModelSwitchAdapterRegistry, snapshot: () => RuntimeCapabilities): void;

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

@@ -3,6 +3,7 @@ import type { ModelProviderGroup } from '@deepseek-ai/dsh-api-session-controller
 import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client';
 import type { InjectFace, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import { type CapabilityRouteView, type MainSettingsView, type ModelSwitchSettingsView, type SubagentSettingsView } from '../client-contract.js';
+import { type ProviderGroupConfig } from '../provider-group.js';
 import type { RuntimeCapabilities } from '../runtime-capabilities.js';
 import { type CapabilitiesSnapshot } from './search-capabilities.js';
 import type { ModelSwitchLocaleKey } from './locales.js';
@@ -15,14 +16,16 @@ export interface ModelSwitchSettingsFace {
         searchSettings: ConfigViewForm<CapabilityRouteView>;
         imageSettings: ConfigViewForm<CapabilityRouteView>;
         autoReviewSettings: ConfigViewForm<CapabilityRouteView>;
+        compactionSettings: ConfigViewForm<CapabilityRouteView>;
         switchSettings: Pick<ConfigForm<ModelSwitchSettingsView>, 'getSnapshot' | 'subscribe'>;
     };
     capabilities: RuntimeCapabilities;
     saveMain: (next: MainSettingsView, expectedRevision: number) => Promise<number>;
     setSubagent: (field: 'mode' | 'provider' | 'model' | 'reasoningEffort', value: string | undefined) => Promise<void>;
-    setCapability: (route: 'search' | 'image' | 'autoReview', field: 'provider' | 'model', value: string | undefined) => Promise<void>;
+    setCapability: (route: 'search' | 'image' | 'autoReview' | 'compaction', field: 'provider' | 'model', value: string | undefined) => Promise<void>;
     setCompactOnSwitch: (value: boolean) => Promise<void>;
-    setPlanCompactThreshold: (value: number) => Promise<void>;
+    /** Replace or remove (undefined) one provider's saved capability group. */
+    saveProviderGroup: (provider: string, group: ProviderGroupConfig | undefined) => Promise<void>;
     loadCatalog: () => Promise<readonly ModelProviderGroup[]>;
     /** Host capabilities long-poll; absent in legacy faces, which keep the static-capabilities path. */
     loadCapabilities?: (revision?: number, signal?: AbortSignal) => Promise<CapabilitiesSnapshot>;

package/lib/types/client/derived-settings-scope.d.ts

@@ -1,4 +1,4 @@
-import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client';
-export type SettingsFieldMap<View> = Readonly<Partial<Record<keyof View & string, string>>>;
-/** Projection over one shared SettingsScope controller/store, with explicit view-to-owner field mapping. */
-export declare function deriveSettingsScope<Source, View>(source: SettingsScope<Source>, project: (value: Source) => View, fields?: SettingsFieldMap<View>): SettingsScope<View>;
+import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client';
+export type SettingsFieldMap<View> = Readonly<Partial<Record<keyof View & string, string>>>;
+/** Projection over one shared SettingsScope controller/store, with explicit view-to-owner field mapping. */
+export declare function deriveSettingsScope<Source, View>(source: SettingsScope<Source>, project: (value: Source) => View, fields?: SettingsFieldMap<View>): SettingsScope<View>;