@codingame/monaco-vscode-chat-service-override 31.0.1 → 32.0.0

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

@@ -23,6 +23,7 @@ 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 { IToolResultCompressor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/toolResultCompressor.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"
@@ -43,6 +44,7 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     private readonly _confirmationService;
     private readonly _commandService;
     private readonly _chatWidgetService;
+    private readonly _toolResultCompressor;
     _serviceBrand: undefined;
     readonly vscodeToolSet: ToolSet;
     readonly executeToolSet: ToolSet;
@@ -68,7 +70,7 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     /** 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, _chatWidgetService: IChatWidgetService);
+    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, _toolResultCompressor: IToolResultCompressor);
     /**
      * Returns if the given tool or toolset is permitted in the current context.
      * When agent mode is enabled, all tools are permitted (no restriction)
@@ -95,6 +97,7 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     private _validateUpdatedInput;
     invokeTool(dto: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
     private prepareToolInvocationWithHookResult;
+    private _logToolApprovalTelemetry;
     /**
      * Determines the auto-confirm decision based on a preToolUse hook result.
      * If the hook returned 'allow', auto-approves. If 'ask', forces confirmation
@@ -131,6 +134,11 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
      * so switching to Autopilot mid-session takes effect immediately.
      */
     private _isSessionLiveAutoApproveLevel;
+    /**
+     * True if the session is in an auto-approve level (Auto-Approve / Autopilot),
+     * via either the last request's stamped level or the live picker level.
+     */
+    private _isSessionInAutoApproveLevel;
     private getEligibleForAutoApprovalSpecialCase;
     private isToolEligibleForAutoApproval;
     private shouldAutoConfirm;

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

@@ -47,6 +47,7 @@ import { chatSessionResourceToId, getChatSessionType } from '@codingame/monaco-v
 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 { 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 { ObservableSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/set';
@@ -67,7 +68,7 @@ const toolIdsThatCannotBeAutoApproved = ( new Set([
     "vscode_get_modified_files_confirmation"
 ]));
 const globalAutoApproveDescription = ( localize2(
-    6739,
+    6987,
     "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 {
@@ -88,7 +89,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         _storageService,
         _confirmationService,
         _commandService,
-        _chatWidgetService
+        _chatWidgetService,
+        _toolResultCompressor
     ) {
         super();
         this._instantiationService = _instantiationService;
@@ -105,6 +107,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this._confirmationService = _confirmationService;
         this._commandService = _commandService;
         this._chatWidgetService = _chatWidgetService;
+        this._toolResultCompressor = _toolResultCompressor;
         this._onDidChangeTools = this._register(( new Emitter()));
         this.onDidChangeTools = this._onDidChangeTools.event;
         this._onDidPrepareToolCallBecomeUnresponsive = this._register(( new Emitter()));
@@ -170,25 +173,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(6740, "Use VS Code features"))
+                description: ( localize(6988, "Use VS Code features"))
             })
         );
         this.executeToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "execute", SpecedToolAliases.execute, {
                 icon: ThemeIcon.fromId(Codicon.terminal.id),
-                description: ( localize(6741, "Execute code and applications on your machine"))
+                description: ( localize(6989, "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(6742, "Read files in your workspace"))
+                description: ( localize(6990, "Read files in your workspace"))
             })
         );
         this.agentToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "agent", SpecedToolAliases.agent, {
                 icon: ThemeIcon.fromId(Codicon.agent.id),
-                description: ( localize(6743, "Delegate tasks to other agents"))
+                description: ( localize(6991, "Delegate tasks to other agents"))
             })
         );
     }
@@ -342,8 +345,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     _handlePreToolUseDenial(dto, hookResult, toolData, pendingInvocation, request) {
-        const hookReason = hookResult.permissionDecisionReason ?? ( localize(6744, "Hook denied tool execution"));
-        const reason = ( localize(6745, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
+        const hookReason = hookResult.permissionDecisionReason ?? ( localize(6992, "Hook denied tool execution"));
+        const reason = ( localize(6993, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
         this._logService.debug(
             `[LanguageModelToolsService#invokeTool] Tool ${dto.toolId} denied by preToolUse hook: ${hookReason}`
         );
@@ -405,6 +408,15 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 );
                 throw ( new CancellationError());
             }
+            if (model?.workingDirectory && !dto.context.workingDirectory) {
+                dto = {
+                    ...dto,
+                    context: {
+                        ...dto.context,
+                        workingDirectory: model.workingDirectory
+                    }
+                };
+            }
         }
         let pendingToolCallKey;
         let toolInvocation;
@@ -537,6 +549,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                         this.playAccessibilitySignal([toolInvocation], dto.context?.sessionResource);
                     }
                     const userConfirmed = await IChatToolInvocation.awaitConfirmation(toolInvocation, token);
+                    this._logToolApprovalTelemetry(tool, dto, userConfirmed);
                     if (userConfirmed.type === ToolConfirmKind.Denied) {
                         throw ( new CancellationError());
                     }
@@ -556,6 +569,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                         dto.parameters = dto.toolSpecificData.rawInput;
                         dto.toolSpecificData = undefined;
                     }
+                } else {
+                    this._logToolApprovalTelemetry(tool, dto, autoConfirmed ?? {
+                        type: ToolConfirmKind.ConfirmationNotNeeded
+                    });
                 }
             } else {
                 prepareTimeWatch = StopWatch.create(true);
@@ -587,6 +604,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 }
             }, token);
             invocationTimeWatch.stop();
+            const compressed = this._toolResultCompressor.maybeCompress(tool.data.id, dto.parameters, toolResult);
+            if (compressed) {
+                toolResult = compressed;
+            }
             this.ensureToolDetails(dto, toolResult, tool.data, toolInvocation);
             const afterExecuteState = await toolInvocation?.didExecuteTool(toolResult, undefined, () => this.shouldAutoConfirmPostExecution(
                 tool.data.id,
@@ -594,7 +615,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 tool.data.source,
                 dto.parameters,
                 dto.context?.sessionResource,
-                dto.chatRequestId
+                dto.chatRequestId,
+                dto.context?.workingDirectory
             ));
             if (toolInvocation && afterExecuteState?.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                 const postConfirm = await IChatToolInvocation.awaitPostConfirmation(toolInvocation, token);
@@ -662,11 +684,41 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async prepareToolInvocationWithHookResult(tool, dto, hookResult, token) {
         let forceConfirmationReason;
         if (hookResult?.permissionDecision === "ask") {
-            const hookMessage = ( localize(6746, "{0} required confirmation", HookType.PreToolUse));
+            const hookMessage = ( localize(6994, "{0} required confirmation", HookType.PreToolUse));
             forceConfirmationReason = hookResult.permissionDecisionReason ? `${hookMessage}: ${hookResult.permissionDecisionReason}` : hookMessage;
         }
         return this.prepareToolInvocation(tool, dto, forceConfirmationReason, token);
     }
+    _logToolApprovalTelemetry(tool, dto, reason) {
+        const confirmKindNames = {
+            [ToolConfirmKind.Denied]: "denied",
+            [ToolConfirmKind.ConfirmationNotNeeded]: "confirmationNotNeeded",
+            [ToolConfirmKind.Setting]: "setting",
+            [ToolConfirmKind.LmServicePerTool]: "lmServicePerTool",
+            [ToolConfirmKind.UserAction]: "userAction",
+            [ToolConfirmKind.Skipped]: "skipped"
+        };
+        const allowedConfirmationNotNeededReasons = ( new Set(["auto-approve-all", "inlineChat"]));
+        let confirmationNotNeededReason;
+        if (reason.type === ToolConfirmKind.ConfirmationNotNeeded && reason.reason) {
+            const raw = typeof reason.reason === "string" ? reason.reason : reason.reason.value;
+            confirmationNotNeededReason = ( allowedConfirmationNotNeededReasons.has(raw)) ? raw : "other";
+        }
+        const terminalData = dto.toolSpecificData?.kind === "terminal" ? dto.toolSpecificData : undefined;
+        this._telemetryService.publicLog2("chat.toolApproval", {
+            confirmKind: confirmKindNames[reason.type],
+            settingId: reason.type === ToolConfirmKind.Setting ? reason.id : undefined,
+            lmServiceScope: reason.type === ToolConfirmKind.LmServicePerTool ? reason.scope : undefined,
+            customButtonKind: reason.type === ToolConfirmKind.UserAction ? reason.selectedButtonKind : undefined,
+            confirmationNotNeededReason,
+            sandboxWrapped: terminalData?.commandLine.isSandboxWrapped,
+            requestUnsandboxedExecution: terminalData?.requestUnsandboxedExecution,
+            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
+        });
+    }
     async resolveAutoConfirmFromHook(hookResult, tool, dto, preparedInvocation, sessionResource) {
         if (hookResult?.permissionDecision === "allow") {
             this._logService.debug(
@@ -675,7 +727,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             return {
                 autoConfirmed: {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: ( localize(6747, "Allowed by hook"))
+                    reason: ( localize(6995, "Allowed by hook"))
                 },
                 preparedInvocation
             };
@@ -691,14 +743,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 const fullReferenceName = getToolFullReferenceName(tool.data);
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    6748,
+                    6996,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(6749, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(6997, "{0} hook required confirmation", HookType.PreToolUse));
                 preparedInvocation.confirmationMessages = {
                     ...preparedInvocation.confirmationMessages,
-                    title: ( localize(6750, "Use the '{0}' tool?", fullReferenceName)),
+                    title: ( localize(6998, "Use the '{0}' tool?", fullReferenceName)),
                     message: ( new MarkdownString(`_${hookNote}_`)),
                     allowAutoConfirm: false
                 };
@@ -709,11 +761,11 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             } else {
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    6751,
+                    6999,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(6752, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(7000, "{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;
@@ -752,7 +804,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             dto.parameters,
             sessionResource,
             dto.chatRequestId,
-            combination
+            combination,
+            dto.context?.workingDirectory
         );
         return {
             autoConfirmed,
@@ -769,7 +822,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 chatSessionResource: dto.context?.sessionResource,
                 chatInteractionId: dto.chatInteractionId,
                 modelId: dto.modelId,
-                forceConfirmationReason: forceConfirmationReason
+                forceConfirmationReason: forceConfirmationReason,
+                workingDirectory: dto.context?.workingDirectory
             }, token);
             const raceResult = await Promise.race([timeout(3000, token).then(() => "timeout"), preparePromise]);
             if (raceResult === "timeout" && dto.context) {
@@ -788,17 +842,17 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(6753, "Confirm tool execution")),
-                message: ( localize(6754, "Run the '{0}' tool?", fullReferenceName)),
+                title: ( localize(7001, "Confirm tool execution")),
+                message: ( localize(7002, "Run the '{0}' tool?", fullReferenceName)),
                 disclaimer: ( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) ? undefined : ( new MarkdownString(( localize(
-                    6755,
+                    7003,
                     "Auto approval for '{0}' is restricted via {1}.",
                     getToolFullReferenceName(tool.data),
                     createMarkdownCommandLink({
                         text: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
                         id: "workbench.action.openSettings",
                         arguments: [ChatConfiguration.EligibleForAutoApproval],
-                        tooltip: ( localize(6756, "Open settings to configure auto-approval"))
+                        tooltip: ( localize(7004, "Open settings to configure auto-approval"))
                     }, false)
                 )), {
                     isTrusted: true
@@ -808,14 +862,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
             prepared.confirmationMessages.disclaimer = ( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) ? undefined : ( new MarkdownString(( localize(
-                6755,
+                7003,
                 "Auto approval for '{0}' is restricted via {1}.",
                 getToolFullReferenceName(tool.data),
                 createMarkdownCommandLink({
                     text: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
                     id: "workbench.action.openSettings",
                     arguments: [ChatConfiguration.EligibleForAutoApproval],
-                    tooltip: ( localize(6756, "Open settings to configure auto-approval"))
+                    tooltip: ( localize(7004, "Open settings to configure auto-approval"))
                 }, false)
             )), {
                 isTrusted: true
@@ -995,6 +1049,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         const widget = this._chatWidgetService.getWidgetBySessionResource(chatSessionResource) ?? this._chatWidgetService.lastFocusedWidget;
         return !!widget && isAutoApproveLevel(widget.input.currentModeInfo.permissionLevel);
     }
+    _isSessionInAutoApproveLevel(chatSessionResource) {
+        if (!chatSessionResource) {
+            return false;
+        }
+        const model = this._chatService.getSession(chatSessionResource);
+        const request = model?.getRequests().at(-1);
+        return isAutoApproveLevel(request?.modeInfo?.permissionLevel) || this._isSessionLiveAutoApproveLevel(chatSessionResource);
+    }
     getEligibleForAutoApprovalSpecialCase(toolData) {
         if (toolData.id === "vscode_fetchWebPage_internal") {
             return "fetch";
@@ -1037,22 +1099,19 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         parameters,
         chatSessionResource,
         chatRequestId,
-        combination
+        combination,
+        workingDirectory
     ) {
         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)) {
-                if (!(( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) && getChatSessionType(chatSessionResource) !== localChatSessionType)) {
-                    return {
-                        type: ToolConfirmKind.ConfirmationNotNeeded,
-                        reason: "auto-approve-all"
-                    };
-                }
+        if (chatSessionResource && !this._isAutoApprovePolicyRestricted() && this._isSessionInAutoApproveLevel(chatSessionResource)) {
+            if (!(( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) && getChatSessionType(chatSessionResource) !== localChatSessionType)) {
+                return {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: "auto-approve-all"
+                };
             }
         }
         if (!this.isToolEligibleForAutoApproval(tool.data)) {
@@ -1063,6 +1122,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             source,
             parameters,
             chatSessionResource,
+            workingDirectory,
             combination
         });
         if (reason) {
@@ -1093,21 +1153,19 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         source,
         parameters,
         chatSessionResource,
-        chatRequestId
+        chatRequestId,
+        workingDirectory
     ) {
-        if (chatSessionResource && !this._isAutoApprovePolicyRestricted()) {
-            const model = this._chatService.getSession(chatSessionResource);
-            const request = model?.getRequests().at(-1);
-            if (isAutoApproveLevel(request?.modeInfo?.permissionLevel) || this._isSessionLiveAutoApproveLevel(chatSessionResource)) {
-                if (!(( toolIdsThatCannotBeAutoApproved.has(toolId)) && getChatSessionType(chatSessionResource) !== localChatSessionType)) {
-                    return {
-                        type: ToolConfirmKind.ConfirmationNotNeeded,
-                        reason: "auto-approve-all"
-                    };
-                }
+        const sessionAutoApprove = chatSessionResource && !this._isAutoApprovePolicyRestricted() && this._isSessionInAutoApproveLevel(chatSessionResource);
+        if (sessionAutoApprove) {
+            if (!(( toolIdsThatCannotBeAutoApproved.has(toolId)) && getChatSessionType(chatSessionResource) !== localChatSessionType)) {
+                return {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: "auto-approve-all"
+                };
             }
         }
-        if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove) && (await this._checkGlobalAutoApprove())) {
+        if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove) && !sessionAutoApprove && (await this._checkGlobalAutoApprove())) {
             return {
                 type: ToolConfirmKind.Setting,
                 id: ChatConfiguration.GlobalAutoApprove
@@ -1117,7 +1175,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             toolId,
             source,
             parameters,
-            chatSessionResource
+            chatSessionResource,
+            workingDirectory
         });
     }
     async _checkGlobalAutoApprove() {
@@ -1162,12 +1221,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }));
             const promptResult = await this._dialogService.prompt({
                 type: Severity.Warning,
-                message: ( localize(6757, "Enable global auto approve?")),
+                message: ( localize(7005, "Enable global auto approve?")),
                 buttons: [{
-                    label: ( localize(6758, "Enable")),
+                    label: ( localize(7006, "Enable")),
                     run: () => true
                 }, {
-                    label: ( localize(6759, "Disable")),
+                    label: ( localize(7007, "Disable")),
                     run: () => false
                 }],
                 custom: {
@@ -1498,7 +1557,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)), ( __param(13, IChatWidgetService))], 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))], LanguageModelToolsService));
 function getToolFullReferenceName(tool, toolSet) {
     const toolName = tool.toolReferenceName ?? tool.displayName;
     if (toolSet) {

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

@@ -1,10 +1,8 @@
 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 { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.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";
@@ -14,15 +12,13 @@ import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/
 export declare const RenameToolId = "vscode_renameSymbol";
 export declare class RenameTool extends Disposable implements IToolImpl {
     private readonly _languageFeaturesService;
-    private readonly _languageService;
     private readonly _textModelService;
     private readonly _workspaceContextService;
     private readonly _chatService;
     private readonly _bulkEditService;
-    private readonly _onDidUpdateToolData;
-    readonly onDidUpdateToolData: Event<void>;
-    constructor(_languageFeaturesService: ILanguageFeaturesService, _languageService: ILanguageService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService, _chatService: IChatService, _bulkEditService: IBulkEditService);
-    getToolData(): IToolData | undefined;
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService, _chatService: IChatService, _bulkEditService: IBulkEditService);
+    getToolData(): IToolData;
+    private _buildToolData;
     prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
     private _successResult;

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

@@ -1,7 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
@@ -11,7 +10,6 @@ import { ResourceTextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/
 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 { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
 import { rename } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/rename/browser/rename';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
@@ -36,10 +34,12 @@ Input:
 IMPORTANT: The file and line do NOT need to be the definition of the symbol. Any occurrence works - a usage, an import, a call site, etc. You can pick whichever occurrence is most convenient.
 
 If the tool returns an error, retry with corrected input - ensure the file path is correct, the line content matches the actual file content, and the symbol name appears in that line.`;
+const StaticModelDescription = BaseModelDescription + `
+
+If the file's language has no rename provider registered, the tool returns an error.`;
 let RenameTool = class RenameTool extends Disposable {
     constructor(
         _languageFeaturesService,
-        _languageService,
         _textModelService,
         _workspaceContextService,
         _chatService,
@@ -47,39 +47,21 @@ let RenameTool = class RenameTool extends Disposable {
     ) {
         super();
         this._languageFeaturesService = _languageFeaturesService;
-        this._languageService = _languageService;
         this._textModelService = _textModelService;
         this._workspaceContextService = _workspaceContextService;
         this._chatService = _chatService;
         this._bulkEditService = _bulkEditService;
-        this._onDidUpdateToolData = this._store.add(( new Emitter()));
-        this.onDidUpdateToolData = this._onDidUpdateToolData.event;
-        this._store.add(
-            Event.debounce(this._languageFeaturesService.renameProvider.onDidChange, () => {}, 2000)((() => this._onDidUpdateToolData.fire()))
-        );
     }
     getToolData() {
-        const languageIds = this._languageFeaturesService.renameProvider.registeredLanguageIds;
-        if (languageIds.size === 0) {
-            return undefined;
-        }
-        let modelDescription = BaseModelDescription;
-        let userDescription;
-        if (( languageIds.has("*"))) {
-            modelDescription += "\n\nSupported for all languages.";
-            userDescription = ( localize(6760, "Rename a symbol across the workspace"));
-        } else {
-            const sorted = [...languageIds].sort();
-            modelDescription += `\n\nCurrently supported for: ${sorted.join(", ")}.`;
-            const niceNames = ( sorted.map(id => this._languageService.getLanguageName(id) ?? id));
-            userDescription = ( localize(6761, "Rename a symbol across the workspace ({0})", niceNames.join(", ")));
-        }
+        return this._buildToolData(StaticModelDescription, ( localize(7008, "Rename a symbol across the workspace")));
+    }
+    _buildToolData(modelDescription, userDescription) {
         return {
             id: RenameToolId,
             toolReferenceName: "rename",
             canBeReferencedInPrompt: false,
             icon: ThemeIcon.fromId(Codicon.rename.id),
-            displayName: ( localize(6762, "Rename Symbol")),
+            displayName: ( localize(7009, "Rename Symbol")),
             userDescription,
             modelDescription,
             source: ToolDataSource.Internal,
@@ -115,12 +97,12 @@ let RenameTool = class RenameTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const input = context.parameters;
         return {
-            invocationMessage: ( localize(6763, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
+            invocationMessage: ( localize(7010, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const input = invocation.parameters;
-        const uri = resolveToolUri(input, this._workspaceContextService);
+        const uri = resolveToolUri(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."
@@ -203,13 +185,13 @@ let RenameTool = class RenameTool extends Disposable {
     }
     _successResult(input, fileCount, editCount) {
         const text = editCount === 1 ? ( localize(
-            6764,
+            7011,
             "Renamed `{0}` to `{1}` - 1 edit in {2} file.",
             input.symbol,
             input.newName,
             fileCount
         )) : ( localize(
-            6765,
+            7012,
             "Renamed `{0}` to `{1}` - {2} edits across {3} files.",
             input.symbol,
             input.newName,
@@ -221,7 +203,7 @@ let RenameTool = class RenameTool extends Disposable {
         return result;
     }
 };
-RenameTool = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, ILanguageService)), ( __param(2, ITextModelService)), ( __param(3, IWorkspaceContextService)), ( __param(4, IChatService)), ( __param(5, IBulkEditService))], RenameTool));
+RenameTool = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, ITextModelService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IChatService)), ( __param(4, IBulkEditService))], RenameTool));
 let RenameToolContribution = class RenameToolContribution extends Disposable {
     static {
         this.ID = "chat.renameTool";
@@ -229,23 +211,7 @@ let RenameToolContribution = class RenameToolContribution extends Disposable {
     constructor(toolsService, instantiationService) {
         super();
         const renameTool = this._store.add(instantiationService.createInstance(RenameTool));
-        let registration;
-        const registerRenameTool = () => {
-            registration?.dispose();
-            registration = undefined;
-            toolsService.flushToolUpdates();
-            const toolData = renameTool.getToolData();
-            if (toolData) {
-                registration = toolsService.registerTool(toolData, renameTool);
-            }
-        };
-        registerRenameTool();
-        this._store.add(renameTool.onDidUpdateToolData(registerRenameTool));
-        this._store.add({
-            dispose: () => {
-                registration?.dispose();
-            }
-        });
+        this._store.add(toolsService.registerTool(renameTool.getToolData(), renameTool));
     }
 };
 RenameToolContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService))], RenameToolContribution));

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

@@ -10,9 +10,10 @@ export interface ISymbolToolInput {
 }
 /**
  * Resolves a URI from tool input. Accepts either a full URI string or a
- * workspace-relative file path.
+ * workspace-relative file path. When a {@link workingDirectory} is provided
+ * (agents window), relative paths are resolved against it first.
  */
-export declare function resolveToolUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService): URI | undefined;
+export declare function resolveToolUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService, workingDirectory?: URI): URI | undefined;
 /**
  * Finds the line number in the model that matches the given line content.
  * Whitespace is normalized so that extra spaces in the input still match.