@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/tools/languageModelToolsConfirmationService.js

@@ -13,8 +13,8 @@ import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 
-const RUN_WITHOUT_APPROVAL = ( localize(5820, "without approval"));
-const CONTINUE_WITHOUT_REVIEWING_RESULTS = ( localize(5821, "without reviewing result"));
+const RUN_WITHOUT_APPROVAL = ( localize(6408, "without approval"));
+const CONTINUE_WITHOUT_REVIEWING_RESULTS = ( localize(6409, "without reviewing result"));
 class GenericConfirmStore extends Disposable {
     constructor(_storageKey, _instantiationService) {
         super();
@@ -213,23 +213,26 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
             return actions;
         }
         actions.push({
-            label: ( localize(5822, "Allow in this Session")),
-            detail: ( localize(5823, "Allow this tool to run in this session without confirmation.")),
+            label: ( localize(6410, "Allow in this Session")),
+            detail: ( localize(6411, "Allow this tool to run in this session without confirmation.")),
             divider: !!actions.length,
+            scope: "session",
             select: async () => {
                 this._preExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, "session");
                 return true;
             }
         }, {
-            label: ( localize(5824, "Allow in this Workspace")),
-            detail: ( localize(5825, "Allow this tool to run in this workspace without confirmation.")),
+            label: ( localize(6412, "Allow in this Workspace")),
+            detail: ( localize(6413, "Allow this tool to run in this workspace without confirmation.")),
+            scope: "workspace",
             select: async () => {
                 this._preExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, "workspace");
                 return true;
             }
         }, {
-            label: ( localize(5826, "Always Allow")),
-            detail: ( localize(5827, "Always allow this tool to run without confirmation.")),
+            label: ( localize(6414, "Always Allow")),
+            detail: ( localize(6415, "Always allow this tool to run without confirmation.")),
+            scope: "profile",
             select: async () => {
                 this._preExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, "profile");
                 return true;
@@ -241,32 +244,35 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
                 definitionId
             } = ref.source;
             actions.push({
-                label: ( localize(5828, "Allow Tools from {0} in this Session", serverLabel)),
+                label: ( localize(6416, "Allow Tools from {0} in this Session", serverLabel)),
                 detail: ( localize(
-                    5829,
+                    6417,
                     "Allow all tools from this server to run in this session without confirmation."
                 )),
                 divider: true,
+                scope: "session",
                 select: async () => {
                     this._preExecutionServerConfirmStore.setAutoConfirmation(definitionId, "session");
                     return true;
                 }
             }, {
-                label: ( localize(5830, "Allow Tools from {0} in this Workspace", serverLabel)),
+                label: ( localize(6418, "Allow Tools from {0} in this Workspace", serverLabel)),
                 detail: ( localize(
-                    5831,
+                    6419,
                     "Allow all tools from this server to run in this workspace without confirmation."
                 )),
+                scope: "workspace",
                 select: async () => {
                     this._preExecutionServerConfirmStore.setAutoConfirmation(definitionId, "workspace");
                     return true;
                 }
             }, {
-                label: ( localize(5832, "Always Allow Tools from {0}", serverLabel)),
+                label: ( localize(6420, "Always Allow Tools from {0}", serverLabel)),
                 detail: ( localize(
-                    5833,
+                    6421,
                     "Always allow all tools from this server to run without confirmation."
                 )),
+                scope: "profile",
                 select: async () => {
                     this._preExecutionServerConfirmStore.setAutoConfirmation(definitionId, "profile");
                     return true;
@@ -285,32 +291,35 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
             return actions;
         }
         actions.push({
-            label: ( localize(5834, "Allow Without Review in this Session")),
+            label: ( localize(6422, "Allow Without Review in this Session")),
             detail: ( localize(
-                5835,
+                6423,
                 "Allow results from this tool to be sent without confirmation in this session."
             )),
             divider: !!actions.length,
+            scope: "session",
             select: async () => {
                 this._postExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, "session");
                 return true;
             }
         }, {
-            label: ( localize(5836, "Allow Without Review in this Workspace")),
+            label: ( localize(6424, "Allow Without Review in this Workspace")),
             detail: ( localize(
-                5837,
+                6425,
                 "Allow results from this tool to be sent without confirmation in this workspace."
             )),
+            scope: "workspace",
             select: async () => {
                 this._postExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, "workspace");
                 return true;
             }
         }, {
-            label: ( localize(5838, "Always Allow Without Review")),
+            label: ( localize(6426, "Always Allow Without Review")),
             detail: ( localize(
-                5839,
+                6427,
                 "Always allow results from this tool to be sent without confirmation."
             )),
+            scope: "profile",
             select: async () => {
                 this._postExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, "profile");
                 return true;
@@ -322,32 +331,35 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
                 definitionId
             } = ref.source;
             actions.push({
-                label: ( localize(5840, "Allow Tools from {0} Without Review in this Session", serverLabel)),
+                label: ( localize(6428, "Allow Tools from {0} Without Review in this Session", serverLabel)),
                 detail: ( localize(
-                    5841,
+                    6429,
                     "Allow results from all tools from this server to be sent without confirmation in this session."
                 )),
                 divider: true,
+                scope: "session",
                 select: async () => {
                     this._postExecutionServerConfirmStore.setAutoConfirmation(definitionId, "session");
                     return true;
                 }
             }, {
-                label: ( localize(5842, "Allow Tools from {0} Without Review in this Workspace", serverLabel)),
+                label: ( localize(6430, "Allow Tools from {0} Without Review in this Workspace", serverLabel)),
                 detail: ( localize(
-                    5843,
+                    6431,
                     "Allow results from all tools from this server to be sent without confirmation in this workspace."
                 )),
+                scope: "workspace",
                 select: async () => {
                     this._postExecutionServerConfirmStore.setAutoConfirmation(definitionId, "workspace");
                     return true;
                 }
             }, {
-                label: ( localize(5844, "Always Allow Tools from {0} Without Review", serverLabel)),
+                label: ( localize(6432, "Always Allow Tools from {0} Without Review", serverLabel)),
                 detail: ( localize(
-                    5845,
+                    6433,
                     "Always allow results from all tools from this server to be sent without confirmation."
                 )),
+                scope: "profile",
                 select: async () => {
                     this._postExecutionServerConfirmStore.setAutoConfirmation(definitionId, "profile");
                     return true;
@@ -364,6 +376,9 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
             }
         };
     }
+    toolCanManageConfirmation(tool) {
+        return !!tool.canRequestPreApproval || !!tool.canRequestPostApproval || ( this._contributions.has(tool.id)) || !!this._preExecutionToolConfirmStore.checkAutoConfirmation(tool.id) || !!this._postExecutionToolConfirmStore.checkAutoConfirmation(tool.id);
+    }
     manageConfirmationPreferences(tools, options) {
         const trackServerTool = (serverId, label, toolId, serversWithTools) => {
             if (!( serversWithTools.has(serverId))) {
@@ -483,7 +498,7 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
                         type: "server-post",
                         serverId,
                         iconClass: ThemeIcon.asClassName(Codicon.play),
-                        label: ( localize(5846, "Continue without reviewing any tool results")),
+                        label: ( localize(6434, "Continue without reviewing any tool results")),
                         checked: serverPostConfirmed
                     });
                 }
@@ -492,7 +507,7 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
                         type: "server-pre",
                         serverId,
                         iconClass: ThemeIcon.asClassName(Codicon.play),
-                        label: ( localize(5847, "Run any tool without approval")),
+                        label: ( localize(6435, "Run any tool without approval")),
                         checked: serverPreConfirmed
                     });
                 }
@@ -578,7 +593,7 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
                     description,
                     checked,
                     pickable,
-                    collapsed: true,
+                    collapsed: tools.length > 1,
                     children: toolChildren.length > 0 ? toolChildren : undefined
                 });
             }
@@ -591,7 +606,7 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
         if (currentScope !== "session") {
             const scopeButton = {
                 iconClass: ThemeIcon.asClassName(Codicon.folder),
-                tooltip: ( localize(5848, "Configure for this workspace only")),
+                tooltip: ( localize(6436, "Configure for this workspace only")),
                 toggle: {
                     checked: currentScope === "workspace"
                 },
@@ -608,9 +623,9 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
         }
         const updatePlaceholder = () => {
             if (currentScope === "session") {
-                quickTree.placeholder = ( localize(5849, "Configure session tool approvals"));
+                quickTree.placeholder = ( localize(6437, "Configure session tool approvals"));
             } else {
-                quickTree.placeholder = currentScope === "workspace" ? ( localize(5850, "Configure workspace tool approvals")) : ( localize(5851, "Configure global tool approvals"));
+                quickTree.placeholder = currentScope === "workspace" ? ( localize(6438, "Configure workspace tool approvals")) : ( localize(6439, "Configure global tool approvals"));
             }
         };
         updatePlaceholder();
@@ -650,18 +665,32 @@ let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmation
                 i.item.onDidTriggerItemButton?.(i.button);
             }
         }));
-        disposables.add(quickTree.onDidAccept(() => {
-            for (const item of quickTree.activeItems) {
-                if (item.type === "manage") {
-                    item.onDidOpen?.();
-                    quickTree.hide();
-                }
+        disposables.add(quickTree.onDidAccept(async () => {
+            const manageItem = quickTree.activeItems.find(i => i.type === "manage");
+            if (manageItem) {
+                quickTree.hide();
+                await manageItem.onDidOpen?.();
+                this.manageConfirmationPreferences(tools, options);
             }
         }));
         disposables.add(quickTree.onDidHide(() => {
             disposables.dispose();
         }));
         quickTree.show();
+        if (options?.focusToolId) {
+            const focusToolId = options.focusToolId;
+            for (const serverItem of quickTree.itemTree) {
+                const serverItemTyped = serverItem;
+                if (serverItemTyped.children) {
+                    const toolItem = serverItemTyped.children.find(c => c.type === "tool" && c.toolId === focusToolId);
+                    if (toolItem) {
+                        quickTree.expand(serverItem);
+                        quickTree.reveal(toolItem);
+                        break;
+                    }
+                }
+            }
+        }
     }
     resetToolAutoConfirmation() {
         this._preExecutionToolConfirmStore.reset();

package/vscode/src/vs/workbench/contrib/chat/browser/tools/languageModelToolsService.d.ts

@@ -23,6 +23,10 @@ import { ILanguageModelChatMetadata } from "@codingame/monaco-vscode-api/vscode/
 import { ILanguageModelToolsConfirmationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service";
 import { CountTokensCallback, IBeginToolCallOptions, IToolAndToolSetEnablementMap, IToolData, IToolImpl, IToolInvocation, IToolInvokedEvent, IToolResult, IToolSet, ToolDataSource, ToolSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+export declare enum AutoApproveStorageKeys {
+    GlobalAutoApproveOptIn = "chat.tools.global.autoApprove.optIn"
+}
 export declare const globalAutoApproveDescription: import("@codingame/monaco-vscode-api/vscode/vs/nls").ILocalizedString;
 export declare class LanguageModelToolsService extends Disposable implements ILanguageModelToolsService {
     private readonly _instantiationService;
@@ -38,6 +42,7 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     private readonly _storageService;
     private readonly _confirmationService;
     private readonly _commandService;
+    private readonly _chatWidgetService;
     _serviceBrand: undefined;
     readonly vscodeToolSet: ToolSet;
     readonly executeToolSet: ToolSet;
@@ -60,8 +65,10 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     private readonly _callsByRequestId;
     /** Pending tool calls in the streaming phase, keyed by toolCallId */
     private readonly _pendingToolCalls;
+    /** Deduplicates _checkGlobalAutoApprove calls within this window */
+    private _pendingGlobalAutoApproveCheck;
     private readonly _isAgentModeEnabled;
-    constructor(_instantiationService: IInstantiationService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService, _chatService: IChatService, _dialogService: IDialogService, _telemetryService: ITelemetryService, _logService: ILogService, _configurationService: IConfigurationService, _accessibilityService: IAccessibilityService, _accessibilitySignalService: IAccessibilitySignalService, _storageService: IStorageService, _confirmationService: ILanguageModelToolsConfirmationService, _commandService: ICommandService);
+    constructor(_instantiationService: IInstantiationService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService, _chatService: IChatService, _dialogService: IDialogService, _telemetryService: ITelemetryService, _logService: ILogService, _configurationService: IConfigurationService, _accessibilityService: IAccessibilityService, _accessibilitySignalService: IAccessibilitySignalService, _storageService: IStorageService, _confirmationService: ILanguageModelToolsConfirmationService, _commandService: ICommandService, _chatWidgetService: IChatWidgetService);
     /**
      * Returns if the given tool or toolset is permitted in the current context.
      * When agent mode is enabled, all tools are permitted (no restriction)
@@ -106,11 +113,23 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     private ensureToolDetails;
     private formatToolInput;
     private toolResultToIO;
+    /**
+     * Returns true if enterprise policy has explicitly disabled the global auto-approve setting.
+     * When this is the case, Bypass Approvals and Autopilot permission levels should not auto-approve tools.
+     */
+    private _isAutoApprovePolicyRestricted;
+    /**
+     * Returns true if the session's current (live) permission picker level is auto-approve.
+     * This checks the widget's current state, not what was stamped on the request,
+     * so switching to Autopilot mid-session takes effect immediately.
+     */
+    private _isSessionLiveAutoApproveLevel;
     private getEligibleForAutoApprovalSpecialCase;
     private isToolEligibleForAutoApproval;
     private shouldAutoConfirm;
     private shouldAutoConfirmPostExecution;
     private _checkGlobalAutoApprove;
+    private _doCheckGlobalAutoApprove;
     private cleanupCallDisposables;
     cancelToolCallsForRequest(requestId: string): void;
     private static readonly githubMCPServerAliases;