shortcutxl 0.3.76 → 0.3.78

package/dist/app/modes/plan/agent.js

@@ -4,13 +4,10 @@
  * Explores the workbook, asks clarifying questions, and produces an
  * implementation plan before switching to action mode for execution.
  */
-import { MODE } from '../../../mode-names.js';
-import { BASH, EXECUTE_CODE, EXECUTE_TOOL, FIND, GET_TOOL_INFO, GREP, LLM_ANALYSIS, LS, MCP_TOOL_NAMES, PLAN_SWITCH_MODE, READ, TAKE_SCREENSHOT } from '../../../tool-names.js';
+import { EXECUTE_CODE, EXECUTE_TOOL, FIND, GET_TOOL_INFO, GREP, LLM_ANALYSIS, LS, MCP_TOOL_NAMES, PLAN_SWITCH_MODE, READ, TAKE_SCREENSHOT } from '../../../tool-names.js';
+import { PLAN_MODE_METADATA } from '../metadata.js';
 import { buildPlanPrompt } from './prompt.js';
-const DESCRIPTION = `\
-Read-only planning mode for exploration, clarifying requirements and drafting an implementation plan.`;
 const TOOLS = [
-    BASH,
     EXECUTE_CODE,
     READ,
     GREP,
@@ -25,11 +22,11 @@ const TOOLS = [
 ];
 export function planAgent() {
     return {
-        name: MODE.PLAN,
-        description: DESCRIPTION,
+        name: PLAN_MODE_METADATA.name,
+        description: PLAN_MODE_METADATA.description,
         systemPrompt: buildPlanPrompt(),
         tools: TOOLS,
-        switchTo: [MODE.ACTION]
+        switchTo: PLAN_MODE_METADATA.switchTo
     };
 }
 //# sourceMappingURL=agent.js.map

package/dist/app/modes/plan/prompt.js

@@ -37,7 +37,7 @@ ${engine.execTool}
 1. Gauge user experience: If unclear from their query, ASK about their spreadsheet familiarity first - then adapt all explanations accordingly (beginners need more context, experts want concise trade-offs)
 2. After exploration: State (1) task understanding (MAX 3-4 lines), (2) list ALL open questions upfront with a brief description of each (e.g., "I need to clarify 3 things: 1) how to handle missing data, 2) whether to use formulas or static values, 3) where to place output"), (3) first question
 3. ONE question per response. Before each question, state which open items remain (e.g., "Still need to resolve: output location, formula vs static values."). If a user's answer resolves multiple items, acknowledge that and move on. Do NOT re-count or renumber — just reference the open items by topic.
-4. Write the final plan as markdown to a file under /tmp, then call switch_from_plan_mode(mode: "action", documentPath: "<that file path>").
+4. Pass the final plan directly to switch_from_plan_mode(mode: "action", reason: "<the full plan>").
 5. If plan rejected: Restart question cycle to understand needed changes
 
 **Critical Rules:**
@@ -66,7 +66,7 @@ Structure:
 - **[Bold question]?**
 
 **Final Plan Format:**
-Write the full plan as markdown to a file under /tmp. Then call switch_from_plan_mode(mode: "action", documentPath: "<that file path>").
+Pass the full plan as markdown directly in the reason argument to switch_from_plan_mode(mode: "action", reason: "<the full plan>").
 
 \`\`\`
 Task: [One sentence]
@@ -83,7 +83,7 @@ Things to Watch Out For:
 - [Key considerations and edge cases]
 \`\`\`
 
-MUST call switch_from_plan_mode(mode: "action", documentPath: "<that file path>") - do NOT output plan directly.
+MUST call switch_from_plan_mode(mode: "action", reason: "<the full plan>") - do NOT output plan directly.
 `;
 // ---------------------------------------------------------------------------
 // Assembly

package/dist/app/permissions/runtime-approval-flow.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ToolExecutionContext } from '../../core/core-types.js';
 import type { RuntimeFilesystemPermissionPolicy, RuntimeShellPermissionPolicy } from '../../core/permission-policy.js';
-import { type ApprovalChoice, type ApprovalRequest, type BashApprovalData, type FileAccessApprovalData, type TaskSpawnApprovalData } from '../approvals/types.js';
+import { type ApprovalChoice, type ApprovalRequest, type BashApprovalData, type FileAccessApprovalData } from '../approvals/types.js';
 import type { SettingsManager } from '../settings-manager.js';
 type RiskyShellOperationRule = {
     label: string;
@@ -26,13 +26,9 @@ export declare function isFilesystemInvocationSafe(absolutePath: string, access:
 export declare function applyFilesystemApprovalChoice(choice: ApprovalChoice, request: ApprovalRequest<FileAccessApprovalData>, access: 'read' | 'write', settingsManager: SettingsManager, ctx: ToolExecutionContext | undefined): ToolExecutionContext | undefined;
 /** Build the approval request payload for a shell command. */
 export declare function buildShellApprovalRequest(params: Record<string, unknown>, toolName: string): ApprovalRequest<BashApprovalData>;
-/** Build the approval request payload for a task subagent spawn. */
-export declare function buildTaskSpawnApprovalRequest(payload: TaskSpawnApprovalData): ApprovalRequest<TaskSpawnApprovalData>;
 /** Check whether the shell policy allows invocations without prompting. */
 export declare function isShellInvocationSafe(policy: RuntimeShellPermissionPolicy | undefined, command?: string): boolean;
 /** Record an approved shell command on the tool execution context. */
 export declare function applyShellApprovalChoice(ctx: ToolExecutionContext | undefined, params: Record<string, unknown>): ToolExecutionContext | undefined;
-/** Translate a task-spawn approval choice into a one-shot subagent spawn grant. */
-export declare function applyTaskSpawnApprovalChoice(ctx: ToolExecutionContext | undefined, request: ApprovalRequest<TaskSpawnApprovalData>, choice?: ApprovalChoice): ToolExecutionContext | undefined;
 export {};
 //# sourceMappingURL=runtime-approval-flow.d.ts.map

package/dist/app/permissions/runtime-approval-flow.js

@@ -133,16 +133,6 @@ export function buildShellApprovalRequest(params, toolName) {
         }
     };
 }
-/** Build the approval request payload for a task subagent spawn. */
-export function buildTaskSpawnApprovalRequest(payload) {
-    return {
-        kind: 'task',
-        title: 'Review subagent spawn',
-        choices: [APPROVAL.RUN_FOREGROUND, APPROVAL.RUN_BACKGROUND, APPROVAL.REJECT],
-        alwaysRequireExplicitApproval: true,
-        payload
-    };
-}
 /** Check whether the shell policy allows invocations without prompting. */
 export function isShellInvocationSafe(policy, command) {
     if (command !== undefined && hasRiskyShellOperation(command)) {
@@ -160,22 +150,4 @@ export function applyShellApprovalChoice(ctx, params) {
         }
     };
 }
-/** Translate a task-spawn approval choice into a one-shot subagent spawn grant. */
-export function applyTaskSpawnApprovalChoice(ctx, request, choice = APPROVAL.ACCEPT) {
-    const runInBackground = choice === APPROVAL.RUN_BACKGROUND
-        ? true
-        : choice === APPROVAL.RUN_FOREGROUND
-            ? false
-            : request.payload.requestedRunInBackground;
-    return {
-        ...ctx,
-        // Task spawn approval is a one-shot child launch authorization. Approved
-        // spawns become full-worker child sessions; the approval does not create a
-        // reusable grant for later task calls.
-        subagentSpawnGrant: {
-            fullWorker: true,
-            runInBackground
-        }
-    };
-}
 //# sourceMappingURL=runtime-approval-flow.js.map

package/dist/app/permissions/tool-gates.d.ts

@@ -1,7 +1,7 @@
 /** Central permission gate for deciding which runtime tool actions require approval. */
 import type { ToolDefinition } from '../../core/core-types.js';
 import { BASH, EDIT, EXECUTE_CODE, FIND, GREP, LS, READ, TASK, WRITE } from '../../tool-names.js';
-import { type ApprovalGate, type BashApprovalData, type FileAccessApprovalData, type TaskSpawnApprovalData } from '../approvals/types.js';
+import { type ApprovalGate, type BashApprovalData, type FileAccessApprovalData } from '../approvals/types.js';
 import type { ShortcutClientLogger } from '../observability/client-logging/client-logger.js';
 import type { SettingsManager } from '../settings-manager.js';
 export type PermissionedRuntimeToolName = typeof READ | typeof WRITE | typeof EDIT | typeof LS | typeof FIND | typeof GREP | typeof BASH | typeof EXECUTE_CODE | typeof TASK;
@@ -43,7 +43,7 @@ export declare const TOOL_GATES: {
         readonly kind: "self-gated";
     };
     readonly task: {
-        readonly kind: "task";
+        readonly kind: "passthrough";
     };
 };
 export declare const PERMISSIONED_RUNTIME_TOOL_NAMES: PermissionedRuntimeToolName[];
@@ -53,7 +53,6 @@ export interface RegisterRuntimeToolDeps {
     settingsManager?: SettingsManager;
     filesystemApproval?: ApprovalGate<FileAccessApprovalData>;
     shellApproval?: ApprovalGate<BashApprovalData>;
-    taskApproval?: ApprovalGate<TaskSpawnApprovalData>;
     observability?: Pick<ShortcutClientLogger, 'info' | 'warn' | 'error'>;
 }
 /** Register a runtime tool with the appropriate permission/approval wrapper. */

package/dist/app/permissions/tool-gates.js

@@ -2,10 +2,8 @@ import { resolveReadPath, resolveToCwd } from '../../shared/files/path-utils.js'
 import { BASH, EDIT, EXECUTE_CODE, FIND, GREP, LS, READ, TASK, WRITE } from '../../tool-names.js';
 import { withPreApproval } from '../approvals/tool-approval.js';
 import { APPROVAL } from '../approvals/types.js';
-import { getSubagent } from '../subagents/index.js';
-import { readTaskQueryFile, resolveTaskQuery } from '../tools/task/query.js';
 import { requirePermissionPolicy } from './require-policy.js';
-import { applyFilesystemApprovalChoice, applyShellApprovalChoice, applyTaskSpawnApprovalChoice, buildFilesystemApprovalRequest, buildShellApprovalRequest, buildTaskSpawnApprovalRequest, describeFilesystemApprovalChoice, isFilesystemInvocationSafe, isShellInvocationSafe } from './runtime-approval-flow.js';
+import { applyFilesystemApprovalChoice, applyShellApprovalChoice, buildFilesystemApprovalRequest, buildShellApprovalRequest, describeFilesystemApprovalChoice, isFilesystemInvocationSafe, isShellInvocationSafe } from './runtime-approval-flow.js';
 export const TOOL_GATES = {
     [READ]: {
         kind: 'filesystem',
@@ -39,7 +37,7 @@ export const TOOL_GATES = {
     },
     [BASH]: { kind: 'shell' },
     [EXECUTE_CODE]: { kind: 'self-gated' },
-    [TASK]: { kind: 'task' }
+    [TASK]: { kind: 'passthrough' }
 };
 export const PERMISSIONED_RUNTIME_TOOL_NAMES = Object.keys(TOOL_GATES);
 /** Type guard: check whether a tool name has a registered permission gate. */
@@ -175,80 +173,6 @@ function wrapShellTool(tool, deps) {
         applyApprovalContext: async (ctx, params) => applyShellApprovalChoice(ctx, params)
     });
 }
-/** Wrap the task tool with subagent-spawn approval and observability. */
-function wrapTaskTool(tool, deps) {
-    if (!deps.taskApproval) {
-        return tool;
-    }
-    return wrapToolWithAgentApproval(tool, {
-        approval: deps.taskApproval,
-        buildRequest: (params) => {
-            const subagentType = String(params.subagent_type ?? '');
-            const subagent = getSubagent(subagentType);
-            let query;
-            if (typeof params.query_file === 'string' && params.query_file.trim().length > 0) {
-                try {
-                    query = readTaskQueryFile(params.query_file);
-                }
-                catch {
-                    query = params.query_file;
-                }
-            }
-            else {
-                query = resolveTaskQuery(String(params.query ?? ''));
-            }
-            return buildTaskSpawnApprovalRequest({
-                subagentType: String(params.subagent_type ?? ''),
-                name: String(params.name ?? ''),
-                query,
-                model: typeof params.model === 'string' ? params.model : undefined,
-                fullWorker: true,
-                canSpawnSubagents: subagent?.tools.includes(TASK) === true,
-                requestedRunInBackground: params.run_in_background === true
-            });
-        },
-        isContentSafe: (_params, ctx) => requirePermissionPolicy(ctx, tool.name).dangerouslySkipRuntimePermissions === true,
-        onRequested: (request) => {
-            deps.observability?.info({
-                module: 'tool',
-                event: 'tool_approval_requested',
-                data: {
-                    tool_name: tool.name,
-                    approval_kind: 'subagent_spawn',
-                    subagent_type: request.payload.subagentType
-                }
-            });
-        },
-        onAccepted: (request, choice) => {
-            deps.observability?.info({
-                module: 'tool',
-                event: 'tool_approval_accepted',
-                data: {
-                    tool_name: tool.name,
-                    approval_kind: 'subagent_spawn',
-                    accept_all: choice === APPROVAL.ACCEPT_ALL,
-                    subagent_type: request.payload.subagentType
-                }
-            });
-        },
-        onRejected: (request) => {
-            deps.observability?.warn({
-                module: 'tool',
-                event: 'tool_approval_rejected',
-                data: {
-                    tool_name: tool.name,
-                    approval_kind: 'subagent_spawn',
-                    subagent_type: request.payload.subagentType
-                }
-            });
-        },
-        isApprovedChoiceAllowed: (_request, choice) => choice === APPROVAL.ACCEPT ||
-            choice === APPROVAL.RUN_FOREGROUND ||
-            choice === APPROVAL.RUN_BACKGROUND,
-        describeApprovedChoice: (request) => `User approved subagent spawn: ${request.payload.name} [${request.payload.subagentType}]`,
-        applyApprovalContext: async (ctx, _params, request, choice) => applyTaskSpawnApprovalChoice(ctx, request, choice)
-    });
-}
 /** Register a runtime tool with the appropriate permission/approval wrapper. */
 export function registerRuntimeTool(tools, tool, deps) {
     if (!isPermissionedRuntimeToolName(tool.name)) {
@@ -263,10 +187,8 @@ export function registerRuntimeTool(tools, tool, deps) {
         case 'shell':
             tools.push(wrapShellTool(permissionedTool, deps));
             return;
-        case 'task':
-            tools.push(wrapTaskTool(permissionedTool, deps));
-            return;
         case 'self-gated':
+        case 'passthrough':
             tools.push(permissionedTool);
     }
 }

package/dist/app/prompts/com-api.js

@@ -52,7 +52,7 @@ Multiple agents may operate on the same Excel instance concurrently. Follow thes
 
 ### Guidelines
 - Use wb.getWorkbookSummary() to get sheet names and used ranges for a workbook before deeper reads
-- Use wrappers over raw COM when wrappers are available, and use COM for everything else
+- Use wrapper methods for cell writes so their exact destination ranges are tracked; raw COM writes execute but do not produce cell diffs. Use COM when no wrapper exists
 - NEVER use Sheet.Copy — it silently creates new workbooks via pywin32. Use range.Copy for data transfer
 - NEVER use Sheet.Move with keyword args (After=x, Before=x) — pywin32 bug creates new workbooks. Use wb.moveSheet(name, index) instead
 - Watch out for indexing: COM collections are 1-based (ws.Cells(1,1) is A1), but Python tuples are 0-based

package/dist/app/prompts/shared-guidelines.js

@@ -8,7 +8,7 @@ import { homedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
 import { CONFIG_DIR_NAME, getAgentDir, getBundledSkillsDir, isNewSheetEnabled } from '../../config.js';
 import { RuntimeSkillSource } from '../../contracts/agent-resources.js';
-import { AGENT_PHILOSOPHY, COMMUNICATION, DATA_FORMATTING, TASK_EXECUTION, WRITING_CODE } from '../../core/prompts/agent-guidelines.js';
+import { COMMUNICATION, DATA_FORMATTING, TASK_EXECUTION, WRITING_CODE } from '../../core/prompts/agent-guidelines.js';
 import { buildMogHeadlessApiReferenceSection } from '../../utils/mog-headless-api-reference.js';
 import { inferExternalSkillProviderFromPath } from '../resources/external-skill-roots.js';
 import { loadSkills } from '../resources/skills.js';
@@ -31,6 +31,10 @@ const COM_RUNTIME_TROUBLESHOOTING = `## Debugging HTTP server health
 - if a single Excel process is running and execute_code fails, it could be due to pop-up blockage. Confirm and debug however you can and then stop. Don't do anything fancy, just tell the user that nothing can proceed until popups are gone
 - if that did not work, we need to close the excel process and restart it. Ask the user to save work, close Excel, and then re-open
 - always wait ~2 seconds to health check`;
+const LOCAL_FILE_LINKS = `
+- Markdown file links will be rendered such that the user can click and open the file in their OS.
+- For auditability, you MUST ALWAYS expose local filesystem changes to the user using Markdown links whose destination is the canonical absolute file URL. 
+- Keep the visible label concise while preserving the full path in the destination.`;
 /**
  * Return the correct engine prompts for the given engine.
  *
@@ -112,10 +116,10 @@ export function buildCurrentSkillsSection(options = {}) {
 // ---------------------------------------------------------------------------
 /** Append action-mode shared guidelines + engine API reference to a sections array. */
 export function pushActionSharedGuidelines(sections, engine) {
-    sections.push(AGENT_PHILOSOPHY, TASK_EXECUTION, COMMUNICATION, WRITING_CODE, DATA_FORMATTING, engine.apiGuidelines);
+    sections.push(TASK_EXECUTION, COMMUNICATION, LOCAL_FILE_LINKS, WRITING_CODE, DATA_FORMATTING, engine.apiGuidelines);
 }
 /** Append read-only shared guidelines + engine API reference to a sections array. */
 export function pushReadOnlySharedGuidelines(sections, engine) {
-    sections.push(COMMUNICATION, engine.apiGuidelines);
+    sections.push(COMMUNICATION, LOCAL_FILE_LINKS, engine.apiGuidelines);
 }
 //# sourceMappingURL=shared-guidelines.js.map

package/dist/app/providers/google-vertex-gateway.js

@@ -15,15 +15,11 @@
  * bodies reuse the shared Google converters so the wire format cannot drift from
  * the built-in and embedded paths.
  */
-import { convertMessages, convertTools, mapStopReasonString } from '../../ai/providers/google-shared.js';
+import { mapStopReasonString } from '../../ai/providers/google-shared.js';
+import { buildGoogleVertexRequest, googleVertexGatewayEndpoint } from '../../ai/providers/google-vertex.js';
 import { AssistantMessageEventStream } from '../../ai/utils/event-stream.js';
 import { isContextOverflowErrorMessage } from '../../ai/utils/overflow.js';
-import { sanitizeSurrogates } from '../../ai/utils/sanitize-unicode.js';
 import { extractStructuredHttpErrorPayload, LLMErrorMetadataHeaders, parseStreamErrorPayload, safeModelStreamErrorMessage } from '../../contracts/model-stream.js';
-// The gateway fronts Vertex with a fixed project/location; the CLI never needs
-// real GCP project credentials. Mirrors the embedded transport's constants.
-const GATEWAY_PROJECT = '-';
-const GATEWAY_LOCATION = 'global';
 class GoogleGatewayHttpError extends Error {
     details;
     constructor(details) {
@@ -43,49 +39,6 @@ function emptyUsage() {
         totalTokens: 0
     };
 }
-function normalizeBaseUrl(baseUrl) {
-    return baseUrl.replace(/\/+$/, '');
-}
-function gatewayEndpoint(baseUrl, modelId) {
-    const model = encodeURIComponent(modelId);
-    return (`${normalizeBaseUrl(baseUrl)}/v1/projects/${GATEWAY_PROJECT}` +
-        `/locations/${GATEWAY_LOCATION}/publishers/google/models/${model}:streamGenerateContent?alt=sse`);
-}
-function mapThinkingLevel(reasoning) {
-    switch (reasoning) {
-        case 'minimal':
-            return 'MINIMAL';
-        case 'low':
-            return 'LOW';
-        case 'medium':
-            return 'MEDIUM';
-        case 'high':
-        case 'xhigh':
-            return 'HIGH';
-        default:
-            return undefined;
-    }
-}
-function buildRequestBody(model, context, options) {
-    const generationConfig = {};
-    if (options?.maxTokens !== undefined)
-        generationConfig.maxOutputTokens = options.maxTokens;
-    if (options?.temperature !== undefined)
-        generationConfig.temperature = options.temperature;
-    const thinkingLevel = model.reasoning ? mapThinkingLevel(options?.reasoning) : undefined;
-    if (thinkingLevel) {
-        generationConfig.thinkingConfig = { includeThoughts: true, thinkingLevel };
-    }
-    const tools = context.tools?.length ? convertTools(context.tools) : undefined;
-    return {
-        contents: convertMessages(model, context),
-        ...(context.systemPrompt
-            ? { systemInstruction: { parts: [{ text: sanitizeSurrogates(context.systemPrompt) }] } }
-            : {}),
-        ...(tools ? { tools } : {}),
-        ...(Object.keys(generationConfig).length > 0 ? { generationConfig } : {})
-    };
-}
 /** Parse Vertex SSE frames into decoded JSON payloads. */
 async function* sseEvents(response) {
     const parseFrame = (frame) => {
@@ -194,10 +147,10 @@ export function streamSimpleGoogleVertexGateway(model, context, options) {
         let textIndex;
         let stopReason = 'stop';
         try {
-            const response = await (options?.fetch ?? fetch)(gatewayEndpoint(model.baseUrl, model.id), {
+            const response = await (options?.fetch ?? fetch)(`${googleVertexGatewayEndpoint(model.baseUrl, model.id, 'streamGenerateContent')}?alt=sse`, {
                 method: 'POST',
                 headers: { 'content-type': 'application/json', ...options?.headers },
-                body: JSON.stringify(buildRequestBody(model, context, options)),
+                body: JSON.stringify(buildGoogleVertexRequest(model, context, options)),
                 signal: options?.signal
             });
             if (!response.ok) {

package/dist/app/providers/model-registry.d.ts

@@ -107,6 +107,7 @@ export interface ProviderConfigInput {
         };
         contextWindow: number;
         maxTokens: number;
+        capabilities?: Model<Api>['capabilities'];
         headers?: Record<string, string>;
         compat?: Model<Api>['compat'];
     }>;

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';
@@ -58,6 +58,9 @@ function createShortcutApiV2AttributionHeaders(options) {
     };
     const userMessageId = headerValue(attribution?.userMessageId);
     const continuationRunId = headerValue(attribution?.continuationRunId) ?? userMessageId;
+    const sessionId = headerValue(attribution?.sessionId);
+    if (sessionId)
+        headers['X-Session-Id'] = sessionId;
     if (continuationRunId)
         headers['X-Agent-Run-Id'] = continuationRunId;
     if (userMessageId)
@@ -116,11 +119,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({
@@ -143,6 +142,7 @@ export function createShortcutApiV2Dispatcher(getExtraHeaders) {
 export function registerShortcutProvider(modelRegistry, apiV2Url, options) {
     const getExtraHeaders = () => ({
         'X-Client-Platform': 'shortcutxl',
+        'X-Client-Version': VERSION,
         // Override the provider SDK's default User-Agent (e.g. "Anthropic/JS <ver>").
         // The api-v2 gateway's WAF blocks provider-SDK user-agents to prevent the
         // gateway being used as a raw upstream proxy, which otherwise surfaces to

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,