@codingame/monaco-vscode-chat-service-override 27.0.0 → 28.0.1

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;

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

@@ -38,13 +38,14 @@ import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { toToolSetVariableEntry, toToolVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { ToolConfirmKind, IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration, isAutoApproveLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatToolInvocation';
 import { chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
-import { HookType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+import { HookType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
 import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
 import { ToolDataSource, VSCodeToolReference, SpecedToolAliases, isToolSet, createToolSchemaUri, toolMatchesModel, ToolInvocationPresentation, stringifyPromptTsxPart, ToolSetForModel, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { getToolConfirmationAlert } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityProvider';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ObservableSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/set';
 import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { observableFromEventOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
@@ -60,7 +61,7 @@ var AutoApproveStorageKeys;
 const SkipAutoApproveConfirmationKey = "vscode.chat.tools.global.autoApprove.testMode";
 const toolIdThatCannotBeAutoApproved = "vscode_get_confirmation_with_options";
 const globalAutoApproveDescription = ( localize2(
-    6345,
+    6440,
     "Global auto approve also known as \"YOLO mode\" disables manual approval completely for _all tools in all workspaces_, allowing the agent to act fully autonomously. This is extremely dangerous and is *never* recommended, even containerized environments like [Codespaces](https://github.com/features/codespaces) and [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) have user keys forwarded into the container that could be compromised.\n\n**This feature disables [critical security protections](https://code.visualstudio.com/docs/copilot/security) and makes it much easier for an attacker to compromise the machine.**\n\nNote: This setting only controls tool approval and does not prevent the agent from asking questions. To automatically answer agent questions, use the [`chat.autoReply`](command:workbench.action.openSettings?%5B%22chat.autoReply%22%5D) setting."
 ));
 let LanguageModelToolsService = class LanguageModelToolsService extends Disposable {
@@ -80,7 +81,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         _accessibilitySignalService,
         _storageService,
         _confirmationService,
-        _commandService
+        _commandService,
+        _chatWidgetService
     ) {
         super();
         this._instantiationService = _instantiationService;
@@ -96,6 +98,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this._storageService = _storageService;
         this._confirmationService = _confirmationService;
         this._commandService = _commandService;
+        this._chatWidgetService = _chatWidgetService;
         this._onDidChangeTools = this._register(( new Emitter()));
         this.onDidChangeTools = this._onDidChangeTools.event;
         this._onDidPrepareToolCallBecomeUnresponsive = this._register(( new Emitter()));
@@ -161,25 +164,25 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this.vscodeToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "vscode", VSCodeToolReference.vscode, {
                 icon: ThemeIcon.fromId(Codicon.vscode.id),
-                description: ( localize(6346, "Use VS Code features"))
+                description: ( localize(6441, "Use VS Code features"))
             })
         );
         this.executeToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "execute", SpecedToolAliases.execute, {
                 icon: ThemeIcon.fromId(Codicon.terminal.id),
-                description: ( localize(6347, "Execute code and applications on your machine"))
+                description: ( localize(6442, "Execute code and applications on your machine"))
             })
         );
         this.readToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "read", SpecedToolAliases.read, {
                 icon: ThemeIcon.fromId(Codicon.book.id),
-                description: ( localize(6348, "Read files in your workspace"))
+                description: ( localize(6443, "Read files in your workspace"))
             })
         );
         this.agentToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "agent", SpecedToolAliases.agent, {
                 icon: ThemeIcon.fromId(Codicon.agent.id),
-                description: ( localize(6349, "Delegate tasks to other agents"))
+                description: ( localize(6444, "Delegate tasks to other agents"))
             })
         );
     }
@@ -333,8 +336,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     _handlePreToolUseDenial(dto, hookResult, toolData, pendingInvocation, request) {
-        const hookReason = hookResult.permissionDecisionReason ?? ( localize(6350, "Hook denied tool execution"));
-        const reason = ( localize(6351, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
+        const hookReason = hookResult.permissionDecisionReason ?? ( localize(6445, "Hook denied tool execution"));
+        const reason = ( localize(6446, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
         this._logService.debug(
             `[LanguageModelToolsService#invokeTool] Tool ${dto.toolId} denied by preToolUse hook: ${hookReason}`
         );
@@ -525,7 +528,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 dto.toolSpecificData = toolInvocation?.toolSpecificData;
                 if (preparedInvocation?.confirmationMessages?.title) {
                     if (!IChatToolInvocation.executionConfirmedOrDenied(toolInvocation) && !autoConfirmed) {
-                        this.playAccessibilitySignal([toolInvocation]);
+                        this.playAccessibilitySignal([toolInvocation], dto.context?.sessionResource);
                     }
                     const userConfirmed = await IChatToolInvocation.awaitConfirmation(toolInvocation, token);
                     if (userConfirmed.type === ToolConfirmKind.Denied) {
@@ -584,7 +587,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 tool.data.runsInWorkspace,
                 tool.data.source,
                 dto.parameters,
-                dto.context?.sessionResource
+                dto.context?.sessionResource,
+                dto.chatRequestId
             ));
             if (toolInvocation && afterExecuteState?.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                 const postConfirm = await IChatToolInvocation.awaitPostConfirmation(toolInvocation, token);
@@ -652,7 +656,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async prepareToolInvocationWithHookResult(tool, dto, hookResult, token) {
         let forceConfirmationReason;
         if (hookResult?.permissionDecision === "ask") {
-            const hookMessage = ( localize(6352, "{0} required confirmation", HookType.PreToolUse));
+            const hookMessage = ( localize(6447, "{0} required confirmation", HookType.PreToolUse));
             forceConfirmationReason = hookResult.permissionDecisionReason ? `${hookMessage}: ${hookResult.permissionDecisionReason}` : hookMessage;
         }
         return this.prepareToolInvocation(tool, dto, forceConfirmationReason, token);
@@ -665,7 +669,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             return {
                 autoConfirmed: {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: ( localize(6353, "Allowed by hook"))
+                    reason: ( localize(6448, "Allowed by hook"))
                 },
                 preparedInvocation
             };
@@ -681,14 +685,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 const fullReferenceName = getToolFullReferenceName(tool.data);
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    6354,
+                    6449,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(6355, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(6450, "{0} hook required confirmation", HookType.PreToolUse));
                 preparedInvocation.confirmationMessages = {
                     ...preparedInvocation.confirmationMessages,
-                    title: ( localize(6356, "Use the '{0}' tool?", fullReferenceName)),
+                    title: ( localize(6451, "Use the '{0}' tool?", fullReferenceName)),
                     message: ( new MarkdownString(`_${hookNote}_`)),
                     allowAutoConfirm: false
                 };
@@ -699,11 +703,11 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             } else {
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    6357,
+                    6452,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(6358, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(6453, "{0} hook required confirmation", HookType.PreToolUse));
                 const existing = preparedInvocation.confirmationMessages;
                 if (preparedInvocation.toolSpecificData?.kind === "terminal") {
                     const existingDisclaimerText = existing.disclaimer ? (typeof existing.disclaimer === "string" ? existing.disclaimer : existing.disclaimer.value) : undefined;
@@ -732,7 +736,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             tool.data.runsInWorkspace,
             tool.data.source,
             dto.parameters,
-            sessionResource
+            sessionResource,
+            dto.chatRequestId
         );
         return {
             autoConfirmed,
@@ -768,10 +773,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(6359, "Confirm tool execution")),
-                message: ( localize(6360, "Run the '{0}' tool?", fullReferenceName)),
+                title: ( localize(6454, "Confirm tool execution")),
+                message: ( localize(6455, "Run the '{0}' tool?", fullReferenceName)),
                 disclaimer: tool.data.id === toolIdThatCannotBeAutoApproved ? undefined : ( new MarkdownString(( localize(
-                    6361,
+                    6456,
                     "Auto approval for '{0}' is restricted via {1}.",
                     getToolFullReferenceName(tool.data),
                     createMarkdownCommandLink({
@@ -787,7 +792,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
             prepared.confirmationMessages.disclaimer = tool.data.id === toolIdThatCannotBeAutoApproved ? undefined : ( new MarkdownString(( localize(
-                6361,
+                6456,
                 "Auto approval for '{0}' is restricted via {1}.",
                 getToolFullReferenceName(tool.data),
                 createMarkdownCommandLink({
@@ -877,11 +882,18 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             await this._callHandleToolStream(toolEntry, invocation, toolCallId, partialInput, token);
         }
     }
-    playAccessibilitySignal(toolInvocations) {
+    playAccessibilitySignal(toolInvocations, chatSessionResource) {
         const autoApproved = this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove);
         if (autoApproved) {
             return;
         }
+        if (chatSessionResource) {
+            const model = this._chatService.getSession(chatSessionResource);
+            const request = model?.getRequests().at(-1);
+            if (isAutoApproveLevel(request?.modeInfo?.permissionLevel) || this._isSessionLiveAutoApproveLevel(chatSessionResource)) {
+                return;
+            }
+        }
         const pendingInvocations = toolInvocations.filter(inv => !IChatToolInvocation.executionConfirmedOrDenied(inv));
         if (pendingInvocations.length === 0) {
             return;
@@ -936,6 +948,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
         }));
     }
+    _isAutoApprovePolicyRestricted() {
+        const inspected = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+        return inspected.policyValue === false;
+    }
+    _isSessionLiveAutoApproveLevel(chatSessionResource) {
+        const widget = this._chatWidgetService.getWidgetBySessionResource(chatSessionResource) ?? this._chatWidgetService.lastFocusedWidget;
+        return !!widget && isAutoApproveLevel(widget.input.currentModeInfo.permissionLevel);
+    }
     getEligibleForAutoApprovalSpecialCase(toolData) {
         if (toolData.id === "vscode_fetchWebPage_internal") {
             return "fetch";
@@ -971,11 +991,28 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return true;
     }
-    async shouldAutoConfirm(toolId, runsInWorkspace, source, parameters, chatSessionResource) {
+    async shouldAutoConfirm(
+        toolId,
+        runsInWorkspace,
+        source,
+        parameters,
+        chatSessionResource,
+        chatRequestId
+    ) {
         const tool = this._tools.get(toolId);
         if (!tool) {
             return undefined;
         }
+        if (chatSessionResource && !this._isAutoApprovePolicyRestricted()) {
+            const model = this._chatService.getSession(chatSessionResource);
+            const request = model?.getRequests().at(-1);
+            if (isAutoApproveLevel(request?.modeInfo?.permissionLevel) || this._isSessionLiveAutoApproveLevel(chatSessionResource)) {
+                return {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: "auto-approve-all"
+                };
+            }
+        }
         if (!this.isToolEligibleForAutoApproval(tool.data)) {
             return undefined;
         }
@@ -1007,7 +1044,24 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return undefined;
     }
-    async shouldAutoConfirmPostExecution(toolId, runsInWorkspace, source, parameters, chatSessionResource) {
+    async shouldAutoConfirmPostExecution(
+        toolId,
+        runsInWorkspace,
+        source,
+        parameters,
+        chatSessionResource,
+        chatRequestId
+    ) {
+        if (chatSessionResource && !this._isAutoApprovePolicyRestricted()) {
+            const model = this._chatService.getSession(chatSessionResource);
+            const request = model?.getRequests().at(-1);
+            if (isAutoApproveLevel(request?.modeInfo?.permissionLevel) || this._isSessionLiveAutoApproveLevel(chatSessionResource)) {
+                return {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: "auto-approve-all"
+                };
+            }
+        }
         if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove) && (await this._checkGlobalAutoApprove())) {
             return {
                 type: ToolConfirmKind.Setting,
@@ -1033,38 +1087,73 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (this._contextKeyService.getContextKeyValue(SkipAutoApproveConfirmationKey) === true) {
             return true;
         }
-        const promptResult = await this._dialogService.prompt({
-            type: Severity.Warning,
-            message: ( localize(6362, "Enable global auto approve?")),
-            buttons: [{
-                label: ( localize(6363, "Enable")),
-                run: () => true
-            }, {
-                label: ( localize(6364, "Disable")),
-                run: () => false
-            }],
-            custom: {
-                icon: Codicon.warning,
-                markdownDetails: [{
-                    markdown: ( new MarkdownString(globalAutoApproveDescription.value, {
-                        isTrusted: {
-                            enabledCommands: ["workbench.action.openSettings"]
-                        }
-                    }))
-                }]
+        if (this._pendingGlobalAutoApproveCheck) {
+            return this._pendingGlobalAutoApproveCheck;
+        }
+        this._pendingGlobalAutoApproveCheck = this._doCheckGlobalAutoApprove();
+        try {
+            return await this._pendingGlobalAutoApproveCheck;
+        } finally {
+            this._pendingGlobalAutoApproveCheck = undefined;
+        }
+    }
+    async _doCheckGlobalAutoApprove() {
+        const store = ( new DisposableStore());
+        try {
+            const cts = ( new CancellationTokenSource());
+            store.add(cts);
+            store.add(this._storageService.onDidChangeValue(
+                StorageScope.APPLICATION,
+                AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+                store
+            )(() => {
+                if (this._storageService.getBoolean(
+                    AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+                    StorageScope.APPLICATION,
+                    false
+                )) {
+                    cts.cancel();
+                }
+            }));
+            const promptResult = await this._dialogService.prompt({
+                type: Severity.Warning,
+                message: ( localize(6457, "Enable global auto approve?")),
+                buttons: [{
+                    label: ( localize(6458, "Enable")),
+                    run: () => true
+                }, {
+                    label: ( localize(6459, "Disable")),
+                    run: () => false
+                }],
+                custom: {
+                    icon: Codicon.warning,
+                    markdownDetails: [{
+                        markdown: ( new MarkdownString(globalAutoApproveDescription.value, {
+                            isTrusted: {
+                                enabledCommands: ["workbench.action.openSettings"]
+                            }
+                        }))
+                    }]
+                },
+                token: cts.token
+            });
+            if (cts.token.isCancellationRequested) {
+                return true;
             }
-        });
-        if (promptResult.result !== true) {
-            await this._configurationService.updateValue(ChatConfiguration.GlobalAutoApprove, false);
-            return false;
+            if (promptResult.result !== true) {
+                await this._configurationService.updateValue(ChatConfiguration.GlobalAutoApprove, false);
+                return false;
+            }
+            this._storageService.store(
+                AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+                true,
+                StorageScope.APPLICATION,
+                StorageTarget.USER
+            );
+            return true;
+        } finally {
+            store.dispose();
         }
-        this._storageService.store(
-            AutoApproveStorageKeys.GlobalAutoApproveOptIn,
-            true,
-            StorageScope.APPLICATION,
-            StorageTarget.USER
-        );
-        return true;
     }
     cleanupCallDisposables(requestId, store) {
         if (requestId) {
@@ -1089,7 +1178,6 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         for (const [toolCallId, invocation] of this._pendingToolCalls) {
             if (invocation.chatRequestId === requestId) {
-                invocation.cancelFromStreaming(ToolConfirmKind.Skipped);
                 this._pendingToolCalls.delete(toolCallId);
             }
         }
@@ -1360,7 +1448,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return getToolFullReferenceName(tool, toolSet);
     }
 };
-LanguageModelToolsService = LanguageModelToolsService_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IExtensionService)), ( __param(2, IContextKeyService)), ( __param(3, IChatService)), ( __param(4, IDialogService)), ( __param(5, ITelemetryService)), ( __param(6, ILogService)), ( __param(7, IConfigurationService)), ( __param(8, IAccessibilityService)), ( __param(9, IAccessibilitySignalService)), ( __param(10, IStorageService)), ( __param(11, ILanguageModelToolsConfirmationService)), ( __param(12, ICommandService))], LanguageModelToolsService));
+LanguageModelToolsService = LanguageModelToolsService_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IExtensionService)), ( __param(2, IContextKeyService)), ( __param(3, IChatService)), ( __param(4, IDialogService)), ( __param(5, ITelemetryService)), ( __param(6, ILogService)), ( __param(7, IConfigurationService)), ( __param(8, IAccessibilityService)), ( __param(9, IAccessibilitySignalService)), ( __param(10, IStorageService)), ( __param(11, ILanguageModelToolsConfirmationService)), ( __param(12, ICommandService)), ( __param(13, IChatWidgetService))], LanguageModelToolsService));
 function getToolFullReferenceName(tool, toolSet) {
     const toolName = tool.toolReferenceName ?? tool.displayName;
     if (toolSet) {
@@ -1377,4 +1465,4 @@ function getToolSetFullReferenceName(toolSet) {
     return toolSet.referenceName;
 }
 
-export { LanguageModelToolsService, globalAutoApproveDescription };
+export { AutoApproveStorageKeys, LanguageModelToolsService, globalAutoApproveDescription };

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

@@ -71,8 +71,8 @@ let RenameTool = class RenameTool extends Disposable {
             toolReferenceName: "rename",
             canBeReferencedInPrompt: false,
             icon: ThemeIcon.fromId(Codicon.rename.id),
-            displayName: ( localize(6365, "Rename Symbol")),
-            userDescription: ( localize(6366, "Rename a symbol across the workspace")),
+            displayName: ( localize(6460, "Rename Symbol")),
+            userDescription: ( localize(6461, "Rename a symbol across the workspace")),
             modelDescription,
             source: ToolDataSource.Internal,
             when: ( ContextKeyExpr.has("config.chat.tools.renameTool.enabled")),
@@ -107,7 +107,7 @@ let RenameTool = class RenameTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const input = context.parameters;
         return {
-            invocationMessage: ( localize(6367, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
+            invocationMessage: ( localize(6462, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
@@ -195,13 +195,13 @@ let RenameTool = class RenameTool extends Disposable {
     }
     _successResult(input, fileCount, editCount) {
         const text = editCount === 1 ? ( localize(
-            6368,
+            6463,
             "Renamed `{0}` to `{1}` - 1 edit in {2} file.",
             input.symbol,
             input.newName,
             fileCount
         )) : ( localize(
-            6369,
+            6464,
             "Renamed `{0}` to `{1}` - {2} edits across {3} files.",
             input.symbol,
             input.newName,

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

@@ -44,7 +44,7 @@ const toolSetsSchema = {
     allowComments: true,
     allowTrailingCommas: true,
     defaultSnippets: [{
-        label: ( localize(6370, "Empty tool set")),
+        label: ( localize(6465, "Empty tool set")),
         body: {
             "${1:toolSetName}": {
                 "tools": ["${2:someTool}", "${3:anotherTool}"],
@@ -54,7 +54,7 @@ const toolSetsSchema = {
         }
     }],
     type: "object",
-    description: ( localize(6371, "User tool sets configuration")),
+    description: ( localize(6466, "User tool sets configuration")),
     additionalProperties: {
         type: "object",
         required: ["tools"],
@@ -62,7 +62,7 @@ const toolSetsSchema = {
         properties: {
             tools: {
                 description: ( localize(
-                    6372,
+                    6467,
                     "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools the way they are referenced in prompts."
                 )),
                 type: "array",
@@ -75,7 +75,7 @@ const toolSetsSchema = {
             },
             icon: {
                 description: ( localize(
-                    6373,
+                    6468,
                     "Icon to use for this tool set in the UI. Uses the \"\\$(name)\"-syntax, like \"\\$(zap)\""
                 )),
                 type: "string",
@@ -83,7 +83,7 @@ const toolSetsSchema = {
                 markdownEnumDescriptions: Array.from(getAllCodicons(), icon => `$(${icon.id})`)
             },
             description: {
-                description: ( localize(6374, "A short description of this tool set.")),
+                description: ( localize(6469, "A short description of this tool set.")),
                 type: "string"
             }
         }
@@ -184,7 +184,7 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
             });
             for (const item of data) {
                 toolEnumValues.push(item.name);
-                toolEnumDescriptions.push(( localize(6375, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
+                toolEnumDescriptions.push(( localize(6470, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
             }
             store.clear();
             reg.registerSchema(toolSetSchemaId, toolSetsSchema, store);
@@ -281,8 +281,8 @@ class ConfigureToolSets extends Action2 {
     constructor() {
         super({
             id: ConfigureToolSets.ID,
-            title: ( localize2(6376, "Configure Tool Sets...")),
-            shortTitle: ( localize(6377, "Tool Sets")),
+            title: ( localize2(6471, "Configure Tool Sets...")),
+            shortTitle: ( localize(6472, "Tool Sets")),
             category: CHAT_CATEGORY,
             f1: true,
             precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatContextKeys.Tools.toolsCount.greater(0))),
@@ -303,7 +303,7 @@ class ConfigureToolSets extends Action2 {
         const textFileService = accessor.get(ITextFileService);
         const picks = [];
         picks.push({
-            label: ( localize(6378, "Create new tool sets file...")),
+            label: ( localize(6473, "Create new tool sets file...")),
             alwaysShow: true,
             iconClass: ThemeIcon.asClassName(Codicon.plus)
         });
@@ -320,7 +320,7 @@ class ConfigureToolSets extends Action2 {
         }
         const pick = await quickInputService.pick(picks, {
             canPickMany: false,
-            placeHolder: ( localize(6379, "Select a tool set to configure"))
+            placeHolder: ( localize(6474, "Select a tool set to configure"))
         });
         if (!pick) {
             return;
@@ -328,13 +328,13 @@ class ConfigureToolSets extends Action2 {
         let resource;
         if (!pick.toolset) {
             const name = await quickInputService.input({
-                placeHolder: ( localize(6380, "Type tool sets file name")),
+                placeHolder: ( localize(6475, "Type tool sets file name")),
                 validateInput: async input => {
                     if (!input) {
-                        return localize(6381, "Invalid file name");
+                        return localize(6476, "Invalid file name");
                     }
                     if (!isValidBasename(input)) {
-                        return localize(6382, "'{0}' is not a valid file name", input);
+                        return localize(6477, "'{0}' is not a valid file name", input);
                     }
                     return undefined;
                 }

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

@@ -75,8 +75,8 @@ let UsagesTool = class UsagesTool extends Disposable {
             toolReferenceName: "usages",
             canBeReferencedInPrompt: false,
             icon: ThemeIcon.fromId(Codicon.references.id),
-            displayName: ( localize(6383, "List Code Usages")),
-            userDescription: ( localize(6384, "Find references, definitions, and implementations of a symbol")),
+            displayName: ( localize(6478, "List Code Usages")),
+            userDescription: ( localize(6479, "Find references, definitions, and implementations of a symbol")),
             modelDescription,
             source: ToolDataSource.Internal,
             when: ( ContextKeyExpr.has("config.chat.tools.usagesTool.enabled")),
@@ -107,7 +107,7 @@ let UsagesTool = class UsagesTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const input = context.parameters;
         return {
-            invocationMessage: ( localize(6385, "Analyzing usages of `{0}`", input.symbol))
+            invocationMessage: ( localize(6480, "Analyzing usages of `{0}`", input.symbol))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
@@ -160,7 +160,7 @@ let UsagesTool = class UsagesTool extends Disposable {
             )]);
             if (references.length === 0) {
                 const result = createToolSimpleTextResult(`No usages found for \`${input.symbol}\`.`);
-                result.toolResultMessage = ( new MarkdownString(( localize(6386, "Analyzed usages of `{0}`, no results", input.symbol))));
+                result.toolResultMessage = ( new MarkdownString(( localize(6481, "Analyzed usages of `{0}`, no results", input.symbol))));
                 return result;
             }
             const previews = await this._getLinePreviews(input.symbol, references, token);
@@ -181,8 +181,8 @@ let UsagesTool = class UsagesTool extends Disposable {
             }
             const text = lines.join("\n");
             const result = createToolSimpleTextResult(text);
-            result.toolResultMessage = references.length === 1 ? ( new MarkdownString(( localize(6387, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
-                6388,
+            result.toolResultMessage = references.length === 1 ? ( new MarkdownString(( localize(6482, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
+                6483,
                 "Analyzed usages of `{0}`, {1} results",
                 input.symbol,
                 references.length