shortcutxl 0.3.76 → 0.3.77

package/dist/app/approvals/tool-approval.d.ts

@@ -10,6 +10,7 @@ import { type ApprovalChoice, type ApprovalGate, type ApprovalRequest } from './
 export declare function withPreApproval<T extends TSchema, D>(tool: ToolDefinition<T>, approval: ApprovalGate<D>, buildRequest: (params: Record<string, unknown>, ctx: ToolExecutionContext | undefined) => ApprovalRequest<D> | Promise<ApprovalRequest<D>>, options?: {
     alwaysPrompt?: boolean;
     isContentSafe?: (params: Record<string, unknown>, ctx: ToolExecutionContext | undefined) => boolean | Promise<boolean>;
+    isHeadlessApprovalAllowed?: (ctx: ToolExecutionContext | undefined) => boolean;
     onRequested?: (request: ApprovalRequest<D>) => void;
     onAccepted?: (request: ApprovalRequest<D>, choice: ApprovalChoice) => void;
     onRejected?: (request: ApprovalRequest<D>) => void;

package/dist/app/approvals/tool-approval.js

@@ -4,6 +4,7 @@
  * Wraps a ToolDefinition with a user-approval prompt before executing.
  */
 import { getApprovalSurface, resolveApprovalExecutionDecision } from '../permissions/approval-surface.js';
+import { APPROVAL_ERROR_CODE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, USER_REJECTED_APPROVAL_MESSAGE, createApprovalErrorResult } from './approval-errors.js';
 import { APPROVAL } from './types.js';
 /** Map an ApprovalChoice to a default summary message prepended to the tool result. */
 function defaultApprovalSummary(choice) {
@@ -12,10 +13,6 @@ function defaultApprovalSummary(choice) {
             return 'User approved this.';
         case APPROVAL.ACCEPT_ALL:
             return 'User enabled session auto-approve.';
-        case APPROVAL.RUN_FOREGROUND:
-            return 'User approved running this task in the foreground.';
-        case APPROVAL.RUN_BACKGROUND:
-            return 'User approved running this task in the background.';
         case APPROVAL.ALLOW_ONCE:
             return 'User allowed this once.';
         case APPROVAL.ALLOW_FILE:
@@ -35,7 +32,7 @@ function prependApprovalSummary(result, summary) {
 }
 /** Wrap a tool with a pre-execution approval gate that prompts when policy requires it. */
 export function withPreApproval(tool, approval, buildRequest, options = {}) {
-    const { alwaysPrompt, isContentSafe, onRequested, onAccepted, onRejected, isApprovedChoiceAllowed, describeApprovedChoice, applyApprovalContext } = options;
+    const { alwaysPrompt, isContentSafe, isHeadlessApprovalAllowed, onRequested, onAccepted, onRejected, isApprovedChoiceAllowed, describeApprovedChoice, applyApprovalContext } = options;
     return {
         name: tool.name,
         label: tool.label,
@@ -44,48 +41,39 @@ export function withPreApproval(tool, approval, buildRequest, options = {}) {
         isReadOnly: tool.isReadOnly,
         promptGuidelines: tool.promptGuidelines,
         async execute(toolCallId, params, signal, onUpdate, ctx) {
+            const extCtx = ctx;
             const safe = alwaysPrompt
                 ? false
                 : ((await isContentSafe?.(params, ctx)) ?? false);
-            const extCtx = ctx;
             const request = await buildRequest(params, ctx);
             const decision = resolveApprovalExecutionDecision({
                 surface: getApprovalSurface(extCtx),
                 isSafe: safe,
                 isAutoApproved: approval.isAutoApproved(),
                 alwaysRequireExplicitApproval: request.alwaysRequireExplicitApproval === true,
-                allowHeadlessApproval: ctx?.permissionPolicy?.approvals.allowHeadlessApproval ?? false
+                allowHeadlessApproval: isHeadlessApprovalAllowed?.(ctx) ??
+                    ctx?.permissionPolicy?.approvals.allowHeadlessApproval ??
+                    false
             });
             if (decision === 'deny') {
-                return {
-                    content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                    details: undefined
-                };
+                onRejected?.(request);
+                return createApprovalErrorResult(APPROVAL_ERROR_CODE.INTERACTIVE_APPROVAL_UNAVAILABLE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, request.kind, tool.name);
             }
             if (decision === 'prompt') {
                 if (!extCtx) {
                     onRejected?.(request);
-                    return {
-                        content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                        details: undefined
-                    };
+                    return createApprovalErrorResult(APPROVAL_ERROR_CODE.INTERACTIVE_APPROVAL_UNAVAILABLE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, request.kind, tool.name);
                 }
                 onRequested?.(request);
                 const choice = await approval.requestApproval(request, extCtx);
                 if (choice === APPROVAL.REJECT || choice === undefined) {
                     onRejected?.(request);
-                    return {
-                        content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                        details: undefined
-                    };
+                    return createApprovalErrorResult(APPROVAL_ERROR_CODE.USER_REJECTED, USER_REJECTED_APPROVAL_MESSAGE, request.kind, tool.name);
                 }
                 const allowedChoice = (await isApprovedChoiceAllowed?.(request, choice)) ?? true;
                 if (!allowedChoice) {
                     onRejected?.(request);
-                    return {
-                        content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                        details: undefined
-                    };
+                    return createApprovalErrorResult(APPROVAL_ERROR_CODE.USER_REJECTED, USER_REJECTED_APPROVAL_MESSAGE, request.kind, tool.name);
                 }
                 onAccepted?.(request, choice);
                 if (choice === APPROVAL.ACCEPT_ALL) {

package/dist/app/approvals/types.d.ts

@@ -9,8 +9,6 @@ import type { ExtensionContext } from '../extensions/index.js';
 export declare const APPROVAL: {
     readonly ACCEPT: "Accept";
     readonly ACCEPT_ALL: "Accept All";
-    readonly RUN_FOREGROUND: "Run foreground";
-    readonly RUN_BACKGROUND: "Run background";
     readonly ALLOW_ONCE: "Allow Once";
     readonly ALLOW_FILE: "Always Allow File";
     readonly ALLOW_FOLDER: "Always Allow Folder";
@@ -61,18 +59,6 @@ export interface BashApprovalData {
         reason: string;
     }>;
 }
-export interface TaskSpawnApprovalData {
-    subagentType: string;
-    name: string;
-    query: string;
-    model?: string;
-    /** Task spawn approval is all-or-nothing: approved children run as full workers. */
-    fullWorker: true;
-    /** True when this subagent can recursively spawn more full-worker children. */
-    canSpawnSubagents: boolean;
-    /** Launch mode requested by the tool call before user approval overrides. */
-    requestedRunInBackground: boolean;
-}
 export interface SwitchModeApprovalData {
     currentMode: string;
     targetMode: string;

package/dist/app/approvals/types.js

@@ -8,8 +8,6 @@
 export const APPROVAL = {
     ACCEPT: 'Accept',
     ACCEPT_ALL: 'Accept All',
-    RUN_FOREGROUND: 'Run foreground',
-    RUN_BACKGROUND: 'Run background',
     ALLOW_ONCE: 'Allow Once',
     ALLOW_FILE: 'Always Allow File',
     ALLOW_FOLDER: 'Always Allow Folder',

package/dist/app/background/tool-summaries.js

@@ -35,8 +35,6 @@ export async function generateToolSummaryDetailed(input, shortcutLlmProxy, optio
                 { role: 'human', content: userContent }
             ],
             max_output_tokens: maxOutputTokens,
-            effort_level: 'low',
-            thinking_type: 'off',
             llmOperation: 'summarize'
         }, {
             signal

package/dist/app/local/tools/execute-code/executor.d.ts

@@ -23,7 +23,7 @@ export interface ComExecResult {
     cfTxId?: string;
     editMode?: boolean;
 }
-export type ApprovalOutcome = 'accepted' | 'failed' | 'reverted' | 'revert-failed' | 'rejected';
+export type ApprovalOutcome = 'accepted' | 'approval-unavailable' | 'failed' | 'reverted' | 'revert-failed' | 'rejected';
 export interface LocalExecResult {
     result: ComExecResult;
     outcome: ApprovalOutcome;

package/dist/app/local/tools/execute-code/executor.js

@@ -10,6 +10,7 @@
  * - `createExcelExecTool()` (COM ToolDefinition wrapper)
  */
 import { log } from '../../../../shared/logging/agent-log.js';
+import { INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE } from '../../../approvals/approval-errors.js';
 import { APPROVAL } from '../../../approvals/types.js';
 import { getApprovalSurface, resolveApprovalExecutionDecision } from '../../../permissions/approval-surface.js';
 import { getEffectiveExcelHttpUrl } from '../../../xll/endpoint.js';
@@ -60,7 +61,7 @@ function isDangerousExcelLifecycleBypassed(ctx) {
 }
 async function requestAlwaysConfirmApproval(approval, ctx, description, dangerousOperations, observability) {
     if (isDangerousExcelLifecycleBypassed(ctx)) {
-        return APPROVAL.ACCEPT;
+        return { choice: APPROVAL.ACCEPT, unavailable: false };
     }
     const request = {
         kind: 'execute_code',
@@ -85,16 +86,16 @@ async function requestAlwaysConfirmApproval(approval, ctx, description, dangerou
     });
     if (decision !== 'prompt' || !approval || !ctx) {
         observability?.onRejected?.(request);
-        return APPROVAL.REJECT;
+        return { choice: APPROVAL.REJECT, unavailable: decision === 'deny' };
     }
     observability?.onRequested?.(request);
     const choice = await approval.requestApproval(request, ctx);
     if (choice === APPROVAL.REJECT || choice === undefined) {
         observability?.onRejected?.(request);
-        return choice;
+        return { choice, unavailable: false };
     }
     observability?.onAccepted?.(request, choice);
-    return choice;
+    return { choice, unavailable: false };
 }
 // ---------------------------------------------------------------------------
 // Approval resolution
@@ -146,7 +147,7 @@ export async function resolveApproval(result, approval, postControl, ctx, descri
                 try {
                     await postControl({ control: CONTROL.REVERT, cfTxId });
                     observability?.onReverted?.(request);
-                    return { outcome: 'reverted' };
+                    return { outcome: 'rejected' };
                 }
                 catch {
                     if (cfTxId != null) {
@@ -239,11 +240,17 @@ export async function executeComLocally(excelHttpUrl, code, options) {
     const analysis = analyzeComWriteCode(code);
     const dangerousLifecycleBypassed = analysis.alwaysRequireApproval && isDangerousExcelLifecycleBypassed(ctx);
     if (analysis.alwaysRequireApproval) {
-        const choice = await requestAlwaysConfirmApproval(approval, ctx, description, analysis.dangerousOperations, observability);
+        const approvalResult = await requestAlwaysConfirmApproval(approval, ctx, description, analysis.dangerousOperations, observability);
+        const { choice } = approvalResult;
         if (choice !== APPROVAL.ACCEPT && choice !== APPROVAL.ACCEPT_ALL) {
             return {
-                result: { ok: true, output: 'Excel operation rejected by user.' },
-                outcome: 'rejected'
+                result: {
+                    ok: true,
+                    output: approvalResult.unavailable
+                        ? INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE
+                        : 'Excel operation rejected by user.'
+                },
+                outcome: approvalResult.unavailable ? 'approval-unavailable' : 'rejected'
             };
         }
         if (choice === APPROVAL.ACCEPT_ALL) {
@@ -264,8 +271,11 @@ export async function executeComLocally(excelHttpUrl, code, options) {
         });
     if (executionDecision === 'deny') {
         return {
-            result: { ok: true, output: 'Excel operation rejected by user.' },
-            outcome: 'rejected'
+            result: {
+                ok: true,
+                output: INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE
+            },
+            outcome: 'approval-unavailable'
         };
     }
     let result = await sendExecRequest();

package/dist/app/local/tools/execute-code/tool.js

@@ -8,6 +8,7 @@
 import { Type } from '@sinclair/typebox';
 import { EXECUTE_CODE } from '../../../../tool-names.js';
 import { truncateOutput } from '../../../../utils/truncate.js';
+import { APPROVAL_ERROR_CODE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, USER_REJECTED_APPROVAL_MESSAGE } from '../../../approvals/approval-errors.js';
 import { buildLocalExcelHttpUrl, parseExcelHttpPort } from '../../../xll/http-url.js';
 import { executeComLocally } from './executor.js';
 const TOOL_NAME = EXECUTE_CODE;
@@ -90,8 +91,26 @@ export function createExcelExecTool(httpPort, approval, observability) {
             }
             if (outcome === 'rejected') {
                 return {
-                    content: [{ type: 'text', text: 'Excel operation rejected by user.' }],
-                    details: result
+                    content: [{ type: 'text', text: USER_REJECTED_APPROVAL_MESSAGE }],
+                    details: {
+                        ...result,
+                        code: APPROVAL_ERROR_CODE.USER_REJECTED,
+                        approvalKind: EXECUTE_CODE,
+                        toolName: EXECUTE_CODE
+                    },
+                    isError: true
+                };
+            }
+            if (outcome === 'approval-unavailable') {
+                return {
+                    content: [{ type: 'text', text: INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE }],
+                    details: {
+                        ...result,
+                        code: APPROVAL_ERROR_CODE.INTERACTIVE_APPROVAL_UNAVAILABLE,
+                        approvalKind: EXECUTE_CODE,
+                        toolName: EXECUTE_CODE
+                    },
+                    isError: true
                 };
             }
             if (outcome === 'failed' || !result.ok) {

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/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';
@@ -112,7 +112,7 @@ 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, WRITING_CODE, DATA_FORMATTING, engine.apiGuidelines);
 }
 /** Append read-only shared guidelines + engine API reference to a sections array. */
 export function pushReadOnlySharedGuidelines(sections, engine) {

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'];
     }>;