@codingame/monaco-vscode-chat-service-override 34.1.2 → 35.0.0

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

@@ -40,17 +40,20 @@ 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, isAutoApproveLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration, isAutoApproveLevel, isAutopilotLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { ChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatToolInvocation';
 import { chatSessionResourceToId, getChatSessionType } 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/hookTypes';
 import { CopilotChatSettingId, CopilotToolId } from '../../common/tools/copilotToolIds.js';
 import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
-import { ToolDataSource, VSCodeToolReference, SpecedToolAliases, toolMatchesModel, isToolSet, createToolSchemaUri, ToolInvocationPresentation, stringifyPromptTsxPart, ToolSetForModel, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
+import { ToolDataSource, VSCodeToolReference, SpecedToolAliases, toolMatchesModel, isToolSet, createToolSchemaUri, ToolInvocationPresentation, stringifyPromptTsxPart, ToolSetForModel, ToolAndToolSetEnablementMap, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { IToolResultCompressor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/toolResultCompressor.service';
 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 { ToolRiskLevel } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService';
+import { IChatToolRiskAssessmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/tools/chatToolRiskAssessmentService.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';
@@ -64,12 +67,14 @@ var AutoApproveStorageKeys;
     AutoApproveStorageKeys["GlobalAutoApproveOptIn"] = "chat.tools.global.autoApprove.optIn";
 })(AutoApproveStorageKeys || (AutoApproveStorageKeys = {}));
 const SkipAutoApproveConfirmationKey = "vscode.chat.tools.global.autoApprove.testMode";
+const autoApproveAllReason = "auto-approve-all";
 const toolIdsThatCannotBeAutoApproved = ( new Set([
     "vscode_get_confirmation_with_options",
     "vscode_get_modified_files_confirmation"
 ]));
+const fetchWebPageToolIds = ( new Set(["copilot_fetchWebPage", "vscode_fetchWebPage_internal"]));
 const globalAutoApproveDescription = ( localize2(
-    7188,
+    7704,
     "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 {
@@ -91,7 +96,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         _confirmationService,
         _commandService,
         _chatWidgetService,
-        _toolResultCompressor
+        _toolResultCompressor,
+        _riskAssessmentService
     ) {
         super();
         this._instantiationService = _instantiationService;
@@ -109,6 +115,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this._commandService = _commandService;
         this._chatWidgetService = _chatWidgetService;
         this._toolResultCompressor = _toolResultCompressor;
+        this._riskAssessmentService = _riskAssessmentService;
         this._onDidChangeTools = this._register(( new Emitter()));
         this.onDidChangeTools = this._onDidChangeTools.event;
         this._onDidPrepareToolCallBecomeUnresponsive = this._register(( new Emitter()));
@@ -174,25 +181,29 @@ 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(7189, "Use VS Code features"))
+                description: ( localize(7705, "Use VS Code features")),
+                deprecated: true
             })
         );
         this.executeToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "execute", SpecedToolAliases.execute, {
                 icon: ThemeIcon.fromId(Codicon.terminal.id),
-                description: ( localize(7190, "Execute code and applications on your machine"))
+                description: ( localize(7706, "Execute code and applications on your machine")),
+                deprecated: true
             })
         );
         this.readToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "read", SpecedToolAliases.read, {
                 icon: ThemeIcon.fromId(Codicon.book.id),
-                description: ( localize(7191, "Read files in your workspace"))
+                description: ( localize(7707, "Read files in your workspace")),
+                deprecated: true
             })
         );
         this.agentToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "agent", SpecedToolAliases.agent, {
                 icon: ThemeIcon.fromId(Codicon.agent.id),
-                description: ( localize(7192, "Delegate tasks to other agents"))
+                description: ( localize(7708, "Delegate tasks to other agents")),
+                deprecated: true
             })
         );
     }
@@ -355,8 +366,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     _handlePreToolUseDenial(dto, hookResult, toolData, pendingInvocation, request) {
-        const hookReason = hookResult.permissionDecisionReason ?? ( localize(7193, "Hook denied tool execution"));
-        const reason = ( localize(7194, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
+        const hookReason = hookResult.permissionDecisionReason ?? ( localize(7709, "Hook denied tool execution"));
+        const reason = ( localize(7710, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
         this._logService.debug(
             `[LanguageModelToolsService#invokeTool] Tool ${dto.toolId} denied by preToolUse hook: ${hookReason}`
         );
@@ -528,7 +539,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 preparedInvocation = await this.prepareToolInvocationWithHookResult(tool, dto, preToolUseHookResult, token);
                 prepareTimeWatch.stop();
                 const {
-                    autoConfirmed,
+                    autoConfirmed: resolvedAutoConfirmed,
                     preparedInvocation: updatedPreparedInvocation
                 } = await this.resolveAutoConfirmFromHook(
                     preToolUseHookResult,
@@ -538,6 +549,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     dto.context?.sessionResource
                 );
                 preparedInvocation = updatedPreparedInvocation;
+                const {
+                    autoConfirmed,
+                    skipExplanation: riskSkipExplanation
+                } = await this._maybeApplyAutopilotRiskGate(tool, dto, preparedInvocation, resolvedAutoConfirmed, token);
                 if (hadPendingInvocation && toolInvocation) {
                     toolInvocation.transitionFromStreaming(preparedInvocation, dto.parameters, autoConfirmed);
                 } else {
@@ -554,6 +569,27 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     this._chatService.appendProgress(request, toolInvocation);
                 }
                 dto.toolSpecificData = toolInvocation?.toolSpecificData;
+                if (riskSkipExplanation) {
+                    this._logToolApprovalTelemetry(tool, dto, {
+                        type: ToolConfirmKind.Skipped
+                    });
+                    this._chatService.appendProgress(request, {
+                        kind: "info",
+                        content: ( new MarkdownString(( localize(
+                            7711,
+                            "Autopilot skipped \"{0}\" because it was assessed as high-risk: {1}",
+                            tool.data.displayName,
+                            riskSkipExplanation
+                        ))))
+                    });
+                    toolResult = {
+                        content: [{
+                            kind: "text",
+                            value: `Autopilot skipped this tool call because it was automatically assessed as high-risk: ${riskSkipExplanation} The action was not performed. Do not retry it as-is — choose a safer approach or leave it for the user to run manually.`
+                        }]
+                    };
+                    return toolResult;
+                }
                 if (preparedInvocation?.confirmationMessages?.title) {
                     if (!IChatToolInvocation.executionConfirmedOrDenied(toolInvocation) && !autoConfirmed) {
                         this.playAccessibilitySignal([toolInvocation], dto.context?.sessionResource);
@@ -694,7 +730,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async prepareToolInvocationWithHookResult(tool, dto, hookResult, token) {
         let forceConfirmationReason;
         if (hookResult?.permissionDecision === "ask") {
-            const hookMessage = ( localize(7195, "{0} required confirmation", HookType.PreToolUse));
+            const hookMessage = ( localize(7712, "{0} required confirmation", HookType.PreToolUse));
             forceConfirmationReason = hookResult.permissionDecisionReason ? `${hookMessage}: ${hookResult.permissionDecisionReason}` : hookMessage;
         }
         return this.prepareToolInvocation(tool, dto, forceConfirmationReason, token);
@@ -708,7 +744,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             [ToolConfirmKind.UserAction]: "userAction",
             [ToolConfirmKind.Skipped]: "skipped"
         };
-        const allowedConfirmationNotNeededReasons = ( new Set(["auto-approve-all", "inlineChat"]));
+        const allowedConfirmationNotNeededReasons = ( new Set([autoApproveAllReason, "inlineChat"]));
         let confirmationNotNeededReason;
         if (reason.type === ToolConfirmKind.ConfirmationNotNeeded && reason.reason) {
             const raw = typeof reason.reason === "string" ? reason.reason : reason.reason.value;
@@ -738,7 +774,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             return {
                 autoConfirmed: {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: ( localize(7196, "Allowed by hook"))
+                    reason: ( localize(7713, "Allowed by hook"))
                 },
                 preparedInvocation
             };
@@ -754,14 +790,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 const fullReferenceName = getToolFullReferenceName(tool.data);
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    7197,
+                    7714,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(7198, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(7715, "{0} hook required confirmation", HookType.PreToolUse));
                 preparedInvocation.confirmationMessages = {
                     ...preparedInvocation.confirmationMessages,
-                    title: ( localize(7199, "Use the '{0}' tool?", fullReferenceName)),
+                    title: ( localize(7716, "Use the '{0}' tool?", fullReferenceName)),
                     message: ( new MarkdownString(`_${hookNote}_`)),
                     allowAutoConfirm: false
                 };
@@ -772,11 +808,11 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             } else {
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    7200,
+                    7717,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(7201, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(7718, "{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;
@@ -823,6 +859,72 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             preparedInvocation
         };
     }
+    async _maybeApplyAutopilotRiskGate(tool, dto, preparedInvocation, autoConfirmed, token) {
+        const isTerminalTool = tool.data.id === TerminalToolId.RunInTerminal;
+        const isFetchTool = ( fetchWebPageToolIds.has(tool.data.id));
+        const isAlwaysClassifyTool = isTerminalTool || isFetchTool;
+        const isBlanketSessionApprove = autoConfirmed?.type === ToolConfirmKind.ConfirmationNotNeeded && autoConfirmed.reason === autoApproveAllReason;
+        const isSelfApprovedAlwaysClassify = isAlwaysClassifyTool && autoConfirmed === undefined && !preparedInvocation?.confirmationMessages?.title;
+        if (!isBlanketSessionApprove && !isSelfApprovedAlwaysClassify) {
+            return {
+                autoConfirmed
+            };
+        }
+        if (!isAlwaysClassifyTool && !preparedInvocation?.confirmationMessages?.title) {
+            return {
+                autoConfirmed
+            };
+        }
+        if (this._configurationService.getValue(ChatConfiguration.AutopilotAdvancedEnabled) !== true) {
+            return {
+                autoConfirmed
+            };
+        }
+        const sessionResource = dto.context?.sessionResource;
+        if (!sessionResource || getChatSessionType(sessionResource) !== localChatSessionType) {
+            return {
+                autoConfirmed
+            };
+        }
+        if (!this._isSessionInAutopilotLevel(sessionResource)) {
+            return {
+                autoConfirmed
+            };
+        }
+        try {
+            const assessment = await this._riskAssessmentService.assess(tool.data, dto.parameters, token, undefined, {
+                ignoreEnablement: true
+            });
+            if (token.isCancellationRequested) {
+                return {
+                    autoConfirmed
+                };
+            }
+            if (assessment?.risk === ToolRiskLevel.Red) {
+                const fallbackExplanation = ( localize(
+                    7719,
+                    "The action was assessed as potentially destructive or irreversible."
+                ));
+                const explanation = assessment.explanation.trim() || fallbackExplanation;
+                this._logService.info(
+                    `[LanguageModelToolsService#invokeTool] Autopilot skipping high-risk tool ${tool.data.id}: ${explanation}`
+                );
+                return {
+                    autoConfirmed: {
+                        type: ToolConfirmKind.Skipped
+                    },
+                    skipExplanation: explanation
+                };
+            }
+        } catch (err) {
+            this._logService.warn(
+                `[LanguageModelToolsService#invokeTool] Autopilot risk assessment failed for tool ${tool.data.id}, allowing: ${toErrorMessage(err)}`
+            );
+        }
+        return {
+            autoConfirmed
+        };
+    }
     async prepareToolInvocation(tool, dto, forceConfirmationReason, token) {
         let prepared;
         if (tool.impl.prepareToolInvocation) {
@@ -853,17 +955,17 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(7202, "Confirm tool execution")),
-                message: ( localize(7203, "Run the '{0}' tool?", fullReferenceName)),
+                title: ( localize(7720, "Confirm tool execution")),
+                message: ( localize(7721, "Run the '{0}' tool?", fullReferenceName)),
                 disclaimer: ( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) ? undefined : ( new MarkdownString(( localize(
-                    7204,
+                    7722,
                     "Auto approval for '{0}' is restricted via {1}.",
                     getToolFullReferenceName(tool.data),
                     createMarkdownCommandLink({
                         text: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
                         id: "workbench.action.openSettings",
                         arguments: [ChatConfiguration.EligibleForAutoApproval],
-                        tooltip: ( localize(7205, "Open settings to configure auto-approval"))
+                        tooltip: ( localize(7723, "Open settings to configure auto-approval"))
                     }, false)
                 )), {
                     isTrusted: true
@@ -873,14 +975,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
             prepared.confirmationMessages.disclaimer = ( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) ? undefined : ( new MarkdownString(( localize(
-                7204,
+                7722,
                 "Auto approval for '{0}' is restricted via {1}.",
                 getToolFullReferenceName(tool.data),
                 createMarkdownCommandLink({
                     text: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
                     id: "workbench.action.openSettings",
                     arguments: [ChatConfiguration.EligibleForAutoApproval],
-                    tooltip: ( localize(7205, "Open settings to configure auto-approval"))
+                    tooltip: ( localize(7723, "Open settings to configure auto-approval"))
                 }, false)
             )), {
                 isTrusted: true
@@ -1068,6 +1170,18 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         const request = model?.getRequests().at(-1);
         return isAutoApproveLevel(request?.modeInfo?.permissionLevel) || this._isSessionLiveAutoApproveLevel(chatSessionResource);
     }
+    _isSessionLiveAutopilotLevel(chatSessionResource) {
+        const widget = this._chatWidgetService.getWidgetBySessionResource(chatSessionResource) ?? this._chatWidgetService.lastFocusedWidget;
+        return !!widget && isAutopilotLevel(widget.input.currentModeInfo.permissionLevel);
+    }
+    _isSessionInAutopilotLevel(chatSessionResource) {
+        if (!chatSessionResource) {
+            return false;
+        }
+        const model = this._chatService.getSession(chatSessionResource);
+        const request = model?.getRequests().at(-1);
+        return isAutopilotLevel(request?.modeInfo?.permissionLevel) || this._isSessionLiveAutopilotLevel(chatSessionResource);
+    }
     getEligibleForAutoApprovalSpecialCase(toolData) {
         if (toolData.id === "vscode_fetchWebPage_internal") {
             return "fetch";
@@ -1121,7 +1235,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             if (!(( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) && getChatSessionType(chatSessionResource) !== localChatSessionType)) {
                 return {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: "auto-approve-all"
+                    reason: autoApproveAllReason
                 };
             }
         }
@@ -1172,7 +1286,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             if (!(( toolIdsThatCannotBeAutoApproved.has(toolId)) && getChatSessionType(chatSessionResource) !== localChatSessionType)) {
                 return {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: "auto-approve-all"
+                    reason: autoApproveAllReason
                 };
             }
         }
@@ -1232,12 +1346,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }));
             const promptResult = await this._dialogService.prompt({
                 type: Severity.Warning,
-                message: ( localize(7206, "Enable global auto approve?")),
+                message: ( localize(7724, "Enable global auto approve?")),
                 buttons: [{
-                    label: ( localize(7207, "Enable")),
+                    label: ( localize(7725, "Enable")),
                     run: () => true
                 }, {
-                    label: ( localize(7208, "Disable")),
+                    label: ( localize(7726, "Disable")),
                     run: () => false
                 }],
                 custom: {
@@ -1398,21 +1512,32 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 result.set(toolSet, enabled);
             }
         }
-        return result;
+        return ToolAndToolSetEnablementMap.fromMap(result);
     }
     toFullReferenceNames(map) {
         const result = [];
         const toolsCoveredByEnabledToolSet = ( new Set());
+        const enabledToolSetIds = ( new Set());
+        const enabledToolIds = ( new Set());
+        for (const [tool, enabled] of map) {
+            if (enabled) {
+                if (isToolSet(tool)) {
+                    enabledToolSetIds.add(tool.id);
+                } else {
+                    enabledToolIds.add(tool.id);
+                }
+            }
+        }
         for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
             if (isToolSet(tool)) {
-                if (map.get(tool)) {
+                if (( enabledToolSetIds.has(tool.id))) {
                     result.push(fullReferenceName);
                     for (const memberTool of tool.getTools()) {
                         toolsCoveredByEnabledToolSet.add(memberTool);
                     }
                 }
             } else {
-                if (map.get(tool) && !( toolsCoveredByEnabledToolSet.has(tool))) {
+                if (( enabledToolIds.has(tool.id)) && !( toolsCoveredByEnabledToolSet.has(tool))) {
                     result.push(fullReferenceName);
                 }
             }
@@ -1484,7 +1609,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             options?.icon ?? Codicon.tools,
             source,
             options?.description,
+            options?.detail,
             options?.legacyFullNames,
+            options?.deprecated,
+            options?.hiddenInToolsPicker,
             this._contextKeyService
         );
         this._toolSets.add(result);
@@ -1567,8 +1695,15 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return getToolFullReferenceName(tool, toolSet);
     }
+    getFullReferenceNameMap() {
+        const result = ( new Map());
+        for (const [item, toolFullReferenceName] of this.toolsWithFullReferenceName.get()) {
+            result.set(item, toolFullReferenceName);
+        }
+        return result;
+    }
 };
-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)), ( __param(14, IToolResultCompressor))], 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)), ( __param(14, IToolResultCompressor)), ( __param(15, IChatToolRiskAssessmentService))], LanguageModelToolsService));
 function getToolFullReferenceName(tool, toolSet) {
     const toolName = tool.toolReferenceName ?? tool.displayName;
     if (toolSet) {

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

@@ -18,7 +18,7 @@ import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { ToolDataSource } 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 { createToolSimpleTextResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolHelpers';
-import { resolveToolUri, errorResult, findLineNumber, findSymbolColumn } from './toolHelpers.js';
+import { resolveSymbolToolFileUri, errorResult, findLineNumber, findSymbolColumn } from './toolHelpers.js';
 
 const RenameToolId = "vscode_renameSymbol";
 const BaseModelDescription = `Rename a code symbol across the workspace using the language server's rename functionality. This performs a precise, semantics-aware rename that updates all references.
@@ -52,7 +52,7 @@ let RenameTool = class RenameTool extends Disposable {
         this._bulkEditService = _bulkEditService;
     }
     getToolData() {
-        return this._buildToolData(StaticModelDescription, ( localize(7209, "Rename a symbol across the workspace")));
+        return this._buildToolData(StaticModelDescription, ( localize(7727, "Rename a symbol across the workspace")));
     }
     _buildToolData(modelDescription, userDescription) {
         return {
@@ -60,7 +60,7 @@ let RenameTool = class RenameTool extends Disposable {
             toolReferenceName: "rename",
             canBeReferencedInPrompt: false,
             icon: ThemeIcon.fromId(Codicon.rename.id),
-            displayName: ( localize(7210, "Rename Symbol")),
+            displayName: ( localize(7728, "Rename Symbol")),
             userDescription,
             modelDescription,
             source: ToolDataSource.Internal,
@@ -95,12 +95,12 @@ let RenameTool = class RenameTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const input = context.parameters;
         return {
-            invocationMessage: ( localize(7211, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
+            invocationMessage: ( localize(7729, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const input = invocation.parameters;
-        const uri = resolveToolUri(input, this._workspaceContextService, invocation.context?.workingDirectory);
+        const uri = resolveSymbolToolFileUri(input, this._workspaceContextService, invocation.context?.workingDirectory);
         if (!uri) {
             return errorResult(
                 "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify the file."
@@ -183,13 +183,13 @@ let RenameTool = class RenameTool extends Disposable {
     }
     _successResult(input, fileCount, editCount) {
         const text = editCount === 1 ? ( localize(
-            7212,
+            7730,
             "Renamed `{0}` to `{1}` - 1 edit in {2} file.",
             input.symbol,
             input.newName,
             fileCount
         )) : ( localize(
-            7213,
+            7731,
             "Renamed `{0}` to `{1}` - {2} edits across {3} files.",
             input.symbol,
             input.newName,

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

@@ -16,8 +16,12 @@ export interface ISymbolToolInput {
  * Resolves a URI from tool input. Accepts either a full URI string or a
  * workspace-relative file path. When a {@link workingDirectory} is provided
  * (agents window), relative paths are resolved against it first.
+ *
+ * Relative paths that escape the resolution base directory via parent-directory
+ * segments (e.g. `../outside.ts`) are rejected and `undefined` is returned, so a
+ * `filePath` cannot traverse out of the working directory boundary.
  */
-export declare function resolveToolUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService, workingDirectory?: URI): URI | undefined;
+export declare function resolveSymbolToolFileUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService, workingDirectory?: URI): URI | undefined;
 /**
  * Gets the chat permission level that should apply to a tool invocation.
  *

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

@@ -6,7 +6,7 @@ import { ChatPermissionLevel, isAutoApproveLevel } from '@codingame/monaco-vscod
 import { createToolSimpleTextResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolHelpers';
 import { WorkingDirectory } from '../../common/workingDirectory.js';
 
-function resolveToolUri(input, workspaceContextService, workingDirectory) {
+function resolveSymbolToolFileUri(input, workspaceContextService, workingDirectory) {
     if (input.uri) {
         return ( URI.parse(input.uri));
     }
@@ -60,4 +60,4 @@ function errorResult(message) {
     return result;
 }
 
-export { errorResult, findLineNumber, findSymbolColumn, getChatPermissionLevelForToolInvocation, getSandboxPrecheckInputsForToolInvocation, resolveToolUri };
+export { errorResult, findLineNumber, findSymbolColumn, getChatPermissionLevelForToolInvocation, getSandboxPrecheckInputsForToolInvocation, resolveSymbolToolFileUri };

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

@@ -21,7 +21,7 @@ import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { ToolDataSource } 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 { createToolSimpleTextResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolHelpers';
-import { resolveToolUri, errorResult, findLineNumber, findSymbolColumn } from './toolHelpers.js';
+import { resolveSymbolToolFileUri, errorResult, findLineNumber, findSymbolColumn } from './toolHelpers.js';
 
 const UsagesToolId = "vscode_listCodeUsages";
 const BaseModelDescription = `Find all usages (references, definitions, and implementations) of a code symbol across the workspace. This tool locates where a symbol is referenced, defined, or implemented.
@@ -54,7 +54,7 @@ let UsagesTool = class UsagesTool extends Disposable {
         this._workspaceContextService = _workspaceContextService;
     }
     getToolData() {
-        return this._buildToolData(StaticModelDescription, ( localize(7227, "Find references, definitions, and implementations of a symbol")));
+        return this._buildToolData(StaticModelDescription, ( localize(7749, "Find references, definitions, and implementations of a symbol")));
     }
     _buildToolData(modelDescription, userDescription) {
         return {
@@ -62,7 +62,7 @@ let UsagesTool = class UsagesTool extends Disposable {
             toolReferenceName: "usages",
             canBeReferencedInPrompt: false,
             icon: ThemeIcon.fromId(Codicon.references.id),
-            displayName: ( localize(7228, "List Code Usages")),
+            displayName: ( localize(7750, "List Code Usages")),
             userDescription,
             modelDescription,
             source: ToolDataSource.Internal,
@@ -93,12 +93,12 @@ let UsagesTool = class UsagesTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const input = context.parameters;
         return {
-            invocationMessage: ( localize(7229, "Analyzing usages of `{0}`", input.symbol))
+            invocationMessage: ( localize(7751, "Analyzing usages of `{0}`", input.symbol))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const input = invocation.parameters;
-        const uri = resolveToolUri(input, this._workspaceContextService, invocation.context?.workingDirectory);
+        const uri = resolveSymbolToolFileUri(input, this._workspaceContextService, invocation.context?.workingDirectory);
         if (!uri) {
             return errorResult(
                 "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify the file."
@@ -146,7 +146,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(7230, "Analyzed usages of `{0}`, no results", input.symbol))));
+                result.toolResultMessage = ( new MarkdownString(( localize(7752, "Analyzed usages of `{0}`, no results", input.symbol))));
                 return result;
             }
             const previews = await this._getLinePreviews(input.symbol, references, token);
@@ -167,8 +167,8 @@ let UsagesTool = class UsagesTool extends Disposable {
             }
             const text = lines.join("\n");
             const result = createToolSimpleTextResult(text);
-            result.toolResultMessage = references.length === 1 ? ( new MarkdownString(( localize(7231, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
-                7232,
+            result.toolResultMessage = references.length === 1 ? ( new MarkdownString(( localize(7753, "Analyzed usages of `{0}`, 1 result", input.symbol)))) : ( new MarkdownString(( localize(
+                7754,
                 "Analyzed usages of `{0}`, {1} results",
                 input.symbol,
                 references.length

package/vscode/src/vs/workbench/contrib/chat/browser/utilityModelContribution.js

@@ -8,8 +8,8 @@ import { COPILOT_VENDOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { createDefaultModelArrays, DefaultModelContribution } from './defaultModelContribution.js';
 
-const defaultEntryLabel = ( localize(7233, "Default"));
-const defaultEntryDescription = ( localize(7234, "Use the built-in default utility model"));
+const defaultEntryLabel = ( localize(7755, "Default"));
+const defaultEntryDescription = ( localize(7756, "Use the default behavior for utility models"));
 const utilityArrays = createDefaultModelArrays(defaultEntryLabel, defaultEntryDescription);
 const utilitySmallArrays = createDefaultModelArrays(defaultEntryLabel, defaultEntryDescription);
 let UtilityModelContribution = class UtilityModelContribution extends DefaultModelContribution {

package/vscode/src/vs/workbench/contrib/chat/browser/viewsWelcome/chatViewsWelcomeHandler.js

@@ -17,29 +17,29 @@ const chatViewsWelcomeJsonSchema = {
     properties: {
         icon: {
             type: "string",
-            description: ( localize(7235, "The icon for the welcome message."))
+            description: ( localize(7757, "The icon for the welcome message."))
         },
         title: {
             type: "string",
-            description: ( localize(7236, "The title of the welcome message."))
+            description: ( localize(7758, "The title of the welcome message."))
         },
         content: {
             type: "string",
             description: ( localize(
-                7237,
+                7759,
                 "The content of the welcome message. The first command link will be rendered as a button."
             ))
         },
         when: {
             type: "string",
-            description: ( localize(7238, "Condition when the welcome message is shown."))
+            description: ( localize(7760, "Condition when the welcome message is shown."))
         }
     }
 };
 const chatViewsWelcomeExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatViewsWelcome",
     jsonSchema: {
-        description: ( localize(7239, "Contributes a welcome message to a chat view")),
+        description: ( localize(7761, "Contributes a welcome message to a chat view")),
         type: "array",
         items: chatViewsWelcomeJsonSchema
     }