dsh-model-switch 0.4.24 → 0.4.26

package/lib/types/client-contract.d.ts

@@ -10,7 +10,6 @@ export interface ModelSwitchSettingsView {
     searchModel?: string;
     imageProvider?: string;
     imageModel?: string;
-    compactOnSwitch?: boolean;
     autoReviewProvider?: string;
     autoReviewModel?: string;
     compactProvider?: string;

package/lib/types/compaction.d.ts

@@ -1,6 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { Entry, Loader } from '@deepseek-ai/cordis-plugin-loader';
 import type { BasicCompactionConfig } from '@deepseek-ai/dsh-compaction-basic';
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm';
 /** Cordis plugin identity; matches the cordis.patch.yml insert row id. */
 export declare 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. */
@@ -8,17 +9,21 @@ export declare const inject: string[];
 /**
  * Both identifiers trimmed and non-empty; undefined means "official default".
  *
- * The summarization route stays deployment-wide on purpose. The official
- * compaction transaction durably records the provider/model that wrote the
- * summary, so a per-session rewrite of the summarization call would make that
- * record false; a deployment that needs provider-scoped summarization uses the
- * official exact-target `modelPolicies` table, which this row forwards
- * verbatim from the profile's `compaction-basic` row config.
+ * Each summarization call derives its route per session (the session's provider
+ * group → the flat compaction card → the official row's `modelPolicies` /
+ * conversation-target fallback) and mutates `options.provider`/`options.model`
+ * in place before `ctx.llm.stream(options)` so the official `summarizeWithLlm`
+ * returns and durably records the exact route that wrote the summary in
+ * `compaction/summary`.
  */
 export interface CompactionRoute {
     readonly provider: string;
     readonly model: string;
 }
+/** Public llm face the official compaction engine uses (`stream` + `resolveModelInfo`). */
+export interface CompactionLlm {
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
 /**
  * Resolve the configurable summarization route from live settings.
  * @param settings - Model Switch settings carrying the optional compaction pair.
@@ -48,6 +53,45 @@ export declare function officialCompactionEntry(loader: Loader | undefined): Ent
  * @returns A plain object spread; missing or invalid configs become `{}`.
  */
 export declare function forwardedConfig(entry: Entry): BasicCompactionConfig;
+/**
+ * Resolve the compaction summarization route for one session id.
+ *
+ * Looks up the session from `ctx.sessions` when available, derives its current
+ * provider (`pending` selection preferred over `lastUsed`, then logged routes),
+ * and resolves the provider group's compaction pair before falling back to the
+ * deployment-wide compaction pair.
+ * @param ctx - this row's context.
+ * @param sessionId - the session id carried on `GenerateOptions.sessionId`.
+ * @returns The derived compaction route, or undefined for the engine's own route.
+ */
+export declare function resolveSessionCompactionRoute(ctx: Context, sessionId: string | undefined): CompactionRoute | undefined;
+/**
+ * Wrap the real llm service so `purpose === 'compaction'` calls resolve their
+ * summarization route per session while keeping `compaction/summary` truthful.
+ *
+ * `summarizeWithLlm` builds a mutable `options` literal with `purpose: 'compaction'`
+ * and `sessionId: agent.session.id`, calls `ctx.llm.stream(options)`, and then
+ * returns `{ provider: options.provider, model: options.model }` to `commitCompactionBody`.
+ * Mutating `options.provider` and `options.model` in place before delegating to
+ * `target.stream(options)` ensures the durable `compaction/summary` event
+ * records the exact provider/model that wrote the summary. All other members
+ * (such as `resolveModelInfo`) pass through bound to `real`.
+ * @param real - the host's `ctx.llm`.
+ * @param resolve - per-session route resolver; undefined keeps `options` untouched.
+ * @param onError - optional error sink when the resolver throws.
+ * @returns A transparent Proxy over `real`.
+ */
+export declare function compactionLlm<T extends CompactionLlm>(real: T, resolve: (sessionId: string) => CompactionRoute | undefined, onError?: (cause: unknown) => void): T;
+/**
+ * Build the child context the compaction engine mounts under.
+ *
+ * When `ctx.llm` is present, shadows it with {@link compactionLlm} on an
+ * extended context so the child engine fiber resolves the per-session wrapper
+ * while registering `ctx.compaction` on the shared context tree.
+ * @param ctx - this row's context.
+ * @returns A context shadowing `llm` when available, else `ctx`.
+ */
+export declare function compactionScope(ctx: Context): Context;
 /**
  * Whether the compaction capability is actually served from this context.
  *

package/lib/types/host-settings.d.ts

@@ -12,7 +12,6 @@ export interface ModelSwitchSettings {
     searchModel?: string;
     imageProvider?: string;
     imageModel?: string;
-    compactOnSwitch: boolean;
     /** Reviewer provider for the Auto preset; both fields unset = follow the session model. */
     autoReviewProvider?: string;
     /** Reviewer model for the Auto preset; set together with `autoReviewProvider`. */
@@ -38,7 +37,6 @@ export interface Config {
     searchModel: Volatile<string | undefined>;
     imageProvider: Volatile<string | undefined>;
     imageModel: Volatile<string | undefined>;
-    compactOnSwitch: Volatile<boolean>;
     autoReviewProvider: Volatile<string | undefined>;
     autoReviewModel: Volatile<string | undefined>;
     compactProvider: Volatile<string | undefined>;

package/lib/types/provider-group.d.ts

@@ -1,23 +1,17 @@
 /**
- * Provider configuration groups: per-provider presets for the session-naming
- * and subagent routes.
+ * Provider configuration groups: per-provider presets for the compaction,
+ * auto-review, 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).
+ * shape identical across releases.
  *
  * All functions here are pure and never throw on malformed storage.
  */
-/** Flat settings fields a provider group carries; the first four are legacy-only. */
+/** Flat settings fields a provider group carries across all four per-session capabilities. */
 export type ProviderGroupRouteField = 'compactProvider' | 'compactModel' | 'autoReviewProvider' | 'autoReviewModel' | 'subagentProvider' | 'subagentModel' | 'subagentReasoningEffort' | 'titleProvider' | 'titleModel';
 /** Stored entry: the owning provider plus every route field; '' means the capability stays at its default. */
 export interface ProviderGroupEntry {

package/lib/types/session-title.d.ts

@@ -8,25 +8,40 @@
  * saved group is named through that group's pair while every other session keeps
  * following its own model.
  *
- * The call itself stays inside the official implementation: the exported
- * `generateSessionTitleWithLlm` receives the session-resolved config and records
- * exactly that route in `session/title-llm-request`, so the durable record and
- * the actual request can never disagree. Nothing is remounted when settings
- * change — the route is read through on every naming request — so a settings
- * save can neither interrupt an in-flight naming request nor leave the profile
- * without a registered provider.
+ * The call itself stays inside the official implementation: the auxiliary-LLM
+ * package records exactly the route that was called in `session/title-llm-request`,
+ * so the durable record and the actual request can never disagree. Nothing is
+ * remounted when settings change — the route is read through on every naming
+ * request — so a settings save can neither interrupt an in-flight naming request
+ * nor leave the profile without a registered provider.
  *
- * `cordis.patch.yml` disables the official row (the seam allows one registered
- * provider per context), and this row mirrors the cadence the disabled row
+ * Two official auxiliary-LLM lines are supported, selected at runtime from the
+ * module surface, because the 0.2.1 release replaced the shared title call:
+ * - Up to DSH 0.2.0 (`generateSessionTitleWithLlm`): the module owns the system
+ *   prompt, input framing, and output validation; the shared policy carries the
+ *   title-length targets.
+ * - DSH 0.2.1+ (`executeSessionTitleLlm`): the provider owns the system prompt,
+ *   the input, the reasoning-effort selection, and the output interpretation;
+ *   the shared policy carries execution controls only. This row mirrors the
+ *   official provider's wording and interpretation so a configured route keeps
+ *   the official behavior.
+ *
+ * A naming request that fails is retried once with a widened output budget
+ * (max-token failures only) and then falls through the remaining route
+ * candidates — the session group's pair, the deployment-wide pair, the row's own
+ * pair, then the session's logged route — so one unavailable model or provider
+ * cannot leave the session on its deterministic fallback title forever.
+ *
+ * `cordis.patch.yml` disables the official rows (the seam allows one registered
+ * provider per context), and this row mirrors the cadence a disabled row
  * declared, so a profile that restated the row as all-prompts keeps its cadence.
  *
  * @module dsh-model-switch/session-title
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { Entry, Loader } from '@deepseek-ai/cordis-plugin-loader';
-import type { SessionTitleAutomaticMode, SessionTitleProviderId, SessionTitleUserMessage } from '@deepseek-ai/dsh-session-title';
-import type { ResolvedSessionTitleLlmConfig, SessionTitleLlmConfig } from '@deepseek-ai/dsh-session-title-llm';
-import { type CapabilityRoute } from './session-route.js';
+import type { SessionTitleAutomaticMode, SessionTitleProviderId, SessionTitleProviderRequest, SessionTitleUserMessage } from '@deepseek-ai/dsh-session-title';
+import { type CapabilityRoute, type RouteBearingSettings } from './session-route.js';
 /** Cordis plugin identity; matches the cordis.patch.yml insert row id. */
 export declare const name = "model-switch-session-title";
 /** The loader names the disabled row, and the seam services the call needs are awaited before the first naming request. */
@@ -44,6 +59,57 @@ export interface TitleCadence {
 }
 /** Both official cadence packages, in the order a profile may declare them. */
 export declare const TITLE_CADENCES: readonly TitleCadence[];
+/** Title-length targets that shape the system instruction. */
+export interface TitleLengthTargets {
+    readonly targetWords: number;
+    readonly targetCjkCharacters: number;
+}
+/** Route-bearing execution policy shared by both official auxiliary-LLM lines. */
+export interface TitleLlmPolicy {
+    readonly maxInputBytes: number;
+    readonly maxOutputTokens: number;
+    readonly timeoutMs: number;
+    readonly provider?: string;
+    readonly model?: string;
+}
+/** The model metadata `executeSessionTitleLlm` hands its reasoning selector. */
+export interface TitleModelMetadata {
+    readonly reasoning?: {
+        readonly efforts?: readonly {
+            readonly id: string;
+        }[];
+    };
+}
+/** Provider-owned preparation for one 0.2.1+ auxiliary title request. */
+export interface PreparedTitleCall {
+    readonly system: string;
+    readonly input: string;
+    readonly messageSeqs: readonly SessionTitleUserMessage['seq'][];
+    readonly selectReasoningEffort: (model: TitleModelMetadata) => string | undefined;
+}
+/** One content block of the assembled 0.2.1+ auxiliary response. */
+export interface TitleResponseBlock {
+    readonly type: string;
+    readonly text?: string;
+}
+/** The assembled 0.2.1+ auxiliary response this row interprets. */
+export interface TitleLlmResponse {
+    readonly blocks: readonly TitleResponseBlock[];
+    readonly finish: {
+        readonly kind: string;
+    };
+    readonly model: {
+        readonly provider: string;
+        readonly model: string;
+    };
+}
+/** The auxiliary-LLM module surface; the call entry point differs per DSH line. */
+type TitleLlmModule = typeof import('@deepseek-ai/dsh-session-title-llm');
+/** The untrusted policy split both lines consume. */
+export interface SplitTitlePolicy {
+    readonly execution: Record<string, unknown>;
+    readonly targets: TitleLengthTargets;
+}
 /**
  * The cadence one official package name declares.
  * @param pkg - the disabled row's package name.
@@ -61,7 +127,7 @@ export declare function titleCadence(pkg: string | undefined): TitleCadence | un
  * @param route - session-resolved naming route, or undefined for the row's own policy.
  * @returns A detached config for one naming request.
  */
-export declare function composeTitleRoute(config: ResolvedSessionTitleLlmConfig, route: CapabilityRoute | undefined): ResolvedSessionTitleLlmConfig;
+export declare function composeTitleRoute(config: TitleLlmPolicy, route: CapabilityRoute | undefined): TitleLlmPolicy;
 /**
  * Frame the exact human messages one naming revision represents.
  * @param messages - every eligible human message of the revision.
@@ -84,13 +150,126 @@ export declare function officialTitleEntry(loader: Loader | undefined): Entry |
  * result is untrusted: the profile may be hand-edited, so the official policy
  * validator runs over it before any naming request is served.
  */
-export declare function forwardedConfig(entry: Entry): Partial<SessionTitleLlmConfig>;
+export declare function forwardedConfig(entry: Entry): Record<string, unknown>;
 /**
  * The official package name this row mounts (either cadence).
  * @param entry - the official session-title provider entry.
  * @returns The package name, or undefined when the row declares none.
  */
 export declare function officialTitlePackage(entry: Entry): string | undefined;
+/**
+ * Split one untrusted stored policy into the halves both official lines accept.
+ *
+ * Execution controls pass through untouched (an invalid value still fails the
+ * official validator). Absent execution fields fall back to the shipped
+ * official defaults, because a profile that mounts no official row has no
+ * policy to forward and this row must still run. Title-length targets are read
+ * here for the system instruction: the pre-0.2.1 line wants them in its shared
+ * config, while 0.2.1 moved them into each provider.
+ * @param forwarded - the disabled official row's stored config.
+ * @returns The execution subset and the title-length targets.
+ */
+export declare function splitTitlePolicy(forwarded: Record<string, unknown>): SplitTitlePolicy;
+/**
+ * Detect the 0.2.1+ auxiliary-LLM line.
+ * @param module - the loaded auxiliary-LLM package.
+ * @returns Whether the module exposes the provider-prepared call.
+ */
+export declare function isModernTitleModule(module: TitleLlmModule): boolean;
+/** One validated naming policy: the execution config plus the targets the system instruction needs. */
+export interface ResolvedNamingPolicy {
+    readonly config: TitleLlmPolicy;
+    readonly targets: TitleLengthTargets;
+}
+/**
+ * Validate the stored policy through the official validator of the installed line.
+ * @param module - the loaded auxiliary-LLM package.
+ * @param forwarded - the disabled official row's stored config.
+ * @returns The validated execution config and title-length targets.
+ * @throws when the official validator rejects the stored policy.
+ */
+export declare function resolveNamingPolicy(module: TitleLlmModule, forwarded: Record<string, unknown>): ResolvedNamingPolicy;
+/**
+ * Candidate routes for one naming request, most specific first and deduplicated.
+ *
+ * The stored session group's pair wins, then the deployment-wide pair, then the
+ * row's own configured pair, then the session's logged route. The list is also
+ * the fallback order: a failing candidate falls through to the next one.
+ * @param settings - live Model Switch settings; undefined skips the stored pairs.
+ * @param provider - the delegating session's provider, when one is observable.
+ * @param policy - the validated row policy (its own pair is the third candidate).
+ * @param requestRoute - the session's logged main-request route, when one exists.
+ * @returns The ordered, deduplicated candidates; empty when only the row policy applies.
+ */
+export declare function titleRouteCandidates(settings: RouteBearingSettings | undefined, provider: string | undefined, policy: TitleLlmPolicy, requestRoute: CapabilityRoute | undefined): readonly CapabilityRoute[];
+/**
+ * Whether a failure may be retried on another candidate.
+ * A superseded or disposed request keeps no budget, and a deadline that fired is
+ * the caller's bound, not the route's fault: both end the attempt loop.
+ * @param error - the failure thrown by the auxiliary call.
+ * @param request - the service-owned request whose signal bounds the work.
+ * @returns Whether another candidate may be tried.
+ */
+export declare function shouldTryNextCandidate(error: unknown, request: SessionTitleProviderRequest): boolean;
+/**
+ * Whether the failure is the model filling its output budget before finishing.
+ * Official lines report this as `title output reached maxOutputTokens`; a widened
+ * budget is the only retry that can succeed for it.
+ * @param error - the failure thrown by the auxiliary call.
+ * @returns Whether one widened-budget retry is worth trying.
+ */
+export declare function isMaxTokensFailure(error: unknown): boolean;
+/**
+ * A widened output budget for the same route.
+ * @param maxOutputTokens - the policy's configured budget.
+ * @returns Four times the budget, capped at 4096 tokens.
+ */
+export declare function widerTitleBudget(maxOutputTokens: number): number;
+/**
+ * Normalize one accepted title exactly like the official service.
+ * @param input - untrusted title text.
+ * @returns A terminal-safe, whitespace-normalized one-line title, possibly empty.
+ */
+export declare function normalizeTitleText(input: string): string;
+/**
+ * Take the title from model output: the first non-empty line, without asterisk
+ * emphasis wrapping that whole line. Models that disregard the one-line
+ * instruction put the title first and commentary after it.
+ * @param text - joined text blocks of the auxiliary response.
+ * @returns The candidate title line.
+ */
+export declare function titleFromOutput(text: string): string;
+/**
+ * Interpret one assembled 0.2.1+ response as a title.
+ * Rejects terminal tool-call and max-token outcomes exactly like the official
+ * provider, so the row keeps the official acceptance rules.
+ * @param response - the assembled auxiliary response.
+ * @returns A non-empty normalized title.
+ * @throws when the finish reason, a tool-call block, or empty text makes the response unusable.
+ */
+export declare function titleFromResponse(response: TitleLlmResponse): string;
+/**
+ * Select the route's least supported reasoning effort for a title call, as the
+ * official 0.2.1 provider does: naming is a short auxiliary task, and a full
+ * reasoning budget can consume the whole output allowance.
+ * @param model - the prepared model metadata.
+ * @returns The first declared effort id, or undefined when the model has none.
+ */
+export declare function selectTitleReasoningEffort(model: TitleModelMetadata): string | undefined;
+/**
+ * The official 0.2.1+ system instruction, including the optional current-title anchor.
+ * @param targets - title-length targets.
+ * @param hasCurrentTitle - whether the request is anchored to an existing provider title.
+ * @returns The system prompt text.
+ */
+export declare function titleSystemPrompt(targets: TitleLengthTargets, hasCurrentTitle: boolean): string;
+/**
+ * Frame the exact messages as JSON so user text cannot break structural delimiters.
+ * @param messages - the selected human messages.
+ * @param currentTitle - the accepted provider title to anchor on, when there is one.
+ * @returns The framed user input.
+ */
+export declare function frameTitleInput(messages: readonly SessionTitleUserMessage[], currentTitle: string | undefined): string;
 /**
  * Mount the Model Switch session-naming row for this profile.
  *
@@ -102,3 +281,4 @@ export declare function officialTitlePackage(entry: Entry): string | undefined;
  * @param ctx - this row's context.
  */
 export declare function apply(ctx: Context): Promise<void>;
+export {};

package/lib/types/subagent-runtime.d.ts

@@ -48,6 +48,16 @@ export declare function routeSubagentRequest<T extends RoutableSubagentRequest>(
  * @throws the fallback startup error when fallback startup fails.
  */
 export declare function mountWithStartupFallback<T>(candidate: (track: StartupCleanupTracker) => Promise<T>, fallback: (track: StartupCleanupTracker) => Promise<T>): Promise<MountedStartup<T>>;
+/**
+ * Operator-facing notice for a Host whose Subagent runtime cannot be routed.
+ *
+ * DSH 0.2.1 replaced `start()`/`startContinuable()` with the activation API, so
+ * this adapter's override point is gone; the row then mounts the untouched
+ * official runtime instead of guessing a new seam.
+ * @param error - the typed startup incompatibility that rejected the candidate.
+ * @returns The notice logged once at startup.
+ */
+export declare function routedRuntimeUnavailableNotice(error: StartupIncompatibilityError): string;
 /** Profile replacement that selects the routed runtime or the untouched official runtime. */
 export declare const profileSubagentRuntime: ((ctx: Context) => Promise<() => Promise<void>>) & {
     inject: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-model-switch",
-  "version": "0.4.24",
+  "version": "0.4.26",
   "description": "Explicit model routing plus composer/Plan picker for DeepSeek Harness",
   "repository": {
     "type": "git",
@@ -106,7 +106,8 @@
         "0.1.7-alpha.2": "compatible",
         "0.1.7-rc.1": "compatible",
         "0.1.7-rc.2": "compatible",
-        "0.2.0-rc.2": "compatible"
+        "0.2.0-rc.2": "compatible",
+        "0.2.1-rc.2": "compatible"
       }
     }
   },

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

@@ -1,4 +0,0 @@
-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>;

package/lib/types/client/picker/main-default-restore.d.ts

@@ -1,56 +0,0 @@
-/**
- * Compensate the Host's own deployment-default write after a Session-only
- * model switch.
- *
- * `session.selectModel` installs the Session selection and, on Hosts that
- * persist a selection as the deployment default, also writes that default.
- * The plugin switches a Session only, so the captured Main default is restored
- * afterwards.
- *
- * That Host write is fenced by a settings revision, and its timing is not part
- * of the released contract: the 0.1.x generation awaited the default write
- * before its RPC resolved, while the 0.2.x generation fires it without
- * awaiting. A fixed `captured + 1` fence therefore either refuses the restore
- * or silently leaves the default switched. Poll-by-revision is used instead:
- * wait for the observed revision to leave the captured one, then fence on the
- * revision actually observed.
- */
-import type { SettingsPathOpView } from '@deepseek-ai/dsh-api-remotes/client';
-import type { ConfigFormSnapshot } from '@deepseek-ai/dsh-client-ui-settings/client';
-import type { MainSettingsView } from '../../client-contract.ts';
-/** The Main Settings namespace surface this module needs. */
-export interface MainDefaultForm {
-    getSnapshot(): ConfigFormSnapshot<MainSettingsView>;
-    subscribe(listener: () => void): () => void;
-    mutate(ops: readonly SettingsPathOpView[], expectedRevision?: number): Promise<boolean>;
-}
-/** Outcome of one compensation attempt. */
-export interface MainDefaultRestore {
-    /** The captured Main default is the effective one again (or no write occurred). */
-    restored: boolean;
-    /** A newer revision won instead; the concurrent edit is left untouched. */
-    conflict: boolean;
-}
-export interface MainDefaultRestoreOptions {
-    /** Timeout primitive; tests inject a deterministic one. */
-    wait?: (ms: number) => Promise<void>;
-    /** How long to await the unawaited Host default write. */
-    timeoutMs?: number;
-    /** Total fences, including one retry after a concurrent revision change. */
-    attempts?: number;
-}
-/** Field writes restoring one complete Main selection; the Host replaces the section. */
-export declare function mainDefaultOps(selection: MainSettingsView): SettingsPathOpView[];
-/**
- * Restore the Main default captured before a Session-only model switch.
- *
- * Never throws and never blocks a Plan answer: a failed compensation is
- * reported, not enforced, because the Session selection the human asked for is
- * already installed by the time this runs.
- *
- * @param form - the official Main Settings namespace form.
- * @param before - the snapshot captured before the switch.
- * @param options - wait/timeout/attempt overrides for tests.
- * @returns Whether the captured default stands again, and whether a newer edit won.
- */
-export declare function restoreMainDefault(form: MainDefaultForm, before: ConfigFormSnapshot<MainSettingsView>, options?: MainDefaultRestoreOptions): Promise<MainDefaultRestore>;

package/lib/types/client/picker/provider-group-watch.d.ts

@@ -1,48 +0,0 @@
-/**
- * Apply a provider's saved capability group whenever the seat session's
- * provider changes — on any switch surface.
- *
- * The official model-selection directory projects the Session's durable
- * `model/selection` events into `store.current` (the sole emitter of those
- * events is the `session.selectModel` RPC), so a switch performed through the
- * TUI or any other client lands in the same store this plugin already reads.
- * One watcher therefore covers every surface for sessions open in this Web
- * UI, where the previous wiring only covered this plugin's own two call sites.
- *
- * Semantics stay exactly as before: a provider change applies the target
- * provider's group when one exists; a provider without a group, a same-model
- * change within one provider, and the subscription baseline itself write
- * nothing. A failed apply is reported and never disturbs the switch.
- */
-import type { ModelSelection } from '@deepseek-ai/dsh-api-session-controller/types';
-/** The directory store slice the watcher observes. */
-export interface DirectoryWatchSource {
-    subscribe: (listener: () => void) => () => void;
-    getSnapshot: () => {
-        current: ModelSelection | null;
-    };
-}
-export interface ProviderGroupWatchOptions {
-    source: DirectoryWatchSource;
-    /** Adopt the target provider's saved group; a group-less provider must write nothing. */
-    apply: (provider: string) => Promise<void>;
-    /** Reported apply failure; defaults to a console warning. */
-    onFailure?: (error: unknown) => void;
-}
-export interface ProviderGroupWatch {
-    /** Detach from the store; in-flight applies are left to finish. */
-    dispose: () => void;
-}
-/**
- * Watch one directory store and apply groups on provider changes.
- *
- * - The first observed provider (or the one already loaded) is the baseline
- *   and never triggers a write, so mounting and initial load stay silent.
- * - Applies are serialized: a change arriving mid-apply coalesces to the
- *   latest target and runs once the current apply finishes, so two writes
- *   never interleave pair writes.
- * - `current` being null (catalog still loading) is ignored, not a change.
- * @param options - the store to watch and the apply to run.
- * @returns the watch handle.
- */
-export declare function createProviderGroupWatch(options: ProviderGroupWatchOptions): ProviderGroupWatch;

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

@@ -1,45 +0,0 @@
-import type { SettingsPathOpView } from '@deepseek-ai/dsh-api-remotes/client';
-import type { SettingsScope, SettingsScopeSnapshot } from '@deepseek-ai/dsh-client-ui-settings/client';
-interface RemoteError {
-    code: string;
-    message: string;
-}
-interface RemoteResult<T> {
-    ok: boolean;
-    value?: T;
-    error?: RemoteError;
-}
-interface NamespaceView {
-    ns: string;
-    value: unknown;
-    base?: unknown;
-    user?: unknown;
-    revision: number;
-}
-interface DescribeValue {
-    writable: boolean;
-    namespaces: readonly NamespaceView[];
-}
-export interface RemoteSettingsFace {
-    describe(): Promise<RemoteResult<DescribeValue>>;
-    mutate(ns: string, ops: readonly unknown[], expectedRevision: number | undefined): Promise<RemoteResult<NamespaceView>>;
-}
-/** Host-backed settings scope used by this plugin on authenticated remote browsers. */
-export declare class RemoteSettingsScope<T> implements SettingsScope<T> {
-    private readonly api;
-    private readonly namespace;
-    private readonly decode;
-    private snapshot;
-    private readonly listeners;
-    constructor(api: RemoteSettingsFace, namespace: string, decode: (value: unknown) => T | undefined);
-    getSnapshot: () => SettingsScopeSnapshot<T>;
-    subscribe: (listener: () => void) => (() => void);
-    reload(): Promise<void>;
-    set(field: string, value: unknown): Promise<void>;
-    unset(field: string): Promise<void>;
-    mutate(ops: readonly SettingsPathOpView[], expectedRevision?: number): Promise<void>;
-    private write;
-    private accept;
-    private publish;
-}
-export {};

package/lib/types/switch-compact.d.ts

@@ -1,72 +0,0 @@
-/** Send-time context check and optional old-model compaction before a switched request. */
-import type { Context } from '@deepseek-ai/cordis';
-import { type UserMessage } from '@deepseek-ai/dsh-llm';
-declare module '@deepseek-ai/dsh-llm' {
-    interface MessageSourceMap {
-        'model-switch': {
-            kind: 'model-switch';
-            form: 'notice';
-            summary: string;
-        };
-    }
-}
-/** Provider and model selected for one model-routed request. */
-export interface SwitchRoute {
-    readonly provider: string;
-    readonly model: string;
-}
-/**
- * Compare two fully specified model routes.
- * @param left - first route, if one was resolved.
- * @param right - second route, if one was resolved.
- * @returns Whether both routes identify the same provider and model.
- */
-export declare function sameSwitchRoute(left: SwitchRoute | undefined, right: SwitchRoute | undefined): boolean;
-/**
- * Decide whether a changed, complete route needs send-time context protection.
- * @param enabled - whether the user enabled send-time protection.
- * @param previous - route used by the preceding request.
- * @param selected - route assembled for the pending request.
- * @returns Whether the pending request changes its provider or model.
- */
-export declare function shouldProtectSwitch(enabled: boolean, previous: SwitchRoute | undefined, selected: SwitchRoute | undefined): boolean;
-/**
- * Input budget for the target window. Reserves output (maxTokens or 20%) plus a
- * fixed estimator margin. `undefined` means the window cannot be used.
- * @param contextWindow - adapter-owned combined request/response capacity.
- * @param maxTokens - optional generation cap from the live agent options.
- * @returns Tokens available to the request input, or undefined for an invalid window.
- */
-export declare function switchInputBudget(contextWindow: number, maxTokens?: number): number | undefined;
-/**
- * Determine whether an estimated input exceeds its target route budget.
- * @param tokens - estimated input tokens.
- * @param budget - input budget for the target window.
- * @returns Whether the budget is unusable or the estimate is too large.
- */
-export declare function overSwitchBudget(tokens: number, budget: number): boolean;
-/**
- * Build one transcript-visible Model Switch progress notice.
- * @param text - localized notice text shown in the transcript.
- * @param summary - bounded event summary for durable session metadata.
- * @returns A plugin-authored user message for the session log.
- */
-export declare function switchNotice(text: string, summary: string): UserMessage;
-/**
- * Extract a complete route from partial request configuration.
- * @param value - candidate provider and model values.
- * @returns A complete route, or undefined when either identifier is absent.
- */
-export declare function routeOf(value: {
-    provider?: string;
-    model?: string;
-} | undefined): SwitchRoute | undefined;
-/**
- * Install send-time switch protection on the host context.
- * @param ctx - host context that owns agent-loop, llm, and tokenMeter.
- * @param settings - live Model Switch settings; `compactOnSwitch !== false` is on.
- * @param roleOf - provider-role lookup used to exclude native Agent runtimes.
- */
-export declare function installSwitchCompaction(ctx: Context, settings: () => {
-    compactOnSwitch?: boolean;
-}, roleOf?: (provider: string) => 'llm' | 'agent' | undefined): void;