dsh-model-switch 0.0.0-stage → 0.4.18

package/lib/types/client/picker/PlanReviewCard.d.ts

@@ -0,0 +1,37 @@
+import type { PendingQuestion } from '@deepseek-ai/dsh-client-ui-user-questions/client';
+import type { ConfigFormSnapshot } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { MainSettingsView } from '../../client-contract.ts';
+import { type PickerDirectoryFace } from './PickerDirectory.ts';
+import type { PickerInteractionOperations } from './popup-dismissal.ts';
+import { type RuntimeProviderLock } from '../runtime-lock.ts';
+export interface PlanReviewFace extends PickerDirectoryFace {
+    available: boolean;
+    resolveInteractionOperations?: () => PickerInteractionOperations | undefined;
+    /** Resolve a provider key to its ProviderDirectory role for runtime icons. */
+    roleOf?: (providerKey: string) => string | undefined;
+    /** Shared native-binding lock state for the seat session. */
+    providerLockStore: {
+        subscribe: (listener: () => void) => () => void;
+        getSnapshot: () => {
+            provider: RuntimeProviderLock;
+            failed: boolean;
+        };
+    };
+    /** Re-read the native binding now (mount, turn transitions, pre-selection). */
+    refreshProviderLock: () => void;
+    subscribeMainDefaults: (listener: () => void) => () => void;
+    getMainDefaultsSnapshot: () => ConfigFormSnapshot<MainSettingsView>;
+    /** Live catalog-group-id → card-key map from ProviderDirectory. */
+    catalogRoutes?: () => Readonly<Record<string, string>>;
+}
+export type PlanReviewCardProps = PropsRuntime<'conversation.composer'> & PropsLocale<'composer-picker'> & InjectFace<PlanReviewFace> & {
+    matched: PendingQuestion;
+};
+/** Match the model seat's admission guard before letting either picker offer a change. */
+export declare function mainDefaultsUnavailableReason(snapshot: ConfigFormSnapshot<MainSettingsView>, t: PlanReviewCardProps['t']): string | undefined;
+/** Inline failed lock-read status; history and log reading stay unaffected. */
+export declare function ProviderLockHint(props: {
+    t: PlanReviewCardProps['t'];
+}): import("react").JSX.Element;
+export declare function PlanReviewCard(props: PlanReviewCardProps): import("react").JSX.Element;

package/lib/types/client/picker/RetryBoundary.d.ts

@@ -0,0 +1,20 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+interface RetryBoundaryProps {
+    children: ReactNode;
+    logLabel: string;
+    renderFallback: (message: string, retry: () => void) => ReactNode;
+}
+/** Own retryable React error-boundary state while callers own presentation and copy. */
+export declare class RetryBoundary extends Component<RetryBoundaryProps, {
+    message: string | null;
+}> {
+    state: {
+        message: null;
+    };
+    static getDerivedStateFromError(error: unknown): {
+        message: string;
+    };
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

package/lib/types/client/picker/external-catalog.d.ts

@@ -0,0 +1,14 @@
+import type { ModelSelection } from '@deepseek-ai/dsh-api-session-controller/types';
+import type { PickerDirectorySnapshot, PickerDirectoryStore } from './PickerDirectory.ts';
+type CatalogGroup = PickerDirectorySnapshot['groups'][number];
+/** Overlay groups from External Agent catalog onto the LLM session.models snapshot. */
+export declare function mergePickerGroups(base: readonly CatalogGroup[], extra: readonly CatalogGroup[]): CatalogGroup[];
+export declare function overlayPickerSnapshot(base: PickerDirectorySnapshot, extra: readonly CatalogGroup[], current: ModelSelection | null): PickerDirectorySnapshot;
+/** Subscribe-able overlay that hides unready External Agent groups by simply omitting them. */
+export declare function createExternalCatalogStore(base: PickerDirectoryStore): {
+    store: PickerDirectoryStore;
+    setExtra(groups: readonly CatalogGroup[]): void;
+    setCurrent(current: ModelSelection | null): void;
+    extraIds(): ReadonlySet<string>;
+};
+export {};

package/lib/types/client/picker/install.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Composer model seat + Plan Review execution picker.
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { ProviderOrderSettings } from 'dsh-llm-providers-ui/order';
+import { type PickerKey } from './locales.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        'composer-picker': PickerKey;
+    }
+}
+/**
+ * Bind the optional Providers entry order as a React external store.
+ * @returns A subscribable order snapshot with an invalidation hook for directory changes.
+ */
+export declare function providerOrderStore(form: ConfigForm<ProviderOrderSettings>): {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => readonly string[];
+    invalidate: () => void;
+};
+/** Register composer model picker and Plan Review execution picker. */
+export declare function installComposerPicker(ctx: ClientContext): void;

package/lib/types/client/picker/locales.d.ts

@@ -0,0 +1,104 @@
+/** `composer-picker` namespace dictionaries. */
+export declare const zh: {
+    'trigger.fallback': string;
+    'trigger.selectAria': string;
+    'trigger.aria': string;
+    'trigger.ariaEffort': string;
+    'menu.aria': string;
+    'menu.back': string;
+    'menu.closeSearch': string;
+    'menu.model': string;
+    'menu.effort': string;
+    'menu.context': string;
+    'menu.fast': string;
+    'menu.thinking': string;
+    'menu.search': string;
+    'context.standard': string;
+    'fast.on': string;
+    'fast.off': string;
+    'thinking.on': string;
+    'thinking.off': string;
+    'effort.providerDefault': string;
+    'status.loading': string;
+    'settings.remoteUnavailable': string;
+    'settings.loading': string;
+    'settings.unavailable': string;
+    'error.action': string;
+    'error.picker': string;
+    'action.reload': string;
+    retry: string;
+    'warning.groupLoad': string;
+    'empty.models': string;
+    'empty.efforts': string;
+    'lock.readFailed': string;
+    'choice.unavailable': string;
+    'plan.kicker': string;
+    'plan.header': string;
+    'plan.execution': string;
+    'plan.approve': string;
+    'plan.keep': string;
+    'plan.discuss': string;
+    'plan.modelFailed': string;
+    'plan.pickerCrash': string;
+    'plan.feedback': string;
+    'plan.feedbackPlaceholder': string;
+    'plan.notRestored': string;
+    'plan.dismissUnsupported': string;
+    'plan.responseRejected': string;
+    'plan.cancelRejected': string;
+    'markdown.copy': string;
+    'markdown.copied': string;
+    'markdown.footnotes': string;
+};
+export type PickerKey = keyof typeof zh;
+export declare const en: {
+    'trigger.fallback': string;
+    'trigger.selectAria': string;
+    'trigger.aria': string;
+    'trigger.ariaEffort': string;
+    'menu.aria': string;
+    'menu.back': string;
+    'menu.closeSearch': string;
+    'menu.model': string;
+    'menu.effort': string;
+    'menu.context': string;
+    'menu.fast': string;
+    'menu.thinking': string;
+    'menu.search': string;
+    'context.standard': string;
+    'fast.on': string;
+    'fast.off': string;
+    'thinking.on': string;
+    'thinking.off': string;
+    'effort.providerDefault': string;
+    'status.loading': string;
+    'settings.remoteUnavailable': string;
+    'settings.loading': string;
+    'settings.unavailable': string;
+    'error.action': string;
+    'error.picker': string;
+    'action.reload': string;
+    retry: string;
+    'warning.groupLoad': string;
+    'empty.models': string;
+    'empty.efforts': string;
+    'lock.readFailed': string;
+    'choice.unavailable': string;
+    'plan.kicker': string;
+    'plan.header': string;
+    'plan.execution': string;
+    'plan.approve': string;
+    'plan.keep': string;
+    'plan.discuss': string;
+    'plan.modelFailed': string;
+    'plan.pickerCrash': string;
+    'plan.feedback': string;
+    'plan.feedbackPlaceholder': string;
+    'plan.notRestored': string;
+    'plan.dismissUnsupported': string;
+    'plan.responseRejected': string;
+    'plan.cancelRejected': string;
+    'markdown.copy': string;
+    'markdown.copied': string;
+    'markdown.footnotes': string;
+};

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

@@ -0,0 +1,56 @@
+/**
+ * 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/popup-dismissal.d.ts

@@ -0,0 +1,22 @@
+/** Dismissal contract shared by the portaled picker and mobile Back routing. */
+export interface PickerInteractionSource {
+    kind: 'touch' | 'keyboard' | 'platform' | 'spatial' | 'programmatic';
+    detail?: string;
+}
+export interface PickerInteractionOperations {
+    registerSurface(surface: {
+        readonly id: string;
+        readonly kind: 'popup';
+        dismiss(source: PickerInteractionSource): void;
+    }): () => void;
+}
+export interface PickerDismissalOptions {
+    documentTarget: Document;
+    surfaceId: string;
+    interaction?: PickerInteractionOperations;
+    trigger: () => HTMLElement | null;
+    popup: () => HTMLElement | null;
+    dismiss: () => void;
+}
+/** Install capture-phase outside-pointer dismissal and optional mobile Back registration. */
+export declare function installPickerDismissal({ documentTarget, surfaceId, interaction, trigger, popup, dismiss, }: PickerDismissalOptions): () => void;

package/lib/types/client/picker/useComposerPickerSurface.d.ts

@@ -0,0 +1,25 @@
+import { type CSSProperties, type MouseEvent as ReactMouseEvent, type PointerEvent as ReactPointerEvent, type RefObject } from 'react';
+import { type PickerInteractionOperations } from './popup-dismissal.ts';
+export interface ComposerPickerSurfaceOptions {
+    locked: boolean;
+    embedded: boolean;
+    tone?: 'capsule';
+    pane: string;
+    reload: () => void;
+    onOpen: () => void;
+    onClose: () => void;
+    resolveInteractionOperations?: () => PickerInteractionOperations | undefined;
+}
+export interface ComposerPickerSurface {
+    id: string;
+    open: boolean;
+    menuStyle: CSSProperties;
+    triggerRef: RefObject<HTMLButtonElement>;
+    menuRef: RefObject<HTMLDivElement>;
+    show: () => void;
+    close: (restoreFocus?: boolean) => void;
+    onTriggerPointerDown: (event: ReactPointerEvent<HTMLButtonElement>) => void;
+    onTriggerClick: (event?: ReactMouseEvent<HTMLButtonElement>) => void;
+}
+/** Own popup activation, positioning, and dismissal behind one internal seam. */
+export declare function useComposerPickerSurface(options: ComposerPickerSurfaceOptions): ComposerPickerSurface;

package/lib/types/client/plugin-rpc.d.ts

@@ -0,0 +1,10 @@
+export interface PluginRpcClient {
+    call(channel: string, endpoint: string, payload: unknown, signal?: AbortSignal): Promise<{
+        ok: boolean;
+        value?: unknown;
+    }>;
+}
+export declare function callPluginRpc(rpc: PluginRpcClient, method: string, endpoint: string, payload: unknown, signal?: AbortSignal): Promise<{
+    ok: boolean;
+    value?: unknown;
+}>;

package/lib/types/client/provider-directory.d.ts

@@ -0,0 +1,23 @@
+/** Optional ProviderDirectory operations consumed by Model Switch. */
+import type { NativeBindingSource } from './runtime-lock.ts';
+/** Provider-directory operations that may be supplied by the Providers UI plugin. */
+export interface ProviderDirectoryFace {
+    subscribe(listener: () => void): () => void;
+    roleOf?(key: string): string | undefined;
+    catalogRoutes?(): Readonly<Record<string, string>>;
+    nativeBindings?(): readonly NativeBindingSource[];
+}
+/** Read the optional catalog route map without assuming a particular Providers UI release. */
+export declare function readCatalogRoutes(directory: ProviderDirectoryFace | undefined): Readonly<Record<string, string>>;
+/** Read the optional native-binding declarations without assuming a particular Providers UI release. */
+export declare function readNativeBindings(directory: ProviderDirectoryFace | undefined): readonly NativeBindingSource[];
+/**
+ * Rank picker/catalog groups from live ProviderDirectory routes.
+ * Published 0.2.8 `sortCatalogGroups` only understands hardcoded LLM routes and
+ * ignores a third argument, so Agent catalog ids would keep source order.
+ * When the Owner publishes `catalogRoutes`, this ranks those keys locally.
+ * With no live map, fall back to the compile-pinned 0.2.8 LLM-only sort.
+ */
+export declare function sortCatalogGroupsWithRoutes<T extends {
+    id: string;
+}>(groups: readonly T[], saved?: readonly string[], catalogKeys?: Readonly<Record<string, string>>): T[];

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

@@ -0,0 +1,45 @@
+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/client/runtime-lock.d.ts

@@ -0,0 +1,68 @@
+import { type PluginRpcClient } from './plugin-rpc.ts';
+/** Session execution-runtime lock from native binding and request activity. */
+/** Native binding query declared by an installed Agent provider. */
+export interface NativeBindingSource {
+    readonly provider: string;
+    readonly channel: string;
+    readonly endpoint: string;
+}
+export type RuntimeProviderLock = string | null;
+/** A known binding remains authoritative even if another query fails. */
+export interface ProviderLockState {
+    readonly provider: RuntimeProviderLock;
+    readonly failed: boolean;
+}
+/** Decode a wire reply only for the provider that owns the query. */
+export declare function decodeBindingProvider(value: unknown, provider: string): RuntimeProviderLock | undefined;
+/** Query installed declarations; one failed query must never become a successful unbound read. */
+export declare function fetchSessionBinding(rpc: PluginRpcClient | undefined, sessionId: string, sources: readonly NativeBindingSource[]): Promise<ProviderLockState>;
+/** Whether one provider remains selectable under a known lock read. */
+export declare function providerSelectable(lock: RuntimeProviderLock, provider: string): boolean;
+/** Extra facts for Agent-role selection on blank vs existing DSH sessions. */
+export interface ProviderAllowContext {
+    /** Empty-log bit from the conversation snapshot; omit when unknown. */
+    blank?: boolean;
+    /** A prompt is being submitted, awaits its first turn, or is running. */
+    active?: boolean;
+    /** Whether the candidate provider is an Agent-role External Agent. */
+    agent?: boolean;
+    /** Whether the current selection is an Agent provider, from its declaration. */
+    currentAgent?: boolean;
+}
+/**
+ * Existing DSH history cannot convert to an External Agent. Blank sessions
+ * and already-bound native sessions keep their current Agent choice.
+ */
+export declare function agentProviderLocked(blank: boolean, bound: RuntimeProviderLock, active?: boolean): boolean;
+/** Picker allow-check over the already-effective lock and the agentLocked bit. */
+export declare function runtimeChoiceAllowed(lock: RuntimeProviderLock, agentLocked: boolean, provider: string, currentProvider: string | undefined, agent: boolean): boolean;
+/**
+ * Whether one provider remains selectable under a lock read that may have failed.
+ * Failed reads keep only the known binding or current selection selectable;
+ * active Agent selections reserve their runtime before the first binding arrives.
+ * Unbound sessions with DSH history cannot select a new Agent provider.
+ * Log reading is never gated by this.
+ * @param state - Latest lock read for the session.
+ * @param provider - Candidate provider for the pending selection.
+ * @param currentProvider - Session current provider, if any.
+ * @param context - Session history, request activity, and candidate Agent role.
+ */
+export declare function isProviderAllowed(state: ProviderLockState, provider: string, currentProvider: string | undefined, context?: ProviderAllowContext): boolean;
+/**
+ * Effective single-provider lock for pickers that only understand
+ * RuntimeProviderLock. Errors fail closed exactly as isProviderAllowed does.
+ */
+export declare function effectiveProviderLock(state: ProviderLockState, currentProvider: string | undefined, active?: boolean, currentAgent?: boolean): RuntimeProviderLock;
+/** Minimal shared lock state: one snapshot per session, refreshed on demand. */
+export interface ProviderLockStore {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ProviderLockState;
+    /** Re-read; concurrent reads resolve in call order, stale ones are dropped. */
+    refresh: () => Promise<ProviderLockState>;
+}
+/**
+ * Create one session lock store over an injecting query.
+ * The query sees the previous snapshot for sticky failure mapping and never
+ * throws (failures resolve to failed reads); refresh never rejects.
+ */
+export declare function createProviderLockStore(query: (previous: ProviderLockState) => Promise<ProviderLockState>): ProviderLockStore;

package/lib/types/client/search-capabilities.d.ts

@@ -0,0 +1,21 @@
+/** Host-owned search capability metadata, decoded at the Connection trust seam. */
+import type { ModelProviderGroup } from '@deepseek-ai/dsh-api-session-controller/types';
+import type { SearchProviderMetadata } from '../adapter-registry.js';
+import type { CapabilitiesSnapshot } from '../capabilities-rpc.js';
+import type { RuntimeCapabilities } from '../runtime-capabilities.js';
+export type { CapabilitiesSnapshot };
+/**
+ * Strictly decode the Host search catalog into fresh plain metadata. Any malformed
+ * entry fails the whole catalog (undefined): when the Host claims search is
+ * available, invalid config must surface as an error, never hide as dropped rows.
+ * Extra fields (functions, credentials) never survive: only id/name copy over.
+ */
+export declare function decodeSearchCatalog(value: unknown): SearchProviderMetadata[] | undefined;
+/**
+ * Strictly decode one capabilities long-poll value; undefined when untrusted.
+ * Only the decoded search block is taken from the network and overlaid onto the
+ * frozen local defaults: no arbitrary Host fields pass through.
+ */
+export declare function decodeCapabilitiesSnapshot(value: unknown): CapabilitiesSnapshot | undefined;
+/** Project already-validated Host search metadata onto group shape (no re-decode). */
+export declare function searchGroupsFromCapabilities(capabilities: RuntimeCapabilities | undefined): ModelProviderGroup[];

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

@@ -0,0 +1,51 @@
+export declare const MODEL_SWITCH_CONFIG_ID = "model-switch";
+export declare const MAIN_DEFAULT_CONFIG_ID = "agent-default-model";
+export declare const PROVIDERS_CONFIG_ID = "llm-providers-ui";
+export interface MainSettingsView {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+export declare class MainSettingsConflictError extends Error {
+    readonly name = "MainSettingsConflictError";
+}
+export interface ModelSwitchSettingsView {
+    subagentMode: 'follow-main' | 'fixed';
+    subagentProvider?: string;
+    subagentModel?: string;
+    subagentReasoningEffort?: string;
+    searchProvider?: string;
+    searchModel?: string;
+    imageProvider?: string;
+    imageModel?: string;
+    compactOnSwitch?: boolean;
+}
+export interface SubagentSettingsView {
+    mode: 'follow-main' | 'fixed';
+    provider?: string;
+    model?: string;
+    reasoningEffort?: string;
+}
+export interface CapabilityRouteView {
+    provider?: string;
+    model?: string;
+}
+export declare const SUBAGENT_SETTINGS_FIELDS: Readonly<{
+    readonly mode: "subagentMode";
+    readonly provider: "subagentProvider";
+    readonly model: "subagentModel";
+    readonly reasoningEffort: "subagentReasoningEffort";
+}>;
+/** Instant Subagent header toggle. Off keeps the stored `follow-main` unset token. */
+export declare function subagentModeForEnabled(enabled: boolean): SubagentSettingsView['mode'];
+export declare const SEARCH_SETTINGS_FIELDS: Readonly<{
+    readonly provider: "searchProvider";
+    readonly model: "searchModel";
+}>;
+export declare const IMAGE_SETTINGS_FIELDS: Readonly<{
+    readonly provider: "imageProvider";
+    readonly model: "imageModel";
+}>;
+export declare function deriveSubagentSettings(settings: ModelSwitchSettingsView): SubagentSettingsView;
+export declare function deriveSearchSettings(settings: ModelSwitchSettingsView): CapabilityRouteView;
+export declare function deriveImageSettings(settings: ModelSwitchSettingsView): CapabilityRouteView;

package/lib/types/compatibility.d.ts

@@ -0,0 +1,38 @@
+interface CompatibilityLogger {
+    warn(message: string): void;
+}
+export type DshRuntimeClassification = {
+    kind: 'verified';
+} | {
+    kind: 'unverified';
+} | {
+    kind: 'blocked';
+    reason: string;
+};
+/**
+ * Classify one runtime without treating the verified table as an allowlist.
+ * @param version - Resolved DSH runtime version.
+ * @param verified - Releases with direct compatibility evidence.
+ * @param blocklist - Versions excluded after reproduced failures.
+ * @returns The fail-open mount decision.
+ */
+export declare function classifyDshRuntime(version: string, verified: ReadonlySet<string>, blocklist?: Readonly<Record<string, unknown>>): DshRuntimeClassification;
+/**
+ * Apply the fail-open decision and emit at most one visible warning.
+ * @param logger - Host logger receiving compatibility warnings.
+ * @param pluginName - Plugin identifier used in diagnostics.
+ * @param version - Resolved DSH runtime version.
+ * @param verified - Releases with direct compatibility evidence.
+ * @param blocklist - Versions excluded after reproduced failures.
+ * @returns Whether the host mount should continue.
+ */
+export declare function shouldMountDshRuntime(logger: CompatibilityLogger, pluginName: string, version: string, verified: ReadonlySet<string>, blocklist?: Readonly<Record<string, unknown>>): boolean;
+/**
+ * Warn once for an unknown runtime while keeping the normal host mount path.
+ * @param logger - Host logger receiving compatibility warnings.
+ * @param pluginName - Plugin identifier used in diagnostics.
+ * @param candidates - DSH peer packages used to resolve the host version.
+ * @returns Whether the host mount should continue.
+ */
+export declare function allowDshRuntime(logger: CompatibilityLogger, pluginName: string, candidates: readonly string[]): boolean;
+export {};

package/lib/types/deepseek-search-adapter.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { WebSearchRequest, WebSearchResult } from '@deepseek-ai/dsh-web';
+import type { ModelSwitchSearchAdapter, SearchModel } from './adapter-registry.js';
+export declare const DEEPSEEK_SEARCH_MODELS: readonly SearchModel[];
+export declare class DeepSeekSearchAdapter implements ModelSwitchSearchAdapter {
+    private readonly ctx;
+    readonly provider = "deepseek-official";
+    readonly label = "DeepSeek";
+    readonly models: readonly SearchModel[];
+    constructor(ctx: Context);
+    supportsModel(model: string): boolean;
+    search(model: string, request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+export declare function installDeepSeekSearchAdapter(ctx: Context): void;