dsh-model-switch 0.0.0-stage → 0.4.17

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

@@ -0,0 +1,78 @@
+import { Context, Service } from '@deepseek-ai/cordis';
+import type { ModelSelection } from '@deepseek-ai/dsh-agent';
+import type { AgentDefaultModelConfig } from '@deepseek-ai/dsh-agent-default-model';
+import { type Config as ModelSwitchSettingsConfig, type ModelSwitchSettings } from './host-settings.js';
+import { ModelSwitchAdapterRegistry } from './adapter-registry.js';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        modelSwitch: ModelSwitchRuntime;
+    }
+}
+/** Host owner for Model Switch settings and the released Main-default adapter. */
+export declare class ModelSwitchRuntime extends Service {
+    static inject: string[];
+    static Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+        subagentMode: import("@deepseek-ai/schemastery").default<"follow-main" | "fixed", "follow-main" | "fixed", "volatile-defined">;
+        subagentProvider: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        subagentModel: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        subagentReasoningEffort: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        searchProvider: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        searchModel: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        imageProvider: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        imageModel: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        compactOnSwitch: import("@deepseek-ai/schemastery").default<boolean, boolean, "volatile-defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        subagentMode: import("@deepseek-ai/schemastery").default<"follow-main" | "fixed", "follow-main" | "fixed", "volatile-defined">;
+        subagentProvider: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        subagentModel: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        subagentReasoningEffort: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        searchProvider: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        searchModel: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        imageProvider: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        imageModel: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+        compactOnSwitch: import("@deepseek-ai/schemastery").default<boolean, boolean, "volatile-defined">;
+    }>>, "plain">;
+    get capabilities(): {
+        searchProviderAdapters: {
+            available: boolean;
+            providers: string[];
+            catalog: readonly import("./adapter-registry.js").SearchProviderMetadata[];
+        };
+        mainDefaults: Readonly<{
+            available: true;
+        }>;
+        settings: Readonly<{
+            available: true;
+        }>;
+        centralSubagentRouting: Readonly<{
+            available: true;
+        }>;
+        packagedPresetRoots: Readonly<{
+            available: false;
+            reason: "packaged-preset-roots";
+        }>;
+        toolOwnerSuppression: Readonly<{
+            available: false;
+            reason: "tool-owner-suppression";
+        }>;
+        visionProviderAdapters: Readonly<{
+            available: false;
+            reason: "vision-provider-adapters";
+        }>;
+        imageProviderAdapters: Readonly<{
+            available: true;
+            providers: readonly string[];
+        }>;
+    };
+    readonly adapters: ModelSwitchAdapterRegistry;
+    private source;
+    constructor(ctx: Context, entry: ModelSwitchSettingsConfig);
+    currentSettings(): ModelSwitchSettings;
+    currentMainSelection(): ModelSelection;
+    saveMainSelection(selection: ModelSelection): Promise<void>;
+}
+export interface MainDefaultPort {
+    currentSelection(): ModelSelection;
+    saveSelection(selection: ModelSelection): Promise<void>;
+}
+export declare function mainDefaultPort(service: AgentDefaultModelConfig): MainDefaultPort;

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

@@ -0,0 +1,49 @@
+import type { Volatile } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export type SubagentMode = 'follow-main' | 'fixed';
+/** Resolved live values consumed by Model Switch. */
+export interface ModelSwitchSettings {
+    subagentMode: SubagentMode;
+    subagentProvider?: string;
+    subagentModel?: string;
+    subagentReasoningEffort?: string;
+    searchProvider?: string;
+    searchModel?: string;
+    imageProvider?: string;
+    imageModel?: string;
+    compactOnSwitch: boolean;
+}
+/** Loader-owned references; every field is directly editable in the profile form. */
+export interface Config {
+    subagentMode: Volatile<SubagentMode>;
+    subagentProvider: Volatile<string | undefined>;
+    subagentModel: Volatile<string | undefined>;
+    subagentReasoningEffort: Volatile<string | undefined>;
+    searchProvider: Volatile<string | undefined>;
+    searchModel: Volatile<string | undefined>;
+    imageProvider: Volatile<string | undefined>;
+    imageModel: Volatile<string | undefined>;
+    compactOnSwitch: Volatile<boolean>;
+}
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    subagentMode: z<"follow-main" | "fixed", "follow-main" | "fixed", "volatile-defined">;
+    subagentProvider: z<string, string, "volatile">;
+    subagentModel: z<string, string, "volatile">;
+    subagentReasoningEffort: z<string, string, "volatile">;
+    searchProvider: z<string, string, "volatile">;
+    searchModel: z<string, string, "volatile">;
+    imageProvider: z<string, string, "volatile">;
+    imageModel: z<string, string, "volatile">;
+    compactOnSwitch: z<boolean, boolean, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    subagentMode: z<"follow-main" | "fixed", "follow-main" | "fixed", "volatile-defined">;
+    subagentProvider: z<string, string, "volatile">;
+    subagentModel: z<string, string, "volatile">;
+    subagentReasoningEffort: z<string, string, "volatile">;
+    searchProvider: z<string, string, "volatile">;
+    searchModel: z<string, string, "volatile">;
+    imageProvider: z<string, string, "volatile">;
+    imageModel: z<string, string, "volatile">;
+    compactOnSwitch: z<boolean, boolean, "volatile-defined">;
+}>>, "plain">;
+export declare function readConfig(config: Config): ModelSwitchSettings;

package/lib/types/image-tool.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ModelSwitchAdapterRegistry } from './adapter-registry.js';
+export declare const GENERATE_IMAGE_TOOL_NAME = "generate_image";
+interface ImageSettings {
+    readonly imageProvider?: string;
+    readonly imageModel?: string;
+}
+export interface ImageToolRuntime {
+    currentSettings(): ImageSettings;
+    readonly adapters: ModelSwitchAdapterRegistry;
+}
+export interface ImageToolController {
+    reconcile(): Promise<void>;
+}
+/** Registers one provider-specific schema and replaces it transactionally on Settings changes. */
+export declare function installGenerateImageTool(ctx: Context, runtime: ImageToolRuntime): ImageToolController;
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,7 @@
+export { Config, readConfig, type ModelSwitchSettings } from './host-settings.js';
+export { mainDefaultPort, ModelSwitchRuntime, type MainDefaultPort } from './host-runtime.js';
+export { ModelSwitchAdapterRegistry, type ModelSwitchProviderAdapters, type ModelSwitchSearchAdapter, type ModelSwitchImageAdapter, type ModelSwitchImageRequest, type ModelSwitchGeneratedImage } from './adapter-registry.js';
+export { RUNTIME_CAPABILITIES, type RuntimeCapabilities, type RuntimeCapability } from './runtime-capabilities.js';
+export { parsePickerId, groupFamilies, planReviewOf, selectPlanReview, approvePlanReview, } from './picker/public.ts';
+export declare const name = "dsh-model-switch";
+export { ModelSwitchRuntime as default } from './host-runtime.js';

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

@@ -0,0 +1,9 @@
+import { type CapabilityCatalog, type ModelSelection } from './capabilities.js';
+export interface MainSettingsDocument {
+    version: 1;
+    defaultRoute: ModelSelection;
+}
+/** Decode storage without resolving availability, so invalid/uninstalled choices remain visible. */
+export declare function parseMainSettingsDocument(input: unknown): MainSettingsDocument;
+/** Validate only when a caller creates a new session; existing sessions never re-read this document. */
+export declare function routeForNewSession(catalog: CapabilityCatalog, settings: MainSettingsDocument): ModelSelection;

package/lib/types/picker/family.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Suffix grammar for composer picker grouping. Provider plugins own the wire
+ * peel; this module only reads catalog ids.
+ */
+/** Trailing Fast row. */
+export declare const FAST_SUFFIX = "-fast";
+/** Parsed picker id after stripping Fast and a numeric context tier. */
+export interface ParsedPickerId {
+    /** Family key after peeling Fast and `-<n>k` / `-<n>m`. */
+    base: string;
+    /** Whether this row is the Fast sibling. */
+    fast: boolean;
+    /** Context suffix without the leading dash, or null for the standard row. */
+    contextTier: string | null;
+    /** Compaction budget implied by the suffix. */
+    contextTokens?: number;
+}
+/** One catalog model as the Host directory projects it. */
+export interface CatalogModelView {
+    id: string;
+    name: string;
+    description?: string;
+    reasoning?: {
+        defaultEffort?: string;
+        efforts: readonly {
+            id: string;
+            name: string;
+            description?: string;
+        }[];
+    };
+}
+/** One provider group from the Host directory. */
+export interface CatalogGroupView {
+    id: string;
+    name: string;
+    models: readonly CatalogModelView[];
+}
+/** One catalog row inside a suffix family. */
+export interface FamilyMember {
+    model: CatalogModelView;
+    fast: boolean;
+    contextTier: string | null;
+    contextTokens?: number;
+    thinking: boolean;
+}
+/** Same-base rows across Fast / context / thinking siblings. */
+export interface ModelFamily {
+    provider: string;
+    providerName: string;
+    base: string;
+    name: string;
+    members: FamilyMember[];
+}
+/** Peel Fast and `-<n>k` / `-<n>m` in either order. Product names like `-max` stay. */
+export declare function parsePickerId(id: string): ParsedPickerId;
+/** Catalog id for a standard-row window that the Host did not publish. UI localizes this. */
+export declare const STANDARD_CONTEXT_LABEL = "standard";
+/** Human label for a context tier: 1M, 272K, or STANDARD_CONTEXT_LABEL when its window is unknown. */
+export declare function contextTierLabel(tier: string | null, tokens?: number): string;
+/** Compact token window for trigger / context-cell copy. */
+export declare function formatWindow(tokens: number): string;
+/** Standard-row window when the Host directory omits contextWindow. */
+export declare function impliedStandardTokens(base: string): number | undefined;
+/** Label a selected variant from catalog identity, never from stale session pressure. */
+export declare function contextLabelForMember(family: ModelFamily, member: FamilyMember): string;
+/** Group directory rows by provider + peeled base. */
+export declare function groupFamilies(groups: readonly CatalogGroupView[]): ModelFamily[];
+/** Locate the family that owns a provider/model pair. */
+export declare function findFamily(families: readonly ModelFamily[], provider: string, modelId: string): ModelFamily | undefined;
+/** Locate one family member by catalog id. */
+export declare function findMember(family: ModelFamily, modelId: string): FamilyMember | undefined;
+export interface VariantPatch {
+    fast?: boolean;
+    contextTier?: string | null;
+    thinking?: boolean;
+}
+/** Pick a sibling after toggling Fast / context / thinking, keeping the other axes. */
+export declare function pickVariant(family: ModelFamily, current: FamilyMember, patch: VariantPatch): FamilyMember;
+/** Fast row appears only when both a Fast and a non-Fast sibling exist. */
+export declare function familyHasFast(family: ModelFamily): boolean;
+/** Provider sections in catalog order, for the model pane. */
+export declare function sectionFamilies(families: readonly ModelFamily[]): Array<{
+    provider: string;
+    providerName: string;
+    families: ModelFamily[];
+}>;
+/** Unique context tiers in catalog order. */
+export declare function contextTiers(family: ModelFamily, standardTokens?: number): Array<{
+    tier: string | null;
+    label: string;
+    tokens?: number;
+}>;
+/** Context row appears only when the family has more than one tier. */
+export declare function familyHasContextChoices(family: ModelFamily): boolean;
+/** Thinking on/off siblings at the current Fast + context axes, or null. */
+export declare function thinkingSiblings(family: ModelFamily, current: FamilyMember): {
+    on: FamilyMember;
+    off: FamilyMember;
+} | null;
+/** Case-insensitive local search over family name, base, and provider. */
+export declare function filterFamilies(families: readonly ModelFamily[], query: string): ModelFamily[];
+export interface ModelSelectionView {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+/** Build a Host selection from a member, preserving or defaulting effort. */
+export declare function selectionOf(family: ModelFamily, member: FamilyMember, reasoningEffort?: string): ModelSelectionView;

package/lib/types/picker/pending-dismissal.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Dismissal seam for one pending question card.
+ *
+ * The published `PendingQuestion` renamed its "user closed this card" verb:
+ * the 0.1.x generation rejected the Host waterfall through `cancel()`
+ * (documented as *Reject the Host waterfall because the user closed the
+ * question*), while the 0.2.x generation splits hiding from cancelling and
+ * exposes only `dismiss()`. Both mean the same product action here — the user
+ * takes the turn back to speak — because plan mode maps `ASK_CANCELLED` to
+ * "the user dismissed the plan review to speak instead; stay in plan mode,
+ * stop here, and wait for their message".
+ *
+ * Probe the method instead of the version: a Host may ship either generation,
+ * and neither seam means the takeover must fail loudly rather than answer.
+ */
+export type PendingDismissal = 'dismiss' | 'cancel';
+/** The card surface this module needs; every generation satisfies a subset. */
+export interface PendingDismissible {
+    /** 0.2.x: withdraw the card (and end an unnamed request); request stays live for a named card. */
+    dismiss?: () => Promise<void>;
+    /** 0.1.x: reject the Host waterfall so the user can speak instead. */
+    cancel?: () => Promise<void>;
+}
+/** Raised when the running Host exposes neither withdrawal verb. */
+export declare class PlanDismissalUnsupportedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Withdraw a pending card so the human can talk instead, on either generation.
+ * @param wait - the matched pending question carrier.
+ * @returns Which verb withdrew the card.
+ * @throws {PlanDismissalUnsupportedError} when the carrier exposes neither verb.
+ */
+export declare function dismissPendingQuestion(wait: PendingDismissible): Promise<PendingDismissal>;

package/lib/types/picker/plan-review.d.ts

@@ -0,0 +1,57 @@
+import type { ModelSelection } from '@deepseek-ai/dsh-api-session-controller/types';
+import type { ComposerChainProps } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import type { PendingQuestion, PlanReview } from '@deepseek-ai/dsh-client-ui-user-questions/client';
+export type { PlanReview } from '@deepseek-ai/dsh-client-ui-user-questions/client';
+export type PlanReviewOption = PlanReview['approve'];
+type QuestionItem = PendingQuestion['questions'][number];
+export declare function planReviewOf(questions: readonly QuestionItem[]): PlanReview | undefined;
+export declare function selectPlanReview(owner: ComposerChainProps): PendingQuestion | null;
+export declare class PlanApprovalResponseError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Result of committing the draft execution model before answering a review.
+ *
+ * A commit and the compensation of the Host's own deployment-default write are
+ * separate facts: only a failed commit may hold the answer back, because the
+ * Host persists a Session selection as the deployment default on several
+ * releases and this plugin restores the captured Main default afterwards. A
+ * failed restore is announced, never fatal — the Session selection the human
+ * asked for is already installed.
+ */
+export interface PlanCommitOutcome {
+    /** The Session now runs the requested provider/model/effort. */
+    committed: boolean;
+    /** The captured Main default is the effective one again. */
+    mainDefaultRestored: boolean;
+}
+/**
+ * Diagnostic text for one failed action, keeping the wire code visible.
+ * Official Remote failures carry a code that names the owning domain
+ * (`session/writer-held`, `session/model-unavailable`, …); dropping it leaves
+ * the human with copy they cannot act on.
+ * @param cause - the thrown value.
+ * @returns The message, prefixed with the nearest available code.
+ */
+export declare function planErrorText(cause: unknown): string;
+export declare function approvePlanReview(args: {
+    select: (selection: ModelSelection) => Promise<PlanCommitOutcome>;
+    selection: ModelSelection;
+    current?: ModelSelection | null;
+    answer: () => Promise<void>;
+    /** Announced after a successful answer when the Main default could not be restored. */
+    onNotRestored?: (notice: string) => void;
+}): Promise<boolean>;
+export interface PlanActionState {
+    busy: boolean;
+    blocked: boolean;
+    error: string | null;
+}
+export interface PlanActionView {
+    approveDisabled: boolean;
+    error: string | null;
+}
+export declare function planActionView(state: PlanActionState, available: boolean, hasExecution: boolean): PlanActionView;
+export declare function settlePlanAction(send: () => Promise<void>, update: (state: PlanActionState) => void): Promise<boolean>;

package/lib/types/picker/public.d.ts

@@ -0,0 +1,5 @@
+/** Host-facing re-exports for tests and typed consumers. */
+export { parsePickerId, groupFamilies, findFamily, pickVariant, familyHasFast, familyHasContextChoices, thinkingSiblings, filterFamilies, selectionOf, contextTierLabel, formatWindow, } from './family.ts';
+export type { ParsedPickerId, CatalogGroupView, CatalogModelView, FamilyMember, ModelFamily, ModelSelectionView, } from './family.ts';
+export { planReviewOf, selectPlanReview, approvePlanReview } from './plan-review.ts';
+export type { PlanReview, PlanReviewOption } from './plan-review.ts';

package/lib/types/picker/selection-feedback.d.ts

@@ -0,0 +1,2 @@
+/** Immediate picker feedback around an asynchronous Host model selection. */
+export declare function beginSelection<T>(select: () => Promise<T>, showFeedback: () => void, settle: (outcome: T) => void): Promise<void>;

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

@@ -0,0 +1,50 @@
+export type RuntimeCapabilityReason = 'central-subagent-routing' | 'packaged-preset-roots' | 'tool-owner-suppression' | 'search-provider-adapters' | 'vision-provider-adapters' | 'image-provider-adapters';
+import type { SearchProviderMetadata } from './adapter-registry.js';
+export interface RuntimeCapability {
+    readonly available: boolean;
+    readonly reason?: RuntimeCapabilityReason;
+    readonly providers?: readonly string[];
+    readonly catalog?: readonly SearchProviderMetadata[];
+}
+export interface RuntimeCapabilities {
+    readonly mainDefaults: RuntimeCapability;
+    readonly settings: RuntimeCapability;
+    readonly centralSubagentRouting: RuntimeCapability;
+    readonly packagedPresetRoots: RuntimeCapability;
+    readonly toolOwnerSuppression: RuntimeCapability;
+    readonly searchProviderAdapters: RuntimeCapability;
+    readonly visionProviderAdapters: RuntimeCapability;
+    readonly imageProviderAdapters: RuntimeCapability;
+}
+export declare const RUNTIME_CAPABILITIES: Readonly<{
+    mainDefaults: Readonly<{
+        available: true;
+    }>;
+    settings: Readonly<{
+        available: true;
+    }>;
+    centralSubagentRouting: Readonly<{
+        available: true;
+    }>;
+    packagedPresetRoots: Readonly<{
+        available: false;
+        reason: "packaged-preset-roots";
+    }>;
+    toolOwnerSuppression: Readonly<{
+        available: false;
+        reason: "tool-owner-suppression";
+    }>;
+    searchProviderAdapters: Readonly<{
+        available: false;
+        reason: "search-provider-adapters";
+        providers: readonly never[];
+    }>;
+    visionProviderAdapters: Readonly<{
+        available: false;
+        reason: "vision-provider-adapters";
+    }>;
+    imageProviderAdapters: Readonly<{
+        available: true;
+        providers: readonly string[];
+    }>;
+}>;

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

@@ -0,0 +1,23 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { WebSearchProvider, WebSearchRequest, WebSearchResult } from '@deepseek-ai/dsh-web';
+import type { ModelSwitchAdapterRegistry } from './adapter-registry.js';
+export declare const MODEL_SWITCH_SEARCH_PROVIDER_ID = "model-switch";
+interface SearchSettings {
+    readonly searchProvider?: string;
+    readonly searchModel?: string;
+}
+/** Thin official WebSearchProvider that resolves Model Switch routing at execution time. */
+export declare class ModelSwitchSearchProvider implements WebSearchProvider {
+    private readonly settings;
+    private readonly adapters;
+    readonly id = "model-switch";
+    constructor(settings: () => SearchSettings, adapters: ModelSwitchAdapterRegistry);
+    available(): boolean;
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+export interface SearchProviderRuntime {
+    currentSettings(): SearchSettings;
+    readonly adapters: ModelSwitchAdapterRegistry;
+}
+export declare function installModelSwitchSearchProvider(ctx: Context, runtime: SearchProviderRuntime): void;
+export {};

package/lib/types/subagent-route-policy.d.ts

@@ -0,0 +1,26 @@
+import { type CapabilityCatalog, type ModelSelection, type ReasoningEffortId } from './capabilities.js';
+export type SubagentRoutePolicy = {
+    mode: 'follow-main';
+} | {
+    mode: 'fixed';
+    route: ModelSelection;
+};
+export interface WorkflowRouteOverride {
+    provider: string;
+    model: string;
+    effort?: ReasoningEffortId;
+}
+export type SubagentRouteSnapshot = {
+    version: 1;
+    source: 'fixed-policy' | 'workflow-override';
+    selection: ModelSelection;
+} | {
+    version: 1;
+    source: 'official-inherit';
+};
+export interface CreateSubagentRouteInput {
+    policy: SubagentRoutePolicy;
+    workflowOverride?: WorkflowRouteOverride;
+}
+export declare function createSubagentRouteSnapshot(catalog: CapabilityCatalog, input: CreateSubagentRouteInput): SubagentRouteSnapshot;
+export declare function restoreSubagentRouteSnapshot(catalog: CapabilityCatalog, input: unknown): SubagentRouteSnapshot;

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

@@ -0,0 +1,51 @@
+import { Context } from '@deepseek-ai/cordis';
+import OfficialSubagentRuntime, { type ContinuableStart, type ContinuableStartSpec, type SubagentRun, type SubagentStartRequest } from '@deepseek-ai/dsh-subagent';
+import type { ModelSwitchSettings } from './host-settings.js';
+/** Raised only when an explicit startup check finds an unsupported public surface. */
+export declare class StartupIncompatibilityError extends Error {
+    readonly name = "StartupIncompatibilityError";
+    readonly surface: string;
+    /**
+     * @param surfaceOrMessage - the incompatible public surface, or the error message.
+     * @param message - the missing or incompatible requirement.
+     */
+    constructor(surfaceOrMessage: string, message?: string);
+}
+/** One idempotent cleanup operation tracked during runtime startup. */
+export type StartupDisposer = () => void | PromiseLike<void>;
+/** Register one cleanup operation for a startup attempt. */
+export type StartupCleanupTracker = (dispose: StartupDisposer) => void;
+/** A successfully mounted runtime and its idempotent cleanup operation. */
+export interface MountedStartup<T> {
+    readonly value: T;
+    readonly dispose: () => Promise<void>;
+}
+type RoutableSubagentRequest = Pick<SubagentStartRequest, 'parent' | 'agentOptions'>;
+/** Inject a fixed Default Subagent route, or leave the request for Official inherit. */
+export declare function routeSubagentRequest<T extends RoutableSubagentRequest>(request: T, settings: ModelSwitchSettings): T;
+/**
+ * Mount a candidate and use the fallback only for typed startup incompatibility.
+ *
+ * Every resource registered by an attempt is disposed in reverse order before a
+ * fallback starts and again when the mounted result is disposed. Cleanup keeps
+ * running after failures, and a startup error stays first in any aggregate.
+ *
+ * @param candidate - startup callback for the routed candidate.
+ * @param fallback - startup callback for the untouched official runtime.
+ * @returns the selected value and an idempotent disposer.
+ * @throws the candidate error unless it is a StartupIncompatibilityError.
+ * @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>>;
+/** Profile replacement that selects the routed runtime or the untouched official runtime. */
+export declare const profileSubagentRuntime: ((ctx: Context) => Promise<() => Promise<void>>) & {
+    inject: string[];
+};
+/** Official runtime with only a pre-descriptor route-selection adapter. */
+export declare class ModelSwitchSubagentRuntime extends OfficialSubagentRuntime {
+    static inject: string[];
+    private routed;
+    start(name: string, request: SubagentStartRequest): Promise<SubagentRun>;
+    startContinuable(spec: ContinuableStartSpec): Promise<ContinuableStart>;
+}
+export default profileSubagentRuntime;

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

@@ -0,0 +1,72 @@
+/** 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;