dsh-model-switch 0.4.24 → 0.4.25

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-model-switch",
-  "version": "0.4.24",
+  "version": "0.4.25",
   "description": "Explicit model routing plus composer/Plan picker for DeepSeek Harness",
   "repository": {
     "type": "git",

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;