dsh-model-switch 0.4.23 → 0.4.24

package/lib/compaction.js

@@ -81,6 +81,24 @@ function currentCompactionRoute(ctx) {
 	return compactionRouteOf(settings);
 }
 /**
+* Whether the compaction capability is actually served from this context.
+*
+* Awaiting a plugin fiber settles even when the plugin's injections were never
+* satisfied, so the mount is confirmed through the public service instead of by
+* the absence of an error: an unactivated engine must never be recorded as the
+* live engine, or the row would stop retrying while `/compact` had no service.
+* @param ctx - this row's context.
+* @returns true when `ctx.compaction` exposes the engine's public entry points.
+*/
+function engineActive(ctx) {
+	try {
+		const service = ctx.get("compaction", false);
+		return service !== void 0 && typeof service.compactIfNeeded === "function";
+	} catch {
+		return false;
+	}
+}
+/**
 * 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.
@@ -100,7 +118,6 @@ async function mountEngine(ctx, config, label) {
 	try {
 		fiber = ctx.plugin(loaded.default, config);
 		await fiber;
-		return fiber;
 	} catch (cause) {
 		if (fiber) try {
 			await fiber.dispose();
@@ -109,6 +126,14 @@ async function mountEngine(ctx, config, label) {
 		ctx.logger.error(cause);
 		return;
 	}
+	if (engineActive(ctx)) return fiber;
+	ctx.logger.error(`model-switch: the compaction engine mounted with ${label} but never activated; unloading it so the next settings change retries`);
+	try {
+		await fiber.dispose();
+	} catch (cause) {
+		ctx.logger.error("model-switch: failed to unload the unactivated compaction engine");
+		ctx.logger.error(cause);
+	}
 }
 /**
 * Dispose the live engine, keeping the ledger clean for the next mount.
@@ -129,8 +154,11 @@ async function disposeEngine(ctx, state) {
 /**
 * 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.
+* A settings change that leaves the composed config identical — every session
+* naming, subagent, or provider-group save — returns after the signature check,
+* so the engine is never unloaded for settings it does not read. A mount that
+* fails to activate stays unmounted with an explicit error and the next settings
+* change retries with a fresh read.
 * @param ctx - this row's context.
 * @param state - the row's reconcile ledger.
 */
@@ -154,22 +182,25 @@ async function runReconcile(ctx, state) {
 		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.
+* Queue one reconcile behind the row's serialized chain, absorbing failures.
 * @param ctx - this row's context.
 * @param state - the row's reconcile ledger.
+* @param coalesce - collapse a burst of triggers into the single pass that reads the settled settings.
 * @returns The chain tail; never rejects.
 */
-function scheduleReconcile(ctx, state) {
-	state.chain = state.chain.then(() => runReconcile(ctx, state)).catch((cause) => {
+function scheduleReconcile(ctx, state, coalesce) {
+	if (coalesce) {
+		if (state.queued) return state.chain;
+		state.queued = true;
+	}
+	state.chain = state.chain.then(async () => {
+		state.queued = false;
+		await runReconcile(ctx, state);
+	}).catch((cause) => {
+		state.queued = false;
 		ctx.logger.error("model-switch: compaction engine reconcile failed");
 		ctx.logger.error(cause);
 	});
@@ -182,9 +213,10 @@ function scheduleReconcile(ctx, state) {
 * 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
+* `model-switch/settings-update` (emitted by the host at construction, on
+* volatile commits, and on ordinary saves) and read the settled settings, so one
+* save costs at most one remount; 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.
@@ -192,14 +224,15 @@ function scheduleReconcile(ctx, state) {
 async function apply(ctx) {
 	const state = {
 		chain: Promise.resolve(),
+		queued: false,
 		signature: null,
 		engine: void 0,
 		missingRow: false
 	};
 	ctx.on("model-switch/settings-update", () => {
-		scheduleReconcile(ctx, state);
+		scheduleReconcile(ctx, state, true);
 	}, { global: true });
-	await scheduleReconcile(ctx, state);
+	await scheduleReconcile(ctx, state, false);
 }
 //#endregion
-export { apply, compactionRouteOf, composeCompactionConfig, forwardedConfig, inject, name, officialCompactionEntry };
+export { apply, compactionRouteOf, composeCompactionConfig, engineActive, forwardedConfig, inject, name, officialCompactionEntry };

package/lib/index.js

@@ -1,3 +1,4 @@
+import { n as normalizeProviderGroups } from "./provider-group-CsZi7H29.js";
 import { ModelSwitchAdapterRegistry } from "./adapter-registry.js";
 import { createRequire } from "node:module";
 import z from "@deepseek-ai/schemastery";
@@ -12,77 +13,6 @@ 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
@@ -103,6 +33,8 @@ const Config = z.object({
 	autoReviewModel: z.string().volatile(),
 	compactProvider: z.string().volatile(),
 	compactModel: z.string().volatile(),
+	titleProvider: z.string().volatile(),
+	titleModel: z.string().volatile(),
 	providerGroups: z.array(z.object({
 		provider: z.string().default(""),
 		compactProvider: z.string().default(""),
@@ -111,7 +43,9 @@ const Config = z.object({
 		autoReviewModel: z.string().default(""),
 		subagentProvider: z.string().default(""),
 		subagentModel: z.string().default(""),
-		subagentReasoningEffort: z.string().default("")
+		subagentReasoningEffort: z.string().default(""),
+		titleProvider: z.string().default(""),
+		titleModel: z.string().default("")
 	})).default([]).volatile()
 });
 function readConfig(config) {
@@ -126,6 +60,8 @@ function readConfig(config) {
 	const autoReviewModel = config.autoReviewModel.get();
 	const compactProvider = config.compactProvider.get();
 	const compactModel = config.compactModel.get();
+	const titleProvider = config.titleProvider.get();
+	const titleModel = config.titleModel.get();
 	const providerGroups = normalizeProviderGroups(config.providerGroups.get());
 	return {
 		subagentMode: config.subagentMode.get(),
@@ -141,6 +77,8 @@ function readConfig(config) {
 		...autoReviewModel === void 0 || autoReviewModel === "" ? {} : { autoReviewModel },
 		...compactProvider === void 0 || compactProvider === "" ? {} : { compactProvider },
 		...compactModel === void 0 || compactModel === "" ? {} : { compactModel },
+		...titleProvider === void 0 || titleProvider === "" ? {} : { titleProvider },
+		...titleModel === void 0 || titleModel === "" ? {} : { titleModel },
 		...Object.keys(providerGroups).length === 0 ? {} : { providerGroups }
 	};
 }
@@ -771,13 +709,22 @@ function installSwitchCompaction(ctx, settings, roleOf = () => void 0) {
 		const assembled = await next();
 		if (context.agent !== void 0) {
 			assemblies.set(context.agent, assembled);
-			stopGate?.();
-			installGate();
+			const previous = stopGate;
+			let replacement;
+			try {
+				replacement = installGate();
+			} catch (cause) {
+				ctx.logger.warn("model-switch: could not refresh the switch-time compaction guard; the existing guard stays in place");
+				ctx.logger.warn(cause);
+				return assembled;
+			}
+			stopGate = replacement;
+			previous?.();
 		}
 		return assembled;
 	});
 	function installGate() {
-		stopGate = ctx.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
+		return ctx.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
 			const decision = await next();
 			if (decision.kind !== "enter" || signal.aborted) return decision;
 			const enabled = settings().compactOnSwitch !== false;

package/lib/provider-group-CsZi7H29.js

@@ -0,0 +1,94 @@
+//#region lib/types/provider-group.js
+/**
+* Provider configuration groups: per-provider presets for the session-naming
+* and subagent routes.
+*
+* A group is a DERIVED policy, not a write: `src/session-route.ts` resolves the
+* routes one session should use from its own provider plus this stored table, so
+* switching a session's provider never rewrites deployment-wide settings and two
+* sessions on different providers cannot overwrite each other. The field names
+* below are the flat settings field names a group pins, which keeps the stored
+* shape identical to the earlier write-through design.
+*
+* Legacy entries may still carry `compactProvider`/`compactModel`/
+* `autoReviewProvider`/`autoReviewModel`: normalization preserves them so an
+* older stored document is never silently rewritten into a different meaning,
+* while the consumption side ignores them (a group save from the current UI
+* writes '' for every unsupported field, which normalization drops).
+*
+* All functions here are pure and never throw on malformed storage.
+*/
+const ROUTE_FIELDS = Object.freeze([
+	"compactProvider",
+	"compactModel",
+	"autoReviewProvider",
+	"autoReviewModel",
+	"subagentProvider",
+	"subagentModel",
+	"subagentReasoningEffort",
+	"titleProvider",
+	"titleModel"
+]);
+/** 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;
+}
+/**
+* The saved group for a provider.
+* @returns the normalized group, or undefined when the provider has no group —
+* which is what leaves the live routes untouched during a switch.
+*/
+function groupOf(groups, provider) {
+	if (groups === void 0 || provider.trim() === "") return void 0;
+	if (!Object.prototype.hasOwnProperty.call(groups, provider)) return void 0;
+	return groups[provider];
+}
+//#endregion
+export { normalizeProviderGroups as n, groupOf as t };

package/lib/session-route-h9SAqajc.js

@@ -0,0 +1,172 @@
+import { t as groupOf } from "./provider-group-CsZi7H29.js";
+//#region lib/types/session-route.js
+/**
+* Per-session capability route derivation.
+*
+* Model Switch stores one deployment-wide route per capability (the flat
+* settings fields) plus, per provider, a saved provider group. Nothing is
+* written when a session changes provider: this module DERIVES the route a
+* capability should use for one session from (a) the session's own provider and
+* (b) the stored group table. Two sessions on different providers therefore
+* resolve independently, and no session's actions rewrite another session's
+* route.
+*
+* The session's provider is read from durable, official state in this order:
+* the `modelSelection` session projection (`pending` before `lastUsed`, so a
+* selection the user just made counts), then the latest logged request-context
+* route, then the latest `request/header` route. Every read is optional: a
+* session with no observable provider, an unregistered projection, or a
+* profile without the projection package all resolve to the deployment default,
+* which is exactly the pre-derivation behavior.
+*
+* All functions are pure except the readers, which never throw and never write.
+*/
+/** Flat deployment-default fields per capability, in group-storage field names. */
+const CAPABILITY_FIELDS = Object.freeze({
+	compaction: {
+		provider: "compactProvider",
+		model: "compactModel"
+	},
+	autoReview: {
+		provider: "autoReviewProvider",
+		model: "autoReviewModel"
+	},
+	title: {
+		provider: "titleProvider",
+		model: "titleModel"
+	},
+	subagent: {
+		provider: "subagentProvider",
+		model: "subagentModel"
+	}
+});
+/** A non-blank string; blank values behave exactly like an absent field. */
+function present(value) {
+	return typeof value === "string" && value.trim() !== "";
+}
+/** Read one capability's pair from a flat route record; undefined unless both halves are present. */
+function pairOf(source, fields) {
+	if (source === void 0) return void 0;
+	const record = source;
+	const provider = record[fields.provider];
+	const model = record[fields.model];
+	if (!present(provider) || !present(model)) return void 0;
+	return {
+		provider,
+		model
+	};
+}
+/**
+* The deployment-wide route for one capability: the flat settings pair.
+* @param settings - live Model Switch settings; undefined means none are reachable.
+* @param capability - capability whose flat pair is read.
+* @returns The complete pair, or undefined when the capability stays at its official/derived default.
+*/
+function deploymentRoute(settings, capability) {
+	return pairOf(settings, CAPABILITY_FIELDS[capability]);
+}
+/**
+* The route a subagent spawn should use for one parent-session provider.
+*
+* A saved group for that provider pins the spawn; otherwise the flat Subagent
+* card pins it, but only in `fixed` mode — `follow-main` IS the official inherit
+* path, expressed by leaving the request untouched rather than by naming it.
+* @param settings - live Model Switch settings.
+* @param provider - the delegating session's provider, when one is observable.
+* @returns The complete route, or undefined for official inherit.
+*/
+function subagentRouteOf(settings, provider) {
+	const group = groupRoute(settings, provider, "subagent");
+	if (group !== void 0) {
+		const effort = groupOf(settings?.providerGroups, provider ?? "")?.subagentReasoningEffort;
+		return present(effort) ? {
+			...group,
+			reasoningEffort: effort
+		} : group;
+	}
+	if (settings?.subagentMode !== "fixed") return void 0;
+	const fixed = deploymentRoute(settings, "subagent");
+	if (fixed === void 0) return void 0;
+	return present(settings.subagentReasoningEffort) ? {
+		...fixed,
+		reasoningEffort: settings.subagentReasoningEffort
+	} : fixed;
+}
+/**
+* One provider's saved route for one capability.
+* @param settings - live Model Switch settings carrying the group table.
+* @param provider - the session's provider; blank or unknown resolves to undefined.
+* @param capability - capability whose group pin is read.
+* @returns The complete group pair, or undefined when the group pins nothing here.
+*/
+function groupRoute(settings, provider, capability) {
+	if (!present(provider)) return void 0;
+	return pairOf(groupOf(settings?.providerGroups, provider), CAPABILITY_FIELDS[capability]);
+}
+/**
+* The route one capability should use for one session.
+*
+* A saved provider group for the session's provider wins; otherwise the flat
+* deployment default applies. An unknown session provider skips every group, so
+* a session Model Switch cannot attribute keeps the deployment default.
+* @param settings - live Model Switch settings.
+* @param provider - the session's provider, when one is observable.
+* @param capability - capability being resolved.
+* @returns The complete pair, or undefined for the capability's official default.
+*/
+function resolveCapabilityRoute(settings, provider, capability) {
+	return groupRoute(settings, provider, capability) ?? deploymentRoute(settings, capability);
+}
+/**
+* Read the provider from the durable model-selection projection.
+* @param ctx - context that may expose `sessionProjections`.
+* @param session - the session whose selection is read.
+* @returns The pending provider, else the last-used provider, else undefined.
+*/
+function projectionProvider(ctx, session) {
+	let state;
+	try {
+		state = ctx.get("sessionProjections", false)?.stateOf(session, "modelSelection");
+	} catch {
+		state = void 0;
+	}
+	if (state === void 0) return void 0;
+	if (present(state.pending?.provider)) return state.pending.provider;
+	if (present(state.lastUsed?.provider)) return state.lastUsed.provider;
+}
+/**
+* The provider one session is using, from official durable state.
+*
+* Preferred source is the session's own model selection (it covers a switch the
+* client has sent but no request has consumed yet); the logged request-context
+* and request-header routes cover profiles without the projection package and
+* replayed sessions that never emitted a selection.
+* @param ctx - context used for the optional projection read.
+* @param session - the session to resolve; undefined resolves to undefined.
+* @returns The provider, or undefined when nothing durable names one.
+*/
+function sessionProviderOf(ctx, session) {
+	if (session === void 0) return void 0;
+	const selected = projectionProvider(ctx, session);
+	if (selected !== void 0) return selected;
+	try {
+		const context = session.requestContext()?.provider;
+		if (present(context)) return context;
+		const header = session.requestHeader()?.config.provider;
+		if (present(header)) return header;
+	} catch {
+		return;
+	}
+}
+/**
+* The subagent route one exact session's spawns should use.
+* @param ctx - context used for the optional session reads.
+* @param session - the delegating session; undefined keeps official inherit.
+* @param settings - live Model Switch settings.
+* @returns The complete route, or undefined for official inherit.
+*/
+function sessionSubagentRouteOf(ctx, session, settings) {
+	return subagentRouteOf(settings, sessionProviderOf(ctx, session));
+}
+//#endregion
+export { sessionProviderOf as n, sessionSubagentRouteOf as r, resolveCapabilityRoute as t };