shortcutxl 0.3.76 → 0.3.77

package/dist/app/providers/model-registry.js

@@ -36,6 +36,28 @@ const OpenAICompletionsCompatSchema = Type.Object({
     openRouterRouting: Type.Optional(OpenRouterRoutingSchema),
     vercelGatewayRouting: Type.Optional(VercelGatewayRoutingSchema)
 });
+const EnabledReasoningLevelSchema = Type.Union([
+    Type.Literal('minimal'),
+    Type.Literal('low'),
+    Type.Literal('medium'),
+    Type.Literal('high'),
+    Type.Literal('xhigh'),
+    Type.Literal('max')
+]);
+const ModelCapabilitiesSchema = Type.Object({
+    reasoning: Type.Optional(Type.Object({
+        control: Type.Union([
+            Type.Literal('adaptive-effort'),
+            Type.Literal('effort'),
+            Type.Literal('thinking-level'),
+            Type.Literal('budget'),
+            Type.Literal('fixed')
+        ]),
+        levels: Type.Array(EnabledReasoningLevelSchema, { minItems: 1, uniqueItems: true }),
+        defaultLevel: EnabledReasoningLevelSchema,
+        supportsOff: Type.Boolean()
+    }))
+});
 // Schema for custom model definition
 // Most fields are optional with sensible defaults for local models (Ollama, LM Studio, etc.)
 const ModelDefinitionSchema = Type.Object({
@@ -52,6 +74,7 @@ const ModelDefinitionSchema = Type.Object({
     })),
     contextWindow: Type.Optional(Type.Number()),
     maxTokens: Type.Optional(Type.Number()),
+    capabilities: Type.Optional(ModelCapabilitiesSchema),
     headers: Type.Optional(Type.Record(Type.String(), Type.String())),
     compat: Type.Optional(OpenAICompletionsCompatSchema)
 });
@@ -68,6 +91,7 @@ const ModelOverrideSchema = Type.Object({
     })),
     contextWindow: Type.Optional(Type.Number()),
     maxTokens: Type.Optional(Type.Number()),
+    capabilities: Type.Optional(ModelCapabilitiesSchema),
     headers: Type.Optional(Type.Record(Type.String(), Type.String())),
     compat: Type.Optional(OpenAICompletionsCompatSchema)
 });
@@ -141,6 +165,9 @@ function applyModelOverride(model, override) {
         result.contextWindow = override.contextWindow;
     if (override.maxTokens !== undefined)
         result.maxTokens = override.maxTokens;
+    if (override.capabilities !== undefined) {
+        result.capabilities = override.capabilities;
+    }
     // Merge cost (partial override)
     if (override.cost) {
         result.cost = {
@@ -321,6 +348,12 @@ export class ModelRegistry {
         }
     }
     validateConfig(config) {
+        const validateReasoningCapabilities = (label, capabilities) => {
+            const reasoning = capabilities?.reasoning;
+            if (reasoning && !reasoning.levels.includes(reasoning.defaultLevel)) {
+                throw new Error(`${label}: capabilities.reasoning.defaultLevel must be included in levels.`);
+            }
+        };
         for (const [providerName, providerConfig] of Object.entries(config.providers)) {
             const hasProviderApi = !!providerConfig.api;
             const models = providerConfig.models ?? [];
@@ -352,6 +385,10 @@ export class ModelRegistry {
                     throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid contextWindow`);
                 if (modelDef.maxTokens !== undefined && modelDef.maxTokens <= 0)
                     throw new Error(`Provider ${providerName}, model ${modelDef.id}: invalid maxTokens`);
+                validateReasoningCapabilities(`Provider ${providerName}, model ${modelDef.id}`, modelDef.capabilities);
+            }
+            for (const [modelId, override] of Object.entries(providerConfig.modelOverrides ?? {})) {
+                validateReasoningCapabilities(`Provider ${providerName}, model override ${modelId}`, override.capabilities);
             }
         }
     }
@@ -398,6 +435,7 @@ export class ModelRegistry {
                     cost: modelDef.cost ?? defaultCost,
                     contextWindow: modelDef.contextWindow ?? 128000,
                     maxTokens: modelDef.maxTokens ?? 16384,
+                    capabilities: modelDef.capabilities,
                     headers,
                     compat: modelDef.compat
                 });
@@ -538,6 +576,7 @@ export class ModelRegistry {
                     cost: modelDef.cost,
                     contextWindow: modelDef.contextWindow,
                     maxTokens: modelDef.maxTokens,
+                    capabilities: modelDef.capabilities,
                     headers,
                     compat: modelDef.compat
                 });

package/dist/app/providers/model-resolver.js

@@ -2,6 +2,7 @@
  * Model resolution, scoping, and initial selection
  */
 import chalk from 'chalk';
+import { resolveModelReasoningLevel } from '../../ai/models.js';
 import { DEFAULT_THINKING_LEVEL, isValidThinkingLevel } from '../../core/defaults.js';
 import { SHORTCUT_MODEL_ID, SHORTCUT_OPENAI_MODEL_ID, SHORTCUT_PROVIDER_ID } from '../../model-ids.js';
 export function formatModelRef(model) {
@@ -40,7 +41,7 @@ export const defaultModelPerProvider = {
     anthropic: SHORTCUT_MODEL_ID.ClaudeOpus5,
     openai: SHORTCUT_OPENAI_MODEL_ID,
     'azure-openai-responses': SHORTCUT_OPENAI_MODEL_ID,
-    google: 'gemini-2.5-pro',
+    google: 'gemini-3-flash-preview',
     'google-vertex': 'gemini-3-pro-preview',
     openrouter: `openai/${SHORTCUT_OPENAI_MODEL_ID}`,
     'vercel-ai-gateway': 'anthropic/claude-opus-5',
@@ -321,16 +322,18 @@ export async function findInitialModel(options) {
             console.error(chalk.red(`Model ${cliProvider}/${cliModel} not found`));
             process.exit(1);
         }
-        return { model: found, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: undefined };
+        return {
+            model: found,
+            thinkingLevel: resolveModelReasoningLevel(found, undefined),
+            fallbackMessage: undefined
+        };
     }
     // 2. Try saved default from settings
     if (defaultProvider && defaultModelId) {
         const found = modelRegistry.find(defaultProvider, defaultModelId);
         if (found) {
             model = found;
-            if (defaultThinkingLevel) {
-                thinkingLevel = defaultThinkingLevel;
-            }
+            thinkingLevel = resolveModelReasoningLevel(found, defaultThinkingLevel);
             return { model, thinkingLevel, fallbackMessage: undefined };
         }
     }
@@ -344,7 +347,7 @@ export async function findInitialModel(options) {
                 if (match) {
                     return {
                         model: match,
-                        thinkingLevel: DEFAULT_THINKING_LEVEL,
+                        thinkingLevel: resolveModelReasoningLevel(match, undefined),
                         fallbackMessage: undefined
                     };
                 }
@@ -353,7 +356,7 @@ export async function findInitialModel(options) {
         // If no default found, use first available
         return {
             model: availableModels[0],
-            thinkingLevel: DEFAULT_THINKING_LEVEL,
+            thinkingLevel: resolveModelReasoningLevel(availableModels[0], undefined),
             fallbackMessage: undefined
         };
     }

package/dist/app/providers/register-shortcut-provider.js

@@ -14,7 +14,7 @@ import { streamSimpleOpenAICompletions } from '../../ai/providers/openai-complet
 import { streamSimpleOpenAIResponses } from '../../ai/providers/openai-responses.js';
 import { createRunContinuationFetch } from '../../ai/run-continuation.js';
 import { NPM_PACKAGE_NAME, VERSION } from '../../config.js';
-import { gatewayBaseUrlForTransport } from '../../embedded-agent/gateway-base-url.js';
+import { gatewayModelForTransport } from '../../embedded-agent/gateway-base-url.js';
 import { OPENAI_PRIORITY_SERVICE_TIER, shortcutProviderFastModeForContext, shortcutSpeedFromOptions, withProviderFastModeHeaders, withProviderFastModePayloadOverride } from '../../embedded-agent/provider-fast-mode.js';
 import { SHORTCUT_PROVIDER_ID } from '../../model-ids.js';
 import { createShortcutModelDefinitions } from '../../shortcut-model-catalog.js';
@@ -116,11 +116,7 @@ export function createShortcutApiV2Dispatcher(getExtraHeaders) {
         // SDK appends "/chat/completions" to baseURL and needs the "/v1" segment;
         // Anthropic builds its own full path). Shared with the standalone transports
         // so the two paths cannot disagree.
-        const nativeModel = {
-            ...model,
-            api: transport,
-            baseUrl: gatewayBaseUrlForTransport(model.baseUrl, transport)
-        };
+        const nativeModel = gatewayModelForTransport(model, model.baseUrl, transport);
         const providerFastModeKind = providerFastModeKindForTransport(transport);
         const fastMode = providerFastModeKind
             ? shortcutProviderFastModeForContext({

package/dist/app/providers/shortcut-api-v2-transport.js

@@ -13,7 +13,11 @@
  * Returns `undefined` for anything else so callers can decide how to fail.
  */
 import { SHORTCUT_MODEL_ID } from '../../model-ids.js';
+import { resolveShortcutModelProtocol } from '../../shortcut-model-catalog.js';
 export function resolveShortcutApiV2Transport(modelId) {
+    const catalogProtocol = resolveShortcutModelProtocol(modelId);
+    if (catalogProtocol)
+        return catalogProtocol;
     const normalized = modelId.trim().toLowerCase();
     // Shortcut-hosted "Pivot" and Fireworks GLM both speak OpenAI completions.
     if (normalized === SHORTCUT_MODEL_ID.Hosted ||

package/dist/app/providers/shortcut-llm-proxy-client.d.ts

@@ -9,6 +9,7 @@
  * call funnels through one transport keyed by model — there is no separate
  * `/api/llm` proxy for helpers.
  */
+import type { ReasoningLevel } from '../../ai/types.js';
 import type { AgentModelRegistry } from '../../contracts/agent-model.js';
 export interface ShortcutLlmAttribution {
     continuationRunId?: string;
@@ -25,8 +26,7 @@ export interface ShortcutLlmProxyRequest {
     model: string;
     messages: ShortcutLlmMessage[];
     tools?: unknown[];
-    effort_level?: string;
-    thinking_type?: string;
+    reasoning?: ReasoningLevel;
     max_tokens?: number;
     max_output_tokens?: number;
     speed?: 'fast' | 'standard';

package/dist/app/providers/shortcut-llm-proxy-client.js

@@ -146,6 +146,7 @@ export function createShortcutLlmProxyClient(options) {
                 apiKey,
                 continuationRunId: attribution?.continuationRunId,
                 maxTokens: request.max_tokens ?? request.max_output_tokens,
+                reasoning: request.reasoning,
                 signal: callOptions?.signal,
                 headers,
                 userMessageId: attribution?.userMessageId,

package/dist/app/resources/package-manager.js

@@ -8,14 +8,14 @@
  * resolved resource to support diagnostics and conflict detection.
  */
 import ignore from 'ignore';
-import { minimatch } from 'minimatch';
 import { spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
-import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { dirname, join, relative, resolve, sep } from 'node:path';
 import { CONFIG_DIR_NAME, getBundledSkillsDir } from '../../config.js';
 import { parseGitUrl } from '../../shared/scm/git.js';
+import { applyPatterns, isEnabledByOverrides } from './resource-patterns.js';
 /** Timeout for npm/git network operations. */
 const NETWORK_TIMEOUT_MS = 10000;
 function isOfflineModeEnabled() {
@@ -365,127 +365,6 @@ function collectResourceFiles(dir, resourceType) {
     }
     return collectFiles(dir, FILE_PATTERNS[resourceType]);
 }
-function matchesAnyPattern(filePath, patterns, baseDir) {
-    const rel = relative(baseDir, filePath);
-    const name = basename(filePath);
-    const isSkillFile = name === 'SKILL.md';
-    const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
-    const parentName = isSkillFile ? basename(parentDir) : undefined;
-    return patterns.some((pattern) => {
-        if (minimatch(rel, pattern) || minimatch(name, pattern) || minimatch(filePath, pattern)) {
-            return true;
-        }
-        if (!isSkillFile)
-            return false;
-        return (minimatch(parentRel, pattern) ||
-            minimatch(parentName, pattern) ||
-            minimatch(parentDir, pattern));
-    });
-}
-function normalizeExactPattern(pattern) {
-    if (pattern.startsWith('./') || pattern.startsWith('.\\')) {
-        return pattern.slice(2);
-    }
-    return pattern;
-}
-function matchesAnyExactPattern(filePath, patterns, baseDir) {
-    if (patterns.length === 0)
-        return false;
-    const rel = relative(baseDir, filePath);
-    const name = basename(filePath);
-    const isSkillFile = name === 'SKILL.md';
-    const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
-    return patterns.some((pattern) => {
-        const normalized = normalizeExactPattern(pattern);
-        if (normalized === rel || normalized === filePath) {
-            return true;
-        }
-        if (!isSkillFile)
-            return false;
-        return normalized === parentRel || normalized === parentDir;
-    });
-}
-function getOverridePatterns(entries) {
-    return entries.filter((pattern) => pattern.startsWith('!') || pattern.startsWith('+') || pattern.startsWith('-'));
-}
-function isEnabledByOverrides(filePath, patterns, baseDir) {
-    const overrides = getOverridePatterns(patterns);
-    const excludes = overrides
-        .filter((pattern) => pattern.startsWith('!'))
-        .map((pattern) => pattern.slice(1));
-    const forceIncludes = overrides
-        .filter((pattern) => pattern.startsWith('+'))
-        .map((pattern) => pattern.slice(1));
-    const forceExcludes = overrides
-        .filter((pattern) => pattern.startsWith('-'))
-        .map((pattern) => pattern.slice(1));
-    let enabled = true;
-    if (excludes.length > 0 && matchesAnyPattern(filePath, excludes, baseDir)) {
-        enabled = false;
-    }
-    if (forceIncludes.length > 0 && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
-        enabled = true;
-    }
-    if (forceExcludes.length > 0 && matchesAnyExactPattern(filePath, forceExcludes, baseDir)) {
-        enabled = false;
-    }
-    return enabled;
-}
-/**
- * Apply patterns to paths and return a Set of enabled paths.
- * Pattern types:
- * - Plain patterns: include matching paths
- * - `!pattern`: exclude matching paths
- * - `+path`: force-include exact path (overrides exclusions)
- * - `-path`: force-exclude exact path (overrides force-includes)
- */
-function applyPatterns(allPaths, patterns, baseDir) {
-    const includes = [];
-    const excludes = [];
-    const forceIncludes = [];
-    const forceExcludes = [];
-    for (const p of patterns) {
-        if (p.startsWith('+')) {
-            forceIncludes.push(p.slice(1));
-        }
-        else if (p.startsWith('-')) {
-            forceExcludes.push(p.slice(1));
-        }
-        else if (p.startsWith('!')) {
-            excludes.push(p.slice(1));
-        }
-        else {
-            includes.push(p);
-        }
-    }
-    // Step 1: Apply includes (or all if no includes)
-    let result;
-    if (includes.length === 0) {
-        result = [...allPaths];
-    }
-    else {
-        result = allPaths.filter((filePath) => matchesAnyPattern(filePath, includes, baseDir));
-    }
-    // Step 2: Apply excludes
-    if (excludes.length > 0) {
-        result = result.filter((filePath) => !matchesAnyPattern(filePath, excludes, baseDir));
-    }
-    // Step 3: Force-include (add back from allPaths, overriding exclusions)
-    if (forceIncludes.length > 0) {
-        for (const filePath of allPaths) {
-            if (!result.includes(filePath) && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
-                result.push(filePath);
-            }
-        }
-    }
-    // Step 4: Force-exclude (remove even if included or force-included)
-    if (forceExcludes.length > 0) {
-        result = result.filter((filePath) => !matchesAnyExactPattern(filePath, forceExcludes, baseDir));
-    }
-    return new Set(result);
-}
 /**
  * Default PackageManager implementation.
  *

package/dist/app/resources/resource-patterns.d.ts

@@ -0,0 +1,9 @@
+export declare function isEnabledByOverrides(filePath: string, patterns: string[], baseDir: string): boolean;
+/**
+ * Apply resource include/exclude patterns to paths.
+ *
+ * Plain patterns include glob matches, `!pattern` excludes glob matches,
+ * `+path` force-includes an exact path, and `-path` force-excludes one.
+ */
+export declare function applyPatterns(allPaths: string[], patterns: string[], baseDir: string): Set<string>;
+//# sourceMappingURL=resource-patterns.d.ts.map

package/dist/app/resources/resource-patterns.js

@@ -0,0 +1,120 @@
+import { Minimatch } from 'minimatch';
+import { basename, dirname, relative, sep } from 'node:path';
+const RESOURCE_PATTERN_OPTIONS = {
+    // Resource filters have always been case-sensitive on every platform. Keep
+    // that contract explicit rather than inheriting platform-specific behavior.
+    nocase: false,
+    // Preserve the minimatch semantics used before these helpers were extracted.
+    nocomment: false,
+    nonegate: false
+};
+function compilePatterns(patterns) {
+    return patterns.map((pattern) => new Minimatch(normalizePathSeparators(pattern), RESOURCE_PATTERN_OPTIONS));
+}
+function normalizePathSeparators(path) {
+    return path.split(sep).join('/');
+}
+function matchCandidates(filePath, baseDir) {
+    const relativePath = relative(baseDir, filePath);
+    const candidates = [relativePath, basename(filePath), filePath];
+    if (basename(filePath) === 'SKILL.md') {
+        const parentDir = dirname(filePath);
+        candidates.push(relative(baseDir, parentDir), basename(parentDir), parentDir);
+    }
+    return candidates.map(normalizePathSeparators);
+}
+function matchesAnyPattern(filePath, patterns, baseDir) {
+    const candidates = matchCandidates(filePath, baseDir);
+    return patterns.some((pattern) => candidates.some((candidate) => pattern.match(candidate)));
+}
+function normalizeExactPattern(pattern) {
+    pattern = normalizePathSeparators(pattern);
+    if (pattern.startsWith('./') || pattern.startsWith('.\\')) {
+        return pattern.slice(2);
+    }
+    return pattern;
+}
+function matchesAnyExactPattern(filePath, patterns, baseDir) {
+    if (patterns.length === 0)
+        return false;
+    const relativePath = normalizePathSeparators(relative(baseDir, filePath));
+    const candidates = [relativePath, normalizePathSeparators(filePath)];
+    if (basename(filePath) === 'SKILL.md') {
+        const parentDir = dirname(filePath);
+        candidates.push(normalizePathSeparators(relative(baseDir, parentDir)), normalizePathSeparators(parentDir));
+    }
+    return patterns.some((pattern) => candidates.includes(normalizeExactPattern(pattern)));
+}
+function getOverridePatterns(entries) {
+    return entries.filter((pattern) => pattern.startsWith('!') || pattern.startsWith('+') || pattern.startsWith('-'));
+}
+export function isEnabledByOverrides(filePath, patterns, baseDir) {
+    const overrides = getOverridePatterns(patterns);
+    const excludes = overrides
+        .filter((pattern) => pattern.startsWith('!'))
+        .map((pattern) => pattern.slice(1));
+    const forceIncludes = overrides
+        .filter((pattern) => pattern.startsWith('+'))
+        .map((pattern) => pattern.slice(1));
+    const forceExcludes = overrides
+        .filter((pattern) => pattern.startsWith('-'))
+        .map((pattern) => pattern.slice(1));
+    const excludeMatchers = compilePatterns(excludes);
+    let enabled = true;
+    if (excludeMatchers.length > 0 && matchesAnyPattern(filePath, excludeMatchers, baseDir)) {
+        enabled = false;
+    }
+    if (forceIncludes.length > 0 && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
+        enabled = true;
+    }
+    if (forceExcludes.length > 0 && matchesAnyExactPattern(filePath, forceExcludes, baseDir)) {
+        enabled = false;
+    }
+    return enabled;
+}
+/**
+ * Apply resource include/exclude patterns to paths.
+ *
+ * Plain patterns include glob matches, `!pattern` excludes glob matches,
+ * `+path` force-includes an exact path, and `-path` force-excludes one.
+ */
+export function applyPatterns(allPaths, patterns, baseDir) {
+    const includes = [];
+    const excludes = [];
+    const forceIncludes = [];
+    const forceExcludes = [];
+    for (const pattern of patterns) {
+        if (pattern.startsWith('+')) {
+            forceIncludes.push(pattern.slice(1));
+        }
+        else if (pattern.startsWith('-')) {
+            forceExcludes.push(pattern.slice(1));
+        }
+        else if (pattern.startsWith('!')) {
+            excludes.push(pattern.slice(1));
+        }
+        else {
+            includes.push(pattern);
+        }
+    }
+    const includeMatchers = compilePatterns(includes);
+    const excludeMatchers = compilePatterns(excludes);
+    let result = includeMatchers.length === 0
+        ? [...allPaths]
+        : allPaths.filter((filePath) => matchesAnyPattern(filePath, includeMatchers, baseDir));
+    if (excludeMatchers.length > 0) {
+        result = result.filter((filePath) => !matchesAnyPattern(filePath, excludeMatchers, baseDir));
+    }
+    for (const filePath of allPaths) {
+        if (forceIncludes.length > 0 &&
+            !result.includes(filePath) &&
+            matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
+            result.push(filePath);
+        }
+    }
+    if (forceExcludes.length > 0) {
+        result = result.filter((filePath) => !matchesAnyExactPattern(filePath, forceExcludes, baseDir));
+    }
+    return new Set(result);
+}
+//# sourceMappingURL=resource-patterns.js.map

package/dist/app/session/forked-agent.d.ts

@@ -14,8 +14,8 @@
  *
  * Global concurrency is still capped to avoid overwhelming the LLM proxy.
  */
-import type { AssistantMessage, Message, Model, ThinkingLevel, ToolCall } from '../../ai/types.js';
-import type { ToolDefinition, ToolExecutionContext } from '../../core/core-types.js';
+import type { AssistantMessage, Message, Model, ToolCall } from '../../ai/types.js';
+import type { ThinkingLevel, ToolDefinition, ToolExecutionContext } from '../../core/core-types.js';
 import type { ShortcutAuthRecovery } from '../providers/shortcut-auth-recovery.js';
 export type { ThinkingLevel };
 export interface ForkedAgentParentContext {

package/dist/app/session/model-manager.js

@@ -6,7 +6,8 @@
  * Stable deps (agent, registries, managers) are constructor-injected.
  * Part of the AgentSession extracted modules.
  */
-import { clampThinkingLevel, computeNextModel, cycleThinkingLevel as computeNextThinkingLevel, filterInteractiveSelectableModels, getAvailableThinkingLevels } from './session-models.js';
+import { resolveModelReasoningLevel } from '../../ai/models.js';
+import { computeNextModel, cycleThinkingLevel as computeNextThinkingLevel, filterInteractiveSelectableModels } from './session-models.js';
 // ============================================================================
 // Manager
 // ============================================================================
@@ -47,7 +48,7 @@ export class ModelManager {
     }
     /** Set thinking level, clamped to model capabilities. Persists only on change. */
     setThinkingLevel(level) {
-        const effective = clampThinkingLevel(level, getAvailableThinkingLevels(this._agent.state.model));
+        const effective = resolveModelReasoningLevel(this._agent.state.model, level);
         const isChanging = effective !== this._agent.state.thinkingLevel;
         this._agent.setThinkingLevel(effective);
         if (isChanging) {

package/dist/app/session/session-lifecycle.js

@@ -5,8 +5,8 @@
  * existing sessions. Each function takes an explicit params object containing
  * the dependencies it needs, rather than reaching into class state.
  */
+import { resolveModelReasoningLevel } from '../../ai/models.js';
 import { configureAgentTempDir } from '../../config.js';
-import { DEFAULT_THINKING_LEVEL } from '../../core/index.js';
 /**
  * Create a new session, optionally with initial messages and parent tracking.
  * Returns true if completed, false if cancelled by extension.
@@ -119,7 +119,8 @@ export async function executeSwitchSession(params) {
     const hasThinkingEntry = sessionManager
         .getBranch()
         .some((entry) => entry.type === 'thinking_level_change');
-    const defaultThinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+    const defaultThinkingLevel = settingsManager.getDefaultThinkingLevel() ??
+        resolveModelReasoningLevel(agent.state.model, undefined);
     if (hasThinkingEntry) {
         // Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
         setThinkingLevel(sessionContext.thinkingLevel);

package/dist/app/session/session-models.d.ts

@@ -16,6 +16,8 @@ export interface ModelCycleResult {
 export declare const THINKING_LEVELS: ThinkingLevel[];
 /** Thinking levels including xhigh (for supported models) */
 export declare const THINKING_LEVELS_WITH_XHIGH: ThinkingLevel[];
+/** Complete ordering used only when clamping a stale selection after a model switch. */
+export declare const ALL_THINKING_LEVELS: ThinkingLevel[];
 /** Check if a model supports thinking/reasoning. */
 export declare function supportsThinking(model: Model<any> | undefined): boolean;
 /** Check if a model supports xhigh thinking. */

package/dist/app/session/session-models.js

@@ -5,7 +5,7 @@
  * AgentSession delegates to these for cycling math and level clamping,
  * then handles persistence and extension events itself.
  */
-import { modelsAreEqual, supportsXhigh } from '../../ai/models.js';
+import { getModelReasoningLevels, modelsAreEqual } from '../../ai/models.js';
 import { SHORTCUT_MODEL_ID, SHORTCUT_OPENAI_MODEL_ID } from '../../model-ids.js';
 // ============================================================================
 // Constants
@@ -21,6 +21,16 @@ export const THINKING_LEVELS_WITH_XHIGH = [
     'high',
     'xhigh'
 ];
+/** Complete ordering used only when clamping a stale selection after a model switch. */
+export const ALL_THINKING_LEVELS = [
+    'off',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max'
+];
 /** Models shown in interactive model controls for known providers. Unlisted providers show all. */
 const INTERACTIVE_MODELS_PER_PROVIDER = {
     shortcut: new Set([
@@ -42,13 +52,11 @@ export function supportsThinking(model) {
 }
 /** Check if a model supports xhigh thinking. */
 export function supportsXhighThinking(model) {
-    return model ? supportsXhigh(model) : false;
+    return model ? getModelReasoningLevels(model).includes('xhigh') : false;
 }
 /** Get available thinking levels for a given model. */
 export function getAvailableThinkingLevels(model) {
-    if (!supportsThinking(model))
-        return ['off'];
-    return supportsXhighThinking(model) ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
+    return model ? getModelReasoningLevels(model) : ['off'];
 }
 /**
  * Clamp a thinking level to the nearest available level.
@@ -57,7 +65,7 @@ export function getAvailableThinkingLevels(model) {
 export function clampThinkingLevel(level, availableLevels) {
     if (availableLevels.includes(level))
         return level;
-    const ordered = THINKING_LEVELS_WITH_XHIGH;
+    const ordered = ALL_THINKING_LEVELS;
     const available = new Set(availableLevels);
     const requestedIndex = ordered.indexOf(level);
     if (requestedIndex === -1) {

package/dist/app/settings-manager.d.ts

@@ -93,7 +93,7 @@ export interface Settings {
     lastChangelogVersion?: string;
     defaultProvider?: string;
     defaultModel?: string;
-    defaultThinkingLevel?: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+    defaultThinkingLevel?: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     transport?: TransportSetting;
     steeringMode?: 'all' | 'one-at-a-time';
     followUpMode?: 'all' | 'one-at-a-time';
@@ -220,8 +220,8 @@ export declare class SettingsManager {
     getFollowUpMode(): 'all' | 'one-at-a-time';
     getTheme(): string | undefined;
     setTheme(theme: string): void;
-    getDefaultThinkingLevel(): 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | undefined;
-    setDefaultThinkingLevel(level: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh'): void;
+    getDefaultThinkingLevel(): 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined;
+    setDefaultThinkingLevel(level: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'): void;
     getTransport(): TransportSetting;
     getRetryEnabled(): boolean;
     setRetryEnabled(enabled: boolean): void;

package/dist/app/shared/tools/execute-code/mog.d.ts

@@ -7,6 +7,8 @@
  */
 import { type CellEdit, type SheetEnginePool } from '@shortcut/mog-sandbox-runtime';
 import type { ToolDefinition } from '../../../../core/core-types.js';
+import { type ApprovalGate } from '../../../approvals/types.js';
+import type { ExcelApprovalPayload } from '../../../local/tools/execute-code/approval-payload.js';
 interface SheetExecResult {
     ok: boolean;
     output?: string;
@@ -20,6 +22,6 @@ declare const schema: import("@sinclair/typebox").TObject<{
     description: import("@sinclair/typebox").TString;
     code: import("@sinclair/typebox").TString;
 }>;
-export declare function createSheetExecTool(pool: SheetEnginePool): ToolDefinition<typeof schema, SheetExecResult>;
+export declare function createSheetExecTool(pool: SheetEnginePool, approval?: ApprovalGate<ExcelApprovalPayload>): ToolDefinition<typeof schema, SheetExecResult>;
 export {};
 //# sourceMappingURL=mog.d.ts.map