@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -74,8 +74,8 @@ const toolIdsThatCannotBeAutoApproved = ( new Set([
 ]));
 const fetchWebPageToolIds = ( new Set(["copilot_fetchWebPage", "vscode_fetchWebPage_internal"]));
 const globalAutoApproveDescription = ( localize2(
-    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."
+    9061,
+    "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/agents/run/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 {
@@ -181,28 +181,28 @@ 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(7705, "Use VS Code features")),
+                description: ( localize(9062, "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(7706, "Execute code and applications on your machine")),
+                description: ( localize(9063, "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(7707, "Read files in your workspace")),
+                description: ( localize(9064, "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(7708, "Delegate tasks to other agents")),
+                description: ( localize(9065, "Delegate tasks to other agents")),
                 deprecated: true
             })
         );
@@ -366,8 +366,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     _handlePreToolUseDenial(dto, hookResult, toolData, pendingInvocation, request) {
-        const hookReason = hookResult.permissionDecisionReason ?? ( localize(7709, "Hook denied tool execution"));
-        const reason = ( localize(7710, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
+        const hookReason = hookResult.permissionDecisionReason ?? ( localize(9066, "Hook denied tool execution"));
+        const reason = ( localize(9067, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
         this._logService.debug(
             `[LanguageModelToolsService#invokeTool] Tool ${dto.toolId} denied by preToolUse hook: ${hookReason}`
         );
@@ -523,6 +523,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         let prepareTimeWatch;
         let invocationTimeWatch;
         let preparedInvocation;
+        let activeTool = tool;
         try {
             if (dto.context) {
                 if (!model) {
@@ -549,12 +550,17 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     dto.context?.sessionResource
                 );
                 preparedInvocation = updatedPreparedInvocation;
+                const preResolvedAutoConfirmed = resolvedAutoConfirmed ?? (preToolUseHookResult?.permissionDecision === "ask" ? undefined : dto.preApproved);
                 const {
                     autoConfirmed,
                     skipExplanation: riskSkipExplanation
-                } = await this._maybeApplyAutopilotRiskGate(tool, dto, preparedInvocation, resolvedAutoConfirmed, token);
+                } = await this._maybeApplyAutopilotRiskGate(tool, dto, preparedInvocation, preResolvedAutoConfirmed, token);
                 if (hadPendingInvocation && toolInvocation) {
-                    toolInvocation.transitionFromStreaming(preparedInvocation, dto.parameters, autoConfirmed);
+                    if (toolInvocation.state.get().type === IChatToolInvocation.StateKind.Streaming) {
+                        toolInvocation.transitionFromStreaming(preparedInvocation, dto.parameters, autoConfirmed);
+                    } else {
+                        toolInvocation.updatePreparedInvocation(preparedInvocation, dto.parameters);
+                    }
                 } else {
                     toolInvocation = ( new ChatToolInvocation(
                         preparedInvocation,
@@ -576,7 +582,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     this._chatService.appendProgress(request, {
                         kind: "info",
                         content: ( new MarkdownString(( localize(
-                            7711,
+                            9068,
                             "Autopilot skipped \"{0}\" because it was assessed as high-risk: {1}",
                             tool.data.displayName,
                             riskSkipExplanation
@@ -629,7 +635,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     preparedInvocation: updatedPreparedInvocation
                 } = await this.resolveAutoConfirmFromHook(preToolUseHookResult, tool, dto, preparedInvocation, undefined);
                 preparedInvocation = updatedPreparedInvocation;
-                if (preparedInvocation?.confirmationMessages?.title && !fallbackAutoConfirmed) {
+                const autoConfirmed = fallbackAutoConfirmed ?? (preToolUseHookResult?.permissionDecision === "ask" ? undefined : dto.preApproved);
+                if (preparedInvocation?.confirmationMessages?.title && !autoConfirmed) {
                     const result = await this._dialogService.confirm({
                         message: renderAsPlaintext(preparedInvocation.confirmationMessages.title),
                         detail: renderAsPlaintext(preparedInvocation.confirmationMessages.message)
@@ -644,21 +651,29 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 throw ( new CancellationError());
             }
             invocationTimeWatch = StopWatch.create(true);
-            toolResult = await tool.impl.invoke(dto, countTokens, {
+            const currentTool = this._tools.get(dto.toolId);
+            if (!currentTool) {
+                throw ( new Error(`Tool ${dto.toolId} was not contributed`));
+            }
+            if (!currentTool.impl) {
+                throw ( new Error(`Tool ${dto.toolId} does not have an implementation registered.`));
+            }
+            activeTool = currentTool;
+            toolResult = await currentTool.impl.invoke(dto, countTokens, {
                 report: step => {
                     toolInvocation?.acceptProgress(step);
                 }
             }, token);
             invocationTimeWatch.stop();
-            const compressed = this._toolResultCompressor.maybeCompress(tool.data.id, dto.parameters, toolResult);
+            const compressed = this._toolResultCompressor.maybeCompress(activeTool.data.id, dto.parameters, toolResult);
             if (compressed) {
                 toolResult = compressed;
             }
-            this.ensureToolDetails(dto, toolResult, tool.data, toolInvocation);
+            this.ensureToolDetails(dto, toolResult, activeTool.data, toolInvocation);
             const afterExecuteState = await toolInvocation?.didExecuteTool(toolResult, undefined, () => this.shouldAutoConfirmPostExecution(
-                tool.data.id,
-                tool.data.runsInWorkspace,
-                tool.data.source,
+                activeTool.data.id,
+                activeTool.data.runsInWorkspace,
+                activeTool.data.source,
                 dto.parameters,
                 dto.context?.sessionResource,
                 dto.chatRequestId,
@@ -681,9 +696,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             this._telemetryService.publicLog2("languageModelToolInvoked", {
                 result: "success",
                 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,
+                toolId: activeTool.data.id,
+                toolExtensionId: activeTool.data.source.type === "extension" ? activeTool.data.source.extensionId.value : undefined,
+                toolSourceKind: activeTool.data.source.type,
                 prepareTimeMs: prepareTimeWatch?.elapsed(),
                 invocationTimeMs: invocationTimeWatch?.elapsed()
             });
@@ -693,9 +708,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             this._telemetryService.publicLog2("languageModelToolInvoked", {
                 result,
                 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,
+                toolId: activeTool.data.id,
+                toolExtensionId: activeTool.data.source.type === "extension" ? activeTool.data.source.extensionId.value : undefined,
+                toolSourceKind: activeTool.data.source.type,
                 prepareTimeMs: prepareTimeWatch?.elapsed(),
                 invocationTimeMs: invocationTimeWatch?.elapsed()
             });
@@ -708,7 +723,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 content: []
             };
             toolResult.toolResultError = err instanceof Error ? err.message : String(err);
-            if (tool.data.alwaysDisplayInputOutput) {
+            if (activeTool.data.alwaysDisplayInputOutput) {
                 toolResult.toolResultDetails = {
                     input: this.formatToolInput(dto),
                     output: [{
@@ -730,7 +745,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async prepareToolInvocationWithHookResult(tool, dto, hookResult, token) {
         let forceConfirmationReason;
         if (hookResult?.permissionDecision === "ask") {
-            const hookMessage = ( localize(7712, "{0} required confirmation", HookType.PreToolUse));
+            const hookMessage = ( localize(9069, "{0} required confirmation", HookType.PreToolUse));
             forceConfirmationReason = hookResult.permissionDecisionReason ? `${hookMessage}: ${hookResult.permissionDecisionReason}` : hookMessage;
         }
         return this.prepareToolInvocation(tool, dto, forceConfirmationReason, token);
@@ -774,7 +789,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             return {
                 autoConfirmed: {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: ( localize(7713, "Allowed by hook"))
+                    reason: ( localize(9070, "Allowed by hook"))
                 },
                 preparedInvocation
             };
@@ -790,14 +805,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 const fullReferenceName = getToolFullReferenceName(tool.data);
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    7714,
+                    9071,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(7715, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(9072, "{0} hook required confirmation", HookType.PreToolUse));
                 preparedInvocation.confirmationMessages = {
                     ...preparedInvocation.confirmationMessages,
-                    title: ( localize(7716, "Use the '{0}' tool?", fullReferenceName)),
+                    title: ( localize(9073, "Use the '{0}' tool?", fullReferenceName)),
                     message: ( new MarkdownString(`_${hookNote}_`)),
                     allowAutoConfirm: false
                 };
@@ -808,11 +823,11 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             } else {
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    7717,
+                    9074,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(7718, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(9075, "{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;
@@ -902,7 +917,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
             if (assessment?.risk === ToolRiskLevel.Red) {
                 const fallbackExplanation = ( localize(
-                    7719,
+                    9076,
                     "The action was assessed as potentially destructive or irreversible."
                 ));
                 const explanation = assessment.explanation.trim() || fallbackExplanation;
@@ -955,17 +970,17 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(7720, "Confirm tool execution")),
-                message: ( localize(7721, "Run the '{0}' tool?", fullReferenceName)),
+                title: ( localize(9077, "Confirm tool execution")),
+                message: ( localize(9078, "Run the '{0}' tool?", fullReferenceName)),
                 disclaimer: ( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) ? undefined : ( new MarkdownString(( localize(
-                    7722,
+                    9079,
                     "Auto approval for '{0}' is restricted via {1}.",
                     getToolFullReferenceName(tool.data),
                     createMarkdownCommandLink({
                         text: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
                         id: "workbench.action.openSettings",
                         arguments: [ChatConfiguration.EligibleForAutoApproval],
-                        tooltip: ( localize(7723, "Open settings to configure auto-approval"))
+                        tooltip: ( localize(9080, "Open settings to configure auto-approval"))
                     }, false)
                 )), {
                     isTrusted: true
@@ -975,21 +990,23 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
             prepared.confirmationMessages.disclaimer = ( toolIdsThatCannotBeAutoApproved.has(tool.data.id)) ? undefined : ( new MarkdownString(( localize(
-                7722,
+                9079,
                 "Auto approval for '{0}' is restricted via {1}.",
                 getToolFullReferenceName(tool.data),
                 createMarkdownCommandLink({
                     text: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
                     id: "workbench.action.openSettings",
                     arguments: [ChatConfiguration.EligibleForAutoApproval],
-                    tooltip: ( localize(7723, "Open settings to configure auto-approval"))
+                    tooltip: ( localize(9080, "Open settings to configure auto-approval"))
                 }, false)
             )), {
                 isTrusted: true
             }));
         }
         if (prepared?.confirmationMessages?.title) {
-            if (prepared.toolSpecificData?.kind !== "terminal" && prepared.confirmationMessages.allowAutoConfirm !== false) {
+            if (this._isAutoApprovePolicyRestricted()) {
+                prepared.confirmationMessages.allowAutoConfirm = false;
+            } else if (prepared.toolSpecificData?.kind !== "terminal" && prepared.confirmationMessages.allowAutoConfirm !== false) {
                 prepared.confirmationMessages.allowAutoConfirm = isEligibleForAutoApproval;
             }
             if (!prepared.toolSpecificData && tool.data.alwaysDisplayInputOutput) {
@@ -1346,12 +1363,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }));
             const promptResult = await this._dialogService.prompt({
                 type: Severity.Warning,
-                message: ( localize(7724, "Enable global auto approve?")),
+                message: ( localize(9081, "Enable global auto approve?")),
                 buttons: [{
-                    label: ( localize(7725, "Enable")),
+                    label: ( localize(9082, "Enable")),
                     run: () => true
                 }, {
-                    label: ( localize(7726, "Disable")),
+                    label: ( localize(9083, "Disable")),
                     run: () => false
                 }],
                 custom: {

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

@@ -4,6 +4,7 @@ import { IBulkEditService } from "@codingame/monaco-vscode-api/vscode/vs/editor/
 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 { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 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";
@@ -14,14 +15,16 @@ export declare class RenameTool extends Disposable implements IToolImpl {
     private readonly _languageFeaturesService;
     private readonly _textModelService;
     private readonly _workspaceContextService;
+    private readonly _uriIdentityService;
     private readonly _chatService;
     private readonly _bulkEditService;
-    constructor(_languageFeaturesService: ILanguageFeaturesService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService, _chatService: IChatService, _bulkEditService: IBulkEditService);
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService, _uriIdentityService: IUriIdentityService, _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;
+    private _containsOutOfScopeEdit;
 }
 export declare class RenameToolContribution extends Disposable implements IWorkbenchContribution {
     static readonly ID = "chat.renameTool";

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

@@ -6,19 +6,20 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
-import { ResourceTextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService';
+import { ResourceTextEdit, ResourceFileEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService';
 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 { rename } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/rename/browser/rename';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 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 { resolveSymbolToolFileUri, errorResult, findLineNumber, findSymbolColumn } from './toolHelpers.js';
+import { resolveSymbolToolFileUri, errorResult, findLineNumber, findSymbolColumn, isSymbolToolResourceInScope } 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.
@@ -26,8 +27,8 @@ const BaseModelDescription = `Rename a code symbol across the workspace using th
 Input:
 - "symbol": The exact current name of the symbol to rename.
 - "newName": The new name for the symbol.
-- "uri": A full URI (e.g. "file:///path/to/file.ts") of a file where the symbol appears. Provide either "uri" or "filePath".
-- "filePath": A workspace-relative file path (e.g. "src/utils/helpers.ts") of a file where the symbol appears. Provide either "uri" or "filePath".
+- "uri": A full URI (e.g. "file:///path/to/file.ts") of a file within the current workspace or working directory where the symbol appears. Provide either "uri" or "filePath".
+- "filePath": A file path relative to the current working directory when one is set, otherwise the first workspace folder (e.g. "src/utils/helpers.ts"). Provide either "uri" or "filePath".
 - "lineContent": A substring of the line of code where the symbol appears. This is used to locate the exact position in the file. Must be the actual text from the file - do NOT fabricate it.
 
 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.
@@ -41,6 +42,7 @@ let RenameTool = class RenameTool extends Disposable {
         _languageFeaturesService,
         _textModelService,
         _workspaceContextService,
+        _uriIdentityService,
         _chatService,
         _bulkEditService
     ) {
@@ -48,11 +50,12 @@ let RenameTool = class RenameTool extends Disposable {
         this._languageFeaturesService = _languageFeaturesService;
         this._textModelService = _textModelService;
         this._workspaceContextService = _workspaceContextService;
+        this._uriIdentityService = _uriIdentityService;
         this._chatService = _chatService;
         this._bulkEditService = _bulkEditService;
     }
     getToolData() {
-        return this._buildToolData(StaticModelDescription, ( localize(7727, "Rename a symbol across the workspace")));
+        return this._buildToolData(StaticModelDescription, ( localize(9084, "Rename a symbol across the workspace")));
     }
     _buildToolData(modelDescription, userDescription) {
         return {
@@ -60,7 +63,7 @@ let RenameTool = class RenameTool extends Disposable {
             toolReferenceName: "rename",
             canBeReferencedInPrompt: false,
             icon: ThemeIcon.fromId(Codicon.rename.id),
-            displayName: ( localize(7728, "Rename Symbol")),
+            displayName: ( localize(9085, "Rename Symbol")),
             userDescription,
             modelDescription,
             source: ToolDataSource.Internal,
@@ -77,11 +80,11 @@ let RenameTool = class RenameTool extends Disposable {
                     },
                     uri: {
                         type: "string",
-                        description: "A full URI of a file where the symbol appears (e.g. \"file:///path/to/file.ts\"). Provide either \"uri\" or \"filePath\"."
+                        description: "A full URI of a file within the current workspace or working directory where the symbol appears (e.g. \"file:///path/to/file.ts\"). Provide either \"uri\" or \"filePath\"."
                     },
                     filePath: {
                         type: "string",
-                        description: "A workspace-relative file path where the symbol appears (e.g. \"src/utils/helpers.ts\"). Provide either \"uri\" or \"filePath\"."
+                        description: "A file path relative to the current working directory when one is set, otherwise the first workspace folder, where the symbol appears (e.g. \"src/utils/helpers.ts\"). Provide either \"uri\" or \"filePath\"."
                     },
                     lineContent: {
                         type: "string",
@@ -95,16 +98,22 @@ let RenameTool = class RenameTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const input = context.parameters;
         return {
-            invocationMessage: ( localize(7729, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
+            invocationMessage: ( localize(9086, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
         };
     }
     async invoke(invocation, _countTokens, _progress, token) {
         const input = invocation.parameters;
-        const uri = resolveSymbolToolFileUri(input, this._workspaceContextService, invocation.context?.workingDirectory);
+        const uri = resolveSymbolToolFileUri(
+            input,
+            this._workspaceContextService,
+            this._uriIdentityService,
+            invocation.context?.workingDirectory
+        );
         if (!uri) {
-            return errorResult(
-                "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify the file."
-            );
+            return errorResult(( localize(
+                9087,
+                "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify a file within the current workspace or working directory."
+            )));
         }
         const ref = await this._textModelService.createModelReference(uri);
         try {
@@ -138,10 +147,22 @@ let RenameTool = class RenameTool extends Disposable {
             if (renameResult.edits.length === 0) {
                 return errorResult(`Rename produced no edits.`);
             }
+            if (this._containsOutOfScopeEdit(renameResult.edits, invocation.context?.workingDirectory)) {
+                return errorResult(( localize(
+                    9088,
+                    "Rename was not applied because it would modify files outside the current workspace or working directory."
+                )));
+            }
             if (invocation.context) {
                 const chatModel = this._chatService.getSession(invocation.context.sessionResource);
                 const request = chatModel?.getRequests().at(-1);
                 if (chatModel && request) {
+                    if (( renameResult.edits.some(edit => !ResourceTextEdit.is(edit)))) {
+                        return errorResult(( localize(
+                            9089,
+                            "Rename was not applied because it produced edits that cannot be reviewed in chat."
+                        )));
+                    }
                     const editsByUri = ( new ResourceMap());
                     for (const edit of renameResult.edits) {
                         if (ResourceTextEdit.is(edit)) {
@@ -183,13 +204,13 @@ let RenameTool = class RenameTool extends Disposable {
     }
     _successResult(input, fileCount, editCount) {
         const text = editCount === 1 ? ( localize(
-            7730,
+            9090,
             "Renamed `{0}` to `{1}` - 1 edit in {2} file.",
             input.symbol,
             input.newName,
             fileCount
         )) : ( localize(
-            7731,
+            9091,
             "Renamed `{0}` to `{1}` - {2} edits across {3} files.",
             input.symbol,
             input.newName,
@@ -200,8 +221,31 @@ let RenameTool = class RenameTool extends Disposable {
         result.toolResultMessage = ( new MarkdownString(text));
         return result;
     }
+    _containsOutOfScopeEdit(edits, workingDirectory) {
+        return ( edits.some(edit => {
+            if (ResourceFileEdit.is(edit)) {
+                return !!edit.oldResource && !isSymbolToolResourceInScope(
+                    edit.oldResource,
+                    this._workspaceContextService,
+                    this._uriIdentityService,
+                    workingDirectory
+                ) || !!edit.newResource && !isSymbolToolResourceInScope(
+                    edit.newResource,
+                    this._workspaceContextService,
+                    this._uriIdentityService,
+                    workingDirectory
+                );
+            }
+            return !isSymbolToolResourceInScope(
+                edit.resource,
+                this._workspaceContextService,
+                this._uriIdentityService,
+                workingDirectory
+            );
+        }));
+    }
 };
-RenameTool = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, ITextModelService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IChatService)), ( __param(4, IBulkEditService))], RenameTool));
+RenameTool = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, ITextModelService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IUriIdentityService)), ( __param(4, IChatService)), ( __param(5, IBulkEditService))], RenameTool));
 let RenameToolContribution = class RenameToolContribution extends Disposable {
     static {
         this.ID = "chat.renameTool";

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

@@ -1,6 +1,7 @@
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import type { ITerminalSandboxPrecheckInputs } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
@@ -13,15 +14,16 @@ export interface ISymbolToolInput {
     lineContent: string;
 }
 /**
- * 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.
+ * Returns whether a resource is within the active working directory, or within
+ * a workspace folder when no explicit working directory is set.
+ */
+export declare function isSymbolToolResourceInScope(resource: URI, workspaceContextService: IWorkspaceContextService, uriIdentityService: IUriIdentityService, workingDirectory?: URI): boolean;
+/**
+ * Resolves an in-scope URI from tool input. Accepts either a full URI string or
+ * a file path relative to the working directory when one is provided, or to the
+ * first workspace folder otherwise.
  */
-export declare function resolveSymbolToolFileUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService, workingDirectory?: URI): URI | undefined;
+export declare function resolveSymbolToolFileUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService, uriIdentityService: IUriIdentityService, 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,13 +6,22 @@ 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 resolveSymbolToolFileUri(input, workspaceContextService, workingDirectory) {
+function isSymbolToolResourceInScope(resource, workspaceContextService, uriIdentityService, workingDirectory) {
+    const normalizedResource = uriIdentityService.extUri.normalizePath(resource);
+    const scopeRoots = workingDirectory ? [workingDirectory] : ( workspaceContextService.getWorkspace().folders.map(folder => folder.uri));
+    return ( scopeRoots.some(
+        root => uriIdentityService.extUri.isEqualOrParent(normalizedResource, uriIdentityService.extUri.normalizePath(root))
+    ));
+}
+function resolveSymbolToolFileUri(input, workspaceContextService, uriIdentityService, workingDirectory) {
     if (input.uri) {
-        return ( URI.parse(input.uri));
+        const uri = uriIdentityService.extUri.normalizePath(( URI.parse(input.uri)));
+        return isSymbolToolResourceInScope(uri, workspaceContextService, uriIdentityService, workingDirectory) ? uri : undefined;
     }
     if (input.filePath) {
         const workingDir = ( new WorkingDirectory(workspaceContextService, workingDirectory));
-        return workingDir.resolveRelativePath(input.filePath);
+        const uri = workingDir.resolveRelativePath(input.filePath);
+        return uri && isSymbolToolResourceInScope(uri, workspaceContextService, uriIdentityService, workingDirectory) ? uri : undefined;
     }
     return undefined;
 }
@@ -60,4 +69,4 @@ function errorResult(message) {
     return result;
 }
 
-export { errorResult, findLineNumber, findSymbolColumn, getChatPermissionLevelForToolInvocation, getSandboxPrecheckInputsForToolInvocation, resolveSymbolToolFileUri };
+export { errorResult, findLineNumber, findSymbolColumn, getChatPermissionLevelForToolInvocation, getSandboxPrecheckInputsForToolInvocation, isSymbolToolResourceInScope, resolveSymbolToolFileUri };

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

@@ -4,6 +4,7 @@ import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/com
 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 { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 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 { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
@@ -16,7 +17,8 @@ export declare class UsagesTool extends Disposable implements IToolImpl {
     private readonly _searchService;
     private readonly _textModelService;
     private readonly _workspaceContextService;
-    constructor(_languageFeaturesService: ILanguageFeaturesService, _modelService: IModelService, _searchService: ISearchService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService);
+    private readonly _uriIdentityService;
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _modelService: IModelService, _searchService: ISearchService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService, _uriIdentityService: IUriIdentityService);
     getToolData(): IToolData;
     private _buildToolData;
     prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;