@toddzheng024/dscode-bundle 0.7.5 → 0.7.7

package/vendor/compaction-basic/types/config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Load-time validation and routed-model policy resolution for compaction-basic.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/config
+ */
+import type { LlmCallConfig } from '@deepseek-ai/dsh-llm';
+import type { BasicCompactionConfig, ResolvedCompactSpec, ResolvedConfig, ResolvedTargetPolicy } from './types.ts';
+/** Target-specific pressure configuration failure eligible for warning suppression. */
+export declare class TargetPressureConfigError extends Error {
+    readonly targetKey: string;
+    /**
+     * @param targetKey - exact provider/model route used as the warning key.
+     * @param message - actionable configuration failure detail.
+     */
+    constructor(targetKey: string, message: string);
+}
+/**
+ * Resolve and validate service defaults plus exact-target partial overrides.
+ * @param config - untrusted plugin configuration after Loader normalization.
+ * @returns detached immutable defaults and validated exact-target overrides.
+ */
+export declare function resolveConfig(config?: BasicCompactionConfig): ResolvedConfig;
+/**
+ * Merge the exact provider/model override over the validated default policy.
+ * @param config - validated service defaults and override table.
+ * @param target - exact durable provider/model route to match.
+ * @returns detached immutable policy before model-capacity scaling.
+ */
+export declare function resolveTargetPolicy(config: ResolvedConfig, target: Pick<LlmCallConfig, 'provider' | 'model'>): ResolvedTargetPolicy;
+/**
+ * Scale one routed policy into concrete token budgets for its model capacity.
+ * @param policy - merged policy for the exact routed target.
+ * @param contextWindow - positive adapter-owned capacity for that target.
+ * @returns detached immutable pressure and retention budgets.
+ */
+export declare function resolveCompactSpec(policy: ResolvedTargetPolicy, contextWindow: number): ResolvedCompactSpec;
+//# sourceMappingURL=config.d.ts.map

package/vendor/compaction-basic/types/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Basic replay-aware compaction backend.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic
+ */
+import { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { CompactionEngine } from '@deepseek-ai/dsh-compaction';
+import type { CompactionResult, CompactionTrigger } from '@deepseek-ai/dsh-compaction';
+import type { SessionSeq } from '@deepseek-ai/dsh-session';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { CommandId } from '@deepseek-ai/dsh-commands/brand';
+import type { SummarizationInput, SummaryResult } from './summarizer.ts';
+import type { BasicCompactionConfig, ResolvedConfig } from './types.ts';
+export type { BasicCompactionConfig, CompactionPolicyConfig, ModelCompactPolicyConfig, ResolvedCompactSpec, ResolvedConfig, ResolvedRetention, ResolvedTargetPolicy, } from './types.ts';
+/**
+ * Dependency-light compaction backend using `ctx.tokenMeter` for pressure,
+ * retention, cited source events, and summary-convergence pricing.
+ *
+ * `summarize()` is the sole subclass customization hook; the replay and durable
+ * mutation strategy stays fixed so every pricing decision uses the singleton
+ * token meter.
+ */
+export declare class BasicCompactionEngine extends CompactionEngine {
+    static inject: string[];
+    static Config: z<BasicCompactionConfig>;
+    /** Resolved and validated compaction configuration. */
+    readonly config: ResolvedConfig;
+    private readonly warnedPressureConfigTargets;
+    private readonly overflowRetries;
+    private readonly overflowAgents;
+    constructor(ctx: Context, config?: BasicCompactionConfig);
+    /**
+     * Register automatic between-step pressure and model-request overflow
+     * recovery. `compactIfNeeded` stays dynamically dispatched so subclass
+     * overrides are honored at event time.
+     */
+    private _registerAutomaticCompaction;
+    /**
+     * Summarize the replayed conversation region through a direct one-shot
+     * `ctx.llm.stream()` call whose prefix reuses the conversation's own system
+     * prompt, tools, and messages so the provider's KV cache is not invalidated.
+     * Override this sole hook for a template or remote summarizer.
+     * @param input - replayed conversation prefix (system, tools, and leading messages) to condense.
+     * @param agent - supplies routed-model history, fallback model, and session id.
+     * @param signal - optional cancellation forwarded to the adapter.
+     * @returns safe text summary blocks and the exact auxiliary call envelope and output.
+     */
+    protected summarize(input: SummarizationInput, agent: Agent, signal?: AbortSignal): Promise<SummaryResult>;
+    /**
+     * Compact for replayed step-boundary pressure or one provider-confirmed context
+     * overflow. Both triggers price the latest durable routed request envelope;
+     * overflow bypasses the normal threshold and retained-tail policy so it can
+     * force one useful balanced reduction.
+     * @param agent - agent whose latest durable routed request is measured.
+     * @param trigger - normal step-boundary pressure or context-overflow recovery.
+     * @param signal - live turn cancellation signal forwarded to summarization.
+     * @returns the latest summary compaction result, or `null` when no summary ran.
+     */
+    compactIfNeeded(agent: Agent, trigger: CompactionTrigger, signal: AbortSignal): Promise<CompactionResult | null>;
+    /**
+     * Compact one inclusive positional range from the agent-owned surface using
+     * the effective token meter for all retention and shrink pricing.
+     * @param start - inclusive first surface-node seq.
+     * @param end - inclusive last surface-node seq.
+     * @param agent - owner of the target session, used by the summarizer.
+     * @param signal - optional summarization cancellation signal.
+     * @returns the successful durable compaction result.
+     */
+    compactRegion(start: SessionSeq, end: SessionSeq, agent: Agent, signal?: AbortSignal): Promise<CompactionResult>;
+    /**
+     * Force one useful idle-session compaction below the pressure threshold, and
+     * resolve only after its standalone marker pair is durably checkpointed.
+     * @param agent - idle agent whose next-turn admission this call reserves.
+     * @param signal - cancellation scoped to this compaction request.
+     * @param sourceCommandId - initiating command identity for presentation correlation.
+     * @returns the committed result, or `null` when no safe useful range exists.
+     */
+    compactNow(agent: Agent, signal: AbortSignal, sourceCommandId?: CommandId): Promise<CompactionResult | null>;
+    /** Bind the effective token meter and dynamically dispatched summarizer hook. */
+    private regionDependencies;
+}
+export default BasicCompactionEngine;
+//# sourceMappingURL=index.d.ts.map

package/vendor/compaction-basic/types/region.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Surface retention selection and the shared log-recorded compaction
+ * transaction for automatic open-turn and manual idle-session compaction.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/region
+ */
+import type { CompactionResult } from '@deepseek-ai/dsh-compaction';
+import type { CommandId } from '@deepseek-ai/dsh-commands/brand';
+import type { TokenMeasurement, TokenMeter } from '@deepseek-ai/dsh-token-meter';
+import { SessionSeq, type Session } from '@deepseek-ai/dsh-session';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SummarizationInput, SummaryResult } from './summarizer.ts';
+interface RegionDependencies {
+    readonly meter: TokenMeter;
+    summarize(input: SummarizationInput, agent: Agent, signal?: AbortSignal): Promise<SummaryResult>;
+}
+interface CompactionTransactionOptions {
+    /** `current-turn` derives a numbered owner; `null` writes a standalone bracket. */
+    readonly owner: 'current-turn' | null;
+    /** Surface relationship that must survive asynchronous summarization. */
+    readonly stability: 'whole-surface' | 'selected-span';
+    /** Optional durability checkpoint after a successfully closed bracket. */
+    readonly flush?: () => Promise<void>;
+    /** Manual command that initiated this transaction, when present. */
+    readonly sourceCommandId?: CommandId;
+}
+/**
+ * Resolve the next range starting at the first non-system surface node while
+ * retaining a priced recent tail and never splitting an assistant
+ * tool-call/result pair. A `system/message` at surface node 0 is never inside
+ * the range; without one the range starts at node 0.
+ * @param session - session supplying authoritative current surface positions.
+ * @param measurement - unified pressure and surface measurement from the conversation meter.
+ * @param retainTokens - minimum recent tail budget retained verbatim.
+ * @returns the inclusive positional seq range to compact, or `null`.
+ */
+export declare function selectCompactableRange(session: Session, measurement: TokenMeasurement, retainTokens: number): {
+    start: SessionSeq;
+    end: SessionSeq;
+} | null;
+/**
+ * Run the single compaction transaction over one selected positional span.
+ * Selection and validation are read-only. Idle/log validation and
+ * `compaction/start` are synchronously adjacent, so the durable opening marker is
+ * the compaction lock before summarization yields. Every later failure makes
+ * exactly one `compaction/end` attempt; a failed close deliberately leaves the
+ * unmatched start detectable.
+ * @param dependencies - conversation meter and dynamically dispatched summarizer hook.
+ * @param session - session whose surface is mutated.
+ * @param start - inclusive first surface-node seq.
+ * @param end - inclusive last surface-node seq.
+ * @param agent - agent used by the summarizer.
+ * @param options - bracket owner, stability rule, and optional durability checkpoint.
+ * @param signal - optional summarization cancellation signal.
+ * @returns the successful durable compaction result.
+ */
+export declare function compactSurfaceRegion(dependencies: RegionDependencies, session: Session, start: SessionSeq, end: SessionSeq, agent: Agent, options: CompactionTransactionOptions, signal?: AbortSignal): Promise<CompactionResult>;
+/**
+ * Recheck the durable compaction lock after an asynchronous policy decision.
+ * @param session - session whose latest marker state is inspected.
+ * @param stage - operation label included in the busy diagnostic.
+ */
+export declare function assertNoActiveCompaction(session: Session, stage: string): void;
+export {};
+//# sourceMappingURL=region.d.ts.map

package/vendor/compaction-basic/types/summarizer.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Default one-shot summarization and durable checkpoint framing.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/summarizer
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ContentBlock, Message, TokenUsage, ToolSchema } from '@deepseek-ai/dsh-llm';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+interface SummaryConfig {
+    readonly summarizationProvider: string;
+    readonly summarizationModel: string;
+    readonly maxTokens: number;
+}
+/**
+ * The replayed conversation surface the summarizer condenses. Reproducing the
+ * last routed request's system prompt, tools, and leading messages verbatim
+ * lets the auxiliary call reuse the provider's warm prefix cache; the trailing
+ * compaction instruction is then the only novel input.
+ */
+export interface SummarizationInput {
+    /** The conversation's tool schemas, reused for prefix-cache alignment; absent when the request carried none. */
+    readonly tools?: readonly ToolSchema[];
+    /** The derived system head, when present, followed by the shadowed region in surface order. */
+    readonly messages: readonly Message[];
+}
+/** Safe summary content plus the exact auxiliary call envelope recorded with it. */
+export type SummaryResult = {
+    summary: ContentBlock[];
+    provider: string;
+    model: string;
+    maxTokens?: number;
+    /** Provider-reported usage for this summarization request. */
+    usage?: TokenUsage;
+} & ({
+    /** Complete provider output before the text-only summary projection. */
+    rawOutput: ContentBlock[];
+    /** Identifies exactly one call through this context's `ctx.llm.stream()`. */
+    llmStreamCall: true;
+} | {
+    /** Optional complete output from an unmarked template, remote, or other summarizer. */
+    rawOutput?: ContentBlock[];
+    /** An unmarked result does not identify a call through this context's LLM seam. */
+    llmStreamCall?: never;
+});
+/**
+ * Run the default cache-reusing `ctx.llm.stream()` summarization call: replay
+ * the conversation prefix, then append the compaction instruction as the final
+ * user message so the provider's warm prefix cache is reused.
+ * @param ctx - context providing the LLM service.
+ * @param config - resolved backend configuration.
+ * @param input - replayed conversation prefix (system, tools, and leading messages) to condense.
+ * @param agent - supplies routed-model history, fallback model, and session id.
+ * @param signal - optional cancellation forwarded to the adapter.
+ * @returns safe text-only summary blocks and the exact call envelope and output.
+ */
+export declare function summarizeWithLlm(ctx: Context, config: SummaryConfig, input: SummarizationInput, agent: Agent, signal?: AbortSignal): Promise<SummaryResult>;
+/**
+ * Wrap raw summary blocks in the durable checkpoint framing.
+ * @param summary - safe text-only model output.
+ * @returns content for the synthesized replacement user message.
+ */
+export declare function frameSummary(summary: readonly ContentBlock[]): ContentBlock[];
+export {};
+//# sourceMappingURL=summarizer.d.ts.map

package/vendor/compaction-basic/types/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Configuration vocabulary for the replay-aware basic compaction backend.
+ *
+ * @module @deepseek-ai/dsh-compaction-basic/types
+ */
+import type { LlmCallConfig } from '@deepseek-ai/dsh-llm';
+/** Policy fields shared by the default policy and exact model overrides. */
+export interface CompactionPolicyConfig {
+    /** Compact at this fraction of the model's context window. Defaults to `0.8`. */
+    thresholdRatio?: number;
+    /** Recent context retained as a fraction of the model's window. Defaults to `0.16`. */
+    retainRatio?: number;
+    /** Absolute recent-context budget; mutually exclusive with `retainRatio`. */
+    retainTokens?: number;
+    /** Summary provider; set together with `summarizationModel`, or inherit the conversation target. */
+    summarizationProvider?: string;
+    /** Summary model; set together with `summarizationProvider`, or inherit the conversation target. */
+    summarizationModel?: string;
+    /** Provider generation cap for summarization. Defaults to `8192`. */
+    maxTokens?: number;
+    /** Extra attempts after the first compaction when pressure remains above threshold. Defaults to `1`. */
+    compactionRetries?: number;
+    /** Maximum retries after canonical context overflow; `0` disables recovery. Defaults to `1`. */
+    maxOverflowRetries?: number;
+}
+/** Exact provider/model override merged over the default compaction policy. */
+export interface ModelCompactPolicyConfig extends CompactionPolicyConfig {
+    /** Registered provider route to match. */
+    provider: string;
+    /** Exact routed model id to match within `provider`. */
+    model: string;
+}
+/** Basic compaction configuration with an optional exact-target policy table. */
+export interface BasicCompactionConfig extends CompactionPolicyConfig {
+    /** Exact provider/model overrides; duplicate targets fail plugin load. */
+    modelPolicies?: ModelCompactPolicyConfig[];
+    /** Enable automatic step-boundary pressure and overflow-recovery listeners. Defaults to `true`. */
+    auto?: boolean;
+}
+/** Exactly one validated retention form. */
+export type ResolvedRetention = {
+    readonly retainRatio: number;
+    readonly retainTokens?: never;
+} | {
+    readonly retainRatio?: never;
+    readonly retainTokens: number;
+};
+/** Validated policy fields shared before and after exact-target matching. */
+interface ResolvedPolicyFields {
+    readonly thresholdRatio: number;
+    readonly summarizationProvider: string;
+    readonly summarizationModel: string;
+    readonly maxTokens: number;
+    readonly compactionRetries: number;
+    readonly maxOverflowRetries: number;
+}
+/** Validated immutable config whose target-specific defaults remain unresolved. */
+export type ResolvedConfig = ResolvedPolicyFields & ResolvedRetention & {
+    readonly modelPolicies: readonly Readonly<ModelCompactPolicyConfig>[];
+    readonly auto: boolean;
+};
+/** Fully merged policy for one routed conversation target, before capacity scaling. */
+export type ResolvedTargetPolicy = ResolvedPolicyFields & ResolvedRetention & {
+    readonly target: Pick<LlmCallConfig, 'provider' | 'model'>;
+};
+/** One routed model's concrete pressure and retention budget. */
+export type ResolvedCompactSpec = Omit<ResolvedTargetPolicy, 'retainRatio' | 'retainTokens'> & {
+    readonly contextWindow: number;
+    readonly thresholdTokens: number;
+    readonly retainTokens: number;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/vendor/deepseek/index.js

@@ -247,7 +247,7 @@ async function serializeMessagesWithImages(messages, images) {
 function requestWithMessages(options, messages, defaults) {
 	messages = flashRequest(options, messages);
 	messages = ultraRequest(options, messages);
-	const tools = options.tools?.filter((tool) => options.reasoningEffort === "ultra" ? tool.name !== "workflow" && tool.name !== "ralph" : !["subagent", "subagent_fork", "workflow", "ralph"].includes(tool.name)).map((tool) => ({
+	const tools = options.tools?.filter((tool) => tool.name !== "workflow" && tool.name !== "ralph").map((tool) => ({
 		type: "function",
 		function: {
 			name: tool.name,

package/vendor/subagent/index.js

@@ -1,6 +1,6 @@
 // dscode-child-name-v1
 // dscode-child-worktree-v3
-// dscode-child-effort-v1
+// dscode-child-effort-v2
 import { createChildWorktree, discardCleanChildWorktree } from "../../plugins/worktree-subagent/worktree.mjs";
 import z from "@deepseek-ai/schemastery";
 import { scopeChainOf, scopeOf } from "@deepseek-ai/dsh-scope";
@@ -396,7 +396,7 @@ function apply(ctx, config, session) {
 			assertSubagentProviderConfiguration(subagentProvider);
 			const wording = providerWording(subagentProvider.inheritsParentContext);
 			const providerRouteDefaults = subagentProvider.agentRouteDefaults;
-			const choiceDescription = !modelSelectionEnabled ? (subagentProvider.capabilities.agentOptions ? " Optionally set reasoning_effort for this child without changing its provider/model. Omit to inherit. Choose low for bounded tasks, high for difficult work, and max only when needed; use an effort supported by the current model." : "") : (providerRouteDefaults !== void 0 ? " Child LLM selection is optional. Omit `provider`, `model`, and `reasoning_effort` to use configured child defaults and this provider's route defaults. Supply `provider` and `model` together after using `list_subagent_models` to inspect advertised routes and efforts. Changing the effective route without naming an effort uses the selected model's default effort." : " Child LLM selection is optional. Omit `provider`, `model`, and `reasoning_effort` to use configured child defaults and inherit compatible missing values from the parent Agent. Supply `provider` and `model` together after using `list_subagent_models` to inspect advertised routes and efforts. Changing the effective route without naming an effort uses the selected model's default effort.") + (subagentProvider.inheritsParentContext ? " Changing the route can prevent provider-side reuse of the inherited conversation prefix." : "");
+			const choiceDescription = !modelSelectionEnabled ? (subagentProvider.capabilities.agentOptions ? " Optionally set reasoning_effort for this child without changing its provider/model. Omit to inherit. Use a level the current model offers: the lowest that fits the task, raised only for difficult work or real uncertainty." : "") : (providerRouteDefaults !== void 0 ? " Child LLM selection is optional. Omit `provider`, `model`, and `reasoning_effort` to use configured child defaults and this provider's route defaults. Supply `provider` and `model` together after using `list_subagent_models` to inspect advertised routes and efforts. Changing the effective route without naming an effort uses the selected model's default effort." : " Child LLM selection is optional. Omit `provider`, `model`, and `reasoning_effort` to use configured child defaults and inherit compatible missing values from the parent Agent. Supply `provider` and `model` together after using `list_subagent_models` to inspect advertised routes and efforts. Changing the effective route without naming an effort uses the selected model's default effort.") + (subagentProvider.inheritsParentContext ? " Changing the route can prevent provider-side reuse of the inherited conversation prefix." : "");
 			mounted = {
 				subagentProvider,
 				disposeTool: runtimeCtx.tools.register(defineTool({
@@ -434,7 +434,7 @@ function apply(ctx, config, session) {
 						} : {},
 						...!modelSelectionEnabled && subagentProvider.capabilities.agentOptions ? { reasoning_effort: {
               type: "string",
-              description: "Reasoning effort for this child only, validated against its model. Omit to inherit. Prefer low for bounded tasks, high for difficult work, max for exceptional uncertainty. Provider/model remain unchanged."
+              description: "Reasoning effort for this child only, validated against its model; use a level that model offers. Omit to inherit. Prefer the lowest level that fits the task and raise it only for difficult work or real uncertainty. Provider/model remain unchanged."
             } } : {},
             ...continuable && (config.provider === "spawn" || config.provider === "fork") ? { worktree: {
               type: "boolean",

package/vendor/tui/dscode-providers/catalog.mjs

@@ -1,37 +1,46 @@
 // Model providers `/provider` switches between. DeepSeek's official API is the
-// native `llm-deepseek` route; OpenRouter reaches the same DeepSeek models
-// through pi-ai's catalog route, which the base composition mounts dormant until
-// a `llm-pi-ai:` settings section declares it.
+// native `llm-deepseek` route; OpenRouter is DSCODE's own adapter
+// (plugins/openrouter), which serves OpenRouter's live model listing and is always
+// registered. This module ships beside the TUI too, so it imports nothing.
 
 export const PROVIDERS = Object.freeze([
   { id: 'deepseek-official', name: 'DeepSeek', aliases: ['deepseek', 'deepseek-official', 'official'], credentialRef: 'DEEPSEEK_API_KEY', defaultModel: 'deepseek-flash' },
-  { id: 'openrouter', name: 'OpenRouter', aliases: ['openrouter', 'open-router'], credentialRef: 'OPENROUTER_API_KEY', defaultModel: 'deepseek/deepseek-v4-flash' },
+  // The optional management key reads account data only; it cannot call models.
+  { id: 'openrouter', name: 'OpenRouter', aliases: ['openrouter', 'open-router'], credentialRef: 'OPENROUTER_API_KEY', managementRef: 'OPENROUTER_MANAGEMENT_KEY', defaultModel: 'deepseek/deepseek-v4-flash' },
 ]);
 
+// The pi-ai adapter served OpenRouter until 0.7.6, from this settings section.
 const PI_AI_NS = 'llm-pi-ai';
 
 // OpenRouter serves DeepSeek V4 thinking as none/high/xhigh. DeepSeek itself
 // answers `low` as high and `max` as xhigh, so the route offers the official
 // low/high/max detents (and Ultra on top of max) with the wire spelling OpenRouter
 // accepts; session cards and delegated children that ask for `low` keep working.
-const OPENROUTER_EFFORTS = Object.freeze({ off: 'none', low: 'high', high: 'high', max: 'xhigh' });
+export const OPENROUTER_EFFORTS = Object.freeze({ off: 'none', low: 'high', high: 'high', max: 'xhigh' });
 
-/** The DeepSeek models the OpenRouter route declares, with their official-route counterparts. */
+/** The DeepSeek models the OpenRouter route serves, with their official-route counterparts. */
 export const OPENROUTER_MODELS = Object.freeze([
   { id: 'deepseek/deepseek-v4-flash', name: 'DeepSeek V4 Flash', official: ['deepseek-flash', 'deepseek-v4-flash'] },
   { id: 'deepseek/deepseek-v4-pro', name: 'DeepSeek V4 Pro', official: ['deepseek-v4-pro'] },
   { id: 'deepseek/deepseek-v4-flash-vision-exp', name: 'DeepSeek V4 Flash Vision Exp', official: ['deepseek-v4-flash-vision-exp'] },
 ]);
 
-/** The `llm-pi-ai` profile `/provider openrouter` writes: installed-catalog models narrowed to DeepSeek. */
-export function openRouterProfile() {
-  return {
-    displayName: 'OpenRouter',
-    apiKeyEnv: 'OPENROUTER_API_KEY',
-    // Like the official route, requests default to high; it also gives /effort the DSCODE detent bar.
-    reasoning: 'high',
-    models: OPENROUTER_MODELS.map(({ id, name }) => ({ id, name, reasoningEfforts: { ...OPENROUTER_EFFORTS } })),
-  };
+/**
+ * Remove the `openrouter` profile earlier builds wrote into the pi-ai section. The
+ * pi-ai adapter is no longer mounted, so the profile is inert, and it would claim the
+ * route a second time if that adapter were ever mounted again.
+ * Never throws: /model and /provider must open regardless.
+ * @returns whether the settings changed.
+ */
+export async function migrateOpenRouterProfile(settings) {
+  try {
+    const descriptor = settings?.describe?.({ redactSecrets: true }).find(entry => entry.ns === PI_AI_NS);
+    if (!descriptor || settings.writable !== true || descriptor.value?.providers?.openrouter === undefined) return false;
+    await settings.mutate(PI_AI_NS, [{ op: 'unset', path: ['providers', 'openrouter'] }], descriptor.revision);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 export function providerSpec(id) {
@@ -106,23 +115,16 @@ export function credentialState(row) {
 }
 
 /**
- * Declare a provider's route before it is used. Only OpenRouter needs one; a
- * profile the user already has (their own models or endpoint) is left alone.
+ * Prepare a provider before a switch. Both routes are always registered; switching
+ * to OpenRouter only clears the inert pi-ai profile earlier builds wrote.
  * @param settings - the host settings service.
  * @returns whether the settings changed.
  */
 export async function ensureProviderRoute(settings, provider) {
-  if (provider !== 'openrouter') return false;
-  if (typeof settings?.describe !== 'function' || typeof settings.mutate !== 'function') throw new Error('settings are unavailable; OpenRouter cannot be configured in this profile');
-  const descriptor = settings.describe({ redactSecrets: true }).find(entry => entry.ns === PI_AI_NS);
-  if (!descriptor) throw new Error('the OpenRouter adapter (llm-pi-ai) is not mounted in this profile');
-  if (descriptor.value?.providers?.openrouter !== undefined) return false;
-  if (settings.writable !== true) throw new Error('settings are read-only; OpenRouter cannot be configured here');
-  await settings.mutate(PI_AI_NS, [{ op: 'set', path: ['providers', 'openrouter'], value: openRouterProfile() }], descriptor.revision);
-  return true;
+  return provider === 'openrouter' ? migrateOpenRouterProfile(settings) : false;
 }
 
-/** Wait for a freshly declared route to reach the model directory. */
+/** Wait for a route's models to reach the model directory. */
 export async function waitForModels(loadModels, provider, { attempts = 30, delayMs = 100 } = {}) {
   let directory;
   for (let attempt = 0; attempt < attempts; attempt++) {

package/vendor/tui/dscode-providers/effort.mjs

@@ -0,0 +1,35 @@
+// Reasoning levels differ per model: DeepSeek offers low/high/max, GPT models
+// minimal through high, and many OpenRouter models none at all. Auxiliary calls
+// name the level they would like and send the nearest one the model offers, or no
+// effort when the model offers no levels.
+
+/** Standard reasoning levels, lowest first. */
+export const EFFORT_LEVELS = Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+
+/**
+ * The level to request from a model.
+ * @param offered - the model's effort ids, or `undefined` when its capability is unknown.
+ * @param wanted - the level the caller would like.
+ * @returns `wanted` when offered or when the capability is unknown; otherwise the nearest
+ *   offered level at or above it, else the highest below; `undefined` when the model offers
+ *   no standard level.
+ */
+export function chooseEffort(offered, wanted) {
+  if (wanted === undefined || offered === undefined || offered.includes(wanted)) return wanted;
+  const rank = EFFORT_LEVELS.indexOf(wanted);
+  const levels = EFFORT_LEVELS.filter(level => offered.includes(level));
+  if (rank < 0 || levels.length === 0) return undefined;
+  return levels.find(level => EFFORT_LEVELS.indexOf(level) >= rank) ?? levels.at(-1);
+}
+
+/**
+ * {@link chooseEffort} for a route, reading the model's levels from the LLM service.
+ * A service without model metadata, or a failed lookup, keeps `wanted`.
+ */
+export async function effortFor(llm, route, wanted, signal) {
+  if (wanted === undefined || typeof llm?.resolveModelInfo !== 'function' || !route?.provider || !route?.model) return wanted;
+  let info;
+  try { info = await llm.resolveModelInfo(route.provider, route.model, signal); }
+  catch { return wanted; }
+  return chooseEffort(info?.reasoning?.efforts?.map(effort => effort.id) ?? [], wanted);
+}