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

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 { ChatToolInvocation } from '../../common/model/chatProgressTypes/chatToolInvocation.js';
+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';
@@ -58,9 +59,10 @@ var AutoApproveStorageKeys;
     AutoApproveStorageKeys["GlobalAutoApproveOptIn"] = "chat.tools.global.autoApprove.optIn";
 })(AutoApproveStorageKeys || (AutoApproveStorageKeys = {}));
 const SkipAutoApproveConfirmationKey = "vscode.chat.tools.global.autoApprove.testMode";
+const toolIdThatCannotBeAutoApproved = "vscode_get_confirmation_with_options";
 const globalAutoApproveDescription = ( localize2(
-    5852,
-    "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.**"
+    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 {
     static {
@@ -79,7 +81,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         _accessibilitySignalService,
         _storageService,
         _confirmationService,
-        _commandService
+        _commandService,
+        _chatWidgetService
     ) {
         super();
         this._instantiationService = _instantiationService;
@@ -95,13 +98,14 @@ 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()));
         this.onDidPrepareToolCallBecomeUnresponsive = this._onDidPrepareToolCallBecomeUnresponsive.event;
         this._onDidInvokeTool = this._register(( new Emitter()));
         this.onDidInvokeTool = this._onDidInvokeTool.event;
-        this._onDidChangeToolsScheduler = ( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750));
+        this._onDidChangeToolsScheduler = this._register(( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750)));
         this._tools = ( new Map());
         this._toolContextKeys = ( new Set());
         this._callsByRequestId = ( new Map());
@@ -160,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(5853, "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(5854, "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(5855, "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(5856, "Delegate tasks to other agents"))
+                description: ( localize(6444, "Delegate tasks to other agents"))
             })
         );
     }
@@ -187,6 +191,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (agentModeEnabled !== false) {
             return true;
         }
+        if (!isToolSet(toolOrToolSet) && toolOrToolSet.canBeReferencedInPrompt === false && toolOrToolSet.source.type === "internal") {
+            return true;
+        }
         const permittedInternalToolSetIds = [SpecedToolAliases.read, SpecedToolAliases.search, SpecedToolAliases.web];
         if (isToolSet(toolOrToolSet)) {
             const permitted = toolOrToolSet.source.type === "internal" && permittedInternalToolSetIds.includes(toolOrToolSet.referenceName);
@@ -329,8 +336,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     _handlePreToolUseDenial(dto, hookResult, toolData, pendingInvocation, request) {
-        const hookReason = hookResult.permissionDecisionReason ?? ( localize(5857, "Hook denied tool execution"));
-        const reason = ( localize(5858, "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}`
         );
@@ -386,6 +393,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (dto.context?.sessionResource) {
             model = this._chatService.getSession(dto.context.sessionResource);
             request = model?.getRequests().at(-1);
+            if (request?.response?.isCanceled || request?.response?.isComplete) {
+                this._logService.debug(
+                    `[LanguageModelToolsService#invokeTool] Ignoring tool ${dto.toolId} for cancelled/complete request ${request.id}`
+                );
+                throw ( new CancellationError());
+            }
         }
         let pendingToolCallKey;
         let toolInvocation;
@@ -515,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) {
@@ -530,6 +543,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                         };
                         return toolResult;
                     }
+                    if (userConfirmed.type === ToolConfirmKind.UserAction && userConfirmed.selectedButton) {
+                        dto.selectedCustomButton = userConfirmed.selectedButton;
+                    }
                     if (dto.toolSpecificData?.kind === "input") {
                         dto.parameters = dto.toolSpecificData.rawInput;
                         dto.toolSpecificData = undefined;
@@ -566,17 +582,15 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }, token);
             invocationTimeWatch.stop();
             this.ensureToolDetails(dto, toolResult, tool.data);
-            if (toolInvocation?.didExecuteTool(toolResult).type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-                const autoConfirmedPost = await this.shouldAutoConfirmPostExecution(
-                    tool.data.id,
-                    tool.data.runsInWorkspace,
-                    tool.data.source,
-                    dto.parameters,
-                    dto.context?.sessionResource
-                );
-                if (autoConfirmedPost) {
-                    IChatToolInvocation.confirmWith(toolInvocation, autoConfirmedPost);
-                }
+            const afterExecuteState = await toolInvocation?.didExecuteTool(toolResult, undefined, () => this.shouldAutoConfirmPostExecution(
+                tool.data.id,
+                tool.data.runsInWorkspace,
+                tool.data.source,
+                dto.parameters,
+                dto.context?.sessionResource,
+                dto.chatRequestId
+            ));
+            if (toolInvocation && afterExecuteState?.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                 const postConfirm = await IChatToolInvocation.awaitPostConfirmation(toolInvocation, token);
                 if (postConfirm.type === ToolConfirmKind.Denied) {
                     throw ( new CancellationError());
@@ -604,7 +618,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const result = isCancellationError(err) ? "userCancelled" : "error";
             this._telemetryService.publicLog2("languageModelToolInvoked", {
                 result,
-                chatSessionId: dto.context?.sessionId,
+                chatSessionId: dto.context?.sessionResource ? chatSessionResourceToId(dto.context.sessionResource) : undefined,
                 toolId: tool.data.id,
                 toolExtensionId: tool.data.source.type === "extension" ? tool.data.source.extensionId.value : undefined,
                 toolSourceKind: tool.data.source.type,
@@ -642,7 +656,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async prepareToolInvocationWithHookResult(tool, dto, hookResult, token) {
         let forceConfirmationReason;
         if (hookResult?.permissionDecision === "ask") {
-            const hookMessage = ( localize(5859, "{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);
@@ -655,7 +669,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             return {
                 autoConfirmed: {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: ( localize(5860, "Allowed by hook"))
+                    reason: ( localize(6448, "Allowed by hook"))
                 },
                 preparedInvocation
             };
@@ -671,14 +685,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 const fullReferenceName = getToolFullReferenceName(tool.data);
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    5861,
+                    6449,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(5862, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(6450, "{0} hook required confirmation", HookType.PreToolUse));
                 preparedInvocation.confirmationMessages = {
                     ...preparedInvocation.confirmationMessages,
-                    title: ( localize(5863, "Use the '{0}' tool?", fullReferenceName)),
+                    title: ( localize(6451, "Use the '{0}' tool?", fullReferenceName)),
                     message: ( new MarkdownString(`_${hookNote}_`)),
                     allowAutoConfirm: false
                 };
@@ -689,11 +703,11 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             } else {
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    5864,
+                    6452,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(5865, "{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;
@@ -722,7 +736,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             tool.data.runsInWorkspace,
             tool.data.source,
             dto.parameters,
-            sessionResource
+            sessionResource,
+            dto.chatRequestId
         );
         return {
             autoConfirmed,
@@ -736,7 +751,6 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 parameters: dto.parameters,
                 toolCallId: dto.callId,
                 chatRequestId: dto.chatRequestId,
-                chatSessionId: dto.context?.sessionId,
                 chatSessionResource: dto.context?.sessionResource,
                 chatInteractionId: dto.chatInteractionId,
                 modelId: dto.modelId,
@@ -759,10 +773,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(5866, "Confirm tool execution")),
-                message: ( localize(5867, "Run the '{0}' tool?", fullReferenceName)),
-                disclaimer: ( new MarkdownString(( localize(
-                    5868,
+                title: ( localize(6454, "Confirm tool execution")),
+                message: ( localize(6455, "Run the '{0}' tool?", fullReferenceName)),
+                disclaimer: tool.data.id === toolIdThatCannotBeAutoApproved ? undefined : ( new MarkdownString(( localize(
+                    6456,
                     "Auto approval for '{0}' is restricted via {1}.",
                     getToolFullReferenceName(tool.data),
                     createMarkdownCommandLink({
@@ -777,8 +791,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             };
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
-            prepared.confirmationMessages.disclaimer = ( new MarkdownString(( localize(
-                5868,
+            prepared.confirmationMessages.disclaimer = tool.data.id === toolIdThatCannotBeAutoApproved ? undefined : ( new MarkdownString(( localize(
+                6456,
                 "Auto approval for '{0}' is restricted via {1}.",
                 getToolFullReferenceName(tool.data),
                 createMarkdownCommandLink({
@@ -868,11 +882,22 @@ 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;
+        }
         const setting = this._configurationService.getValue(AccessibilitySignal.chatUserActionRequired.settingsKey);
         if (!setting) {
             return;
@@ -881,7 +906,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         const announcementEnabled = this._accessibilityService.isScreenReaderOptimized() && setting.announcement === "auto";
         if (soundEnabled || announcementEnabled) {
             this._accessibilitySignalService.playSignal(AccessibilitySignal.chatUserActionRequired, {
-                customAlertMessage: this._instantiationService.invokeFunction(getToolConfirmationAlert, toolInvocations),
+                customAlertMessage: this._instantiationService.invokeFunction(getToolConfirmationAlert, pendingInvocations),
                 userGesture: true,
                 modality: !soundEnabled ? "announcement" : undefined
             });
@@ -923,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";
@@ -934,6 +967,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (toolData.id === "copilot_fetchWebPage") {
             return true;
         }
+        if (toolData.id === toolIdThatCannotBeAutoApproved) {
+            return false;
+        }
         const eligibilityConfig = this._configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
         if (eligibilityConfig && typeof eligibilityConfig === "object" && fullReferenceName) {
             if (Object.prototype.hasOwnProperty.call(eligibilityConfig, fullReferenceName)) {
@@ -955,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;
         }
@@ -991,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,
@@ -1017,35 +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(5869, "Enable global auto approve?")),
-            buttons: [{
-                label: ( localize(5870, "Enable")),
-                run: () => true
-            }, {
-                label: ( localize(5871, "Disable")),
-                run: () => false
-            }],
-            custom: {
-                icon: Codicon.warning,
-                disableCloseAction: true,
-                markdownDetails: [{
-                    markdown: ( new MarkdownString(globalAutoApproveDescription.value))
-                }]
+        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) {
@@ -1303,7 +1411,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     add(alias, fullReferenceName);
                 }
                 if (tool.legacyToolReferenceFullNames) {
+                    const slashIndex = fullReferenceName.lastIndexOf("/");
+                    const toolSetPrefix = slashIndex !== -1 ? fullReferenceName.substring(0, slashIndex + 1) : undefined;
                     for (const legacyName of tool.legacyToolReferenceFullNames) {
+                        if (toolSetPrefix && !legacyName.includes("/")) {
+                            add(toolSetPrefix + legacyName, fullReferenceName);
+                        }
                         if (legacyName.includes("/")) {
                             const toolSetFullName = legacyName.substring(0, legacyName.lastIndexOf("/"));
                             if (!( knownToolSetNames.has(toolSetFullName))) {
@@ -1335,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) {
@@ -1352,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.d.ts

@@ -0,0 +1,31 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IBulkEditService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService.service";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } 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";
+export declare const RenameToolId = "vscode_renameSymbol";
+export declare class RenameTool extends Disposable implements IToolImpl {
+    private readonly _languageFeaturesService;
+    private readonly _textModelService;
+    private readonly _workspaceContextService;
+    private readonly _chatService;
+    private readonly _bulkEditService;
+    private readonly _onDidUpdateToolData;
+    readonly onDidUpdateToolData: Event<void>;
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService, _chatService: IChatService, _bulkEditService: IBulkEditService);
+    getToolData(): IToolData;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    private _successResult;
+}
+export declare class RenameToolContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.renameTool";
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService);
+}