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

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

@@ -39,7 +39,7 @@ import { toToolSetVariableEntry, toToolVariableEntry } from '@codingame/monaco-v
 import { ToolConfirmKind, IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { ChatToolInvocation } from '../../common/model/chatProgressTypes/chatToolInvocation.js';
+import { ChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatToolInvocation';
 import { chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { HookType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
 import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
@@ -58,9 +58,10 @@ var AutoApproveStorageKeys;
     AutoApproveStorageKeys["GlobalAutoApproveOptIn"] = "chat.tools.global.autoApprove.optIn";
 })(AutoApproveStorageKeys || (AutoApproveStorageKeys = {}));
 const SkipAutoApproveConfirmationKey = "vscode.chat.tools.global.autoApprove.testMode";
+const toolIdThatCannotBeAutoApproved = "vscode_get_confirmation_with_options";
 const globalAutoApproveDescription = ( localize2(
-    5852,
-    "Global auto approve also known as \"YOLO mode\" disables manual approval completely for _all tools in all workspaces_, allowing the agent to act fully autonomously. This is extremely dangerous and is *never* recommended, even containerized environments like [Codespaces](https://github.com/features/codespaces) and [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) have user keys forwarded into the container that could be compromised.\n\n**This feature disables [critical security protections](https://code.visualstudio.com/docs/copilot/security) and makes it much easier for an attacker to compromise the machine.**"
+    6345,
+    "Global auto approve also known as \"YOLO mode\" disables manual approval completely for _all tools in all workspaces_, allowing the agent to act fully autonomously. This is extremely dangerous and is *never* recommended, even containerized environments like [Codespaces](https://github.com/features/codespaces) and [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) have user keys forwarded into the container that could be compromised.\n\n**This feature disables [critical security protections](https://code.visualstudio.com/docs/copilot/security) and makes it much easier for an attacker to compromise the machine.**\n\nNote: This setting only controls tool approval and does not prevent the agent from asking questions. To automatically answer agent questions, use the [`chat.autoReply`](command:workbench.action.openSettings?%5B%22chat.autoReply%22%5D) setting."
 ));
 let LanguageModelToolsService = class LanguageModelToolsService extends Disposable {
     static {
@@ -101,7 +102,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this.onDidPrepareToolCallBecomeUnresponsive = this._onDidPrepareToolCallBecomeUnresponsive.event;
         this._onDidInvokeTool = this._register(( new Emitter()));
         this.onDidInvokeTool = this._onDidInvokeTool.event;
-        this._onDidChangeToolsScheduler = ( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750));
+        this._onDidChangeToolsScheduler = this._register(( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750)));
         this._tools = ( new Map());
         this._toolContextKeys = ( new Set());
         this._callsByRequestId = ( new Map());
@@ -160,25 +161,25 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this.vscodeToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "vscode", VSCodeToolReference.vscode, {
                 icon: ThemeIcon.fromId(Codicon.vscode.id),
-                description: ( localize(5853, "Use VS Code features"))
+                description: ( localize(6346, "Use VS Code features"))
             })
         );
         this.executeToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "execute", SpecedToolAliases.execute, {
                 icon: ThemeIcon.fromId(Codicon.terminal.id),
-                description: ( localize(5854, "Execute code and applications on your machine"))
+                description: ( localize(6347, "Execute code and applications on your machine"))
             })
         );
         this.readToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "read", SpecedToolAliases.read, {
                 icon: ThemeIcon.fromId(Codicon.book.id),
-                description: ( localize(5855, "Read files in your workspace"))
+                description: ( localize(6348, "Read files in your workspace"))
             })
         );
         this.agentToolSet = this._register(
             this.createToolSet(ToolDataSource.Internal, "agent", SpecedToolAliases.agent, {
                 icon: ThemeIcon.fromId(Codicon.agent.id),
-                description: ( localize(5856, "Delegate tasks to other agents"))
+                description: ( localize(6349, "Delegate tasks to other agents"))
             })
         );
     }
@@ -187,6 +188,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (agentModeEnabled !== false) {
             return true;
         }
+        if (!isToolSet(toolOrToolSet) && toolOrToolSet.canBeReferencedInPrompt === false && toolOrToolSet.source.type === "internal") {
+            return true;
+        }
         const permittedInternalToolSetIds = [SpecedToolAliases.read, SpecedToolAliases.search, SpecedToolAliases.web];
         if (isToolSet(toolOrToolSet)) {
             const permitted = toolOrToolSet.source.type === "internal" && permittedInternalToolSetIds.includes(toolOrToolSet.referenceName);
@@ -329,8 +333,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     _handlePreToolUseDenial(dto, hookResult, toolData, pendingInvocation, request) {
-        const hookReason = hookResult.permissionDecisionReason ?? ( localize(5857, "Hook denied tool execution"));
-        const reason = ( localize(5858, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
+        const hookReason = hookResult.permissionDecisionReason ?? ( localize(6350, "Hook denied tool execution"));
+        const reason = ( localize(6351, "Denied by {0} hook: {1}", HookType.PreToolUse, hookReason));
         this._logService.debug(
             `[LanguageModelToolsService#invokeTool] Tool ${dto.toolId} denied by preToolUse hook: ${hookReason}`
         );
@@ -386,6 +390,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (dto.context?.sessionResource) {
             model = this._chatService.getSession(dto.context.sessionResource);
             request = model?.getRequests().at(-1);
+            if (request?.response?.isCanceled || request?.response?.isComplete) {
+                this._logService.debug(
+                    `[LanguageModelToolsService#invokeTool] Ignoring tool ${dto.toolId} for cancelled/complete request ${request.id}`
+                );
+                throw ( new CancellationError());
+            }
         }
         let pendingToolCallKey;
         let toolInvocation;
@@ -530,6 +540,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                         };
                         return toolResult;
                     }
+                    if (userConfirmed.type === ToolConfirmKind.UserAction && userConfirmed.selectedButton) {
+                        dto.selectedCustomButton = userConfirmed.selectedButton;
+                    }
                     if (dto.toolSpecificData?.kind === "input") {
                         dto.parameters = dto.toolSpecificData.rawInput;
                         dto.toolSpecificData = undefined;
@@ -566,17 +579,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }, token);
             invocationTimeWatch.stop();
             this.ensureToolDetails(dto, toolResult, tool.data);
-            if (toolInvocation?.didExecuteTool(toolResult).type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-                const autoConfirmedPost = await this.shouldAutoConfirmPostExecution(
-                    tool.data.id,
-                    tool.data.runsInWorkspace,
-                    tool.data.source,
-                    dto.parameters,
-                    dto.context?.sessionResource
-                );
-                if (autoConfirmedPost) {
-                    IChatToolInvocation.confirmWith(toolInvocation, autoConfirmedPost);
-                }
+            const afterExecuteState = await toolInvocation?.didExecuteTool(toolResult, undefined, () => this.shouldAutoConfirmPostExecution(
+                tool.data.id,
+                tool.data.runsInWorkspace,
+                tool.data.source,
+                dto.parameters,
+                dto.context?.sessionResource
+            ));
+            if (toolInvocation && afterExecuteState?.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
                 const postConfirm = await IChatToolInvocation.awaitPostConfirmation(toolInvocation, token);
                 if (postConfirm.type === ToolConfirmKind.Denied) {
                     throw ( new CancellationError());
@@ -604,7 +614,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const result = isCancellationError(err) ? "userCancelled" : "error";
             this._telemetryService.publicLog2("languageModelToolInvoked", {
                 result,
-                chatSessionId: dto.context?.sessionId,
+                chatSessionId: dto.context?.sessionResource ? chatSessionResourceToId(dto.context.sessionResource) : undefined,
                 toolId: tool.data.id,
                 toolExtensionId: tool.data.source.type === "extension" ? tool.data.source.extensionId.value : undefined,
                 toolSourceKind: tool.data.source.type,
@@ -642,7 +652,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async prepareToolInvocationWithHookResult(tool, dto, hookResult, token) {
         let forceConfirmationReason;
         if (hookResult?.permissionDecision === "ask") {
-            const hookMessage = ( localize(5859, "{0} required confirmation", HookType.PreToolUse));
+            const hookMessage = ( localize(6352, "{0} required confirmation", HookType.PreToolUse));
             forceConfirmationReason = hookResult.permissionDecisionReason ? `${hookMessage}: ${hookResult.permissionDecisionReason}` : hookMessage;
         }
         return this.prepareToolInvocation(tool, dto, forceConfirmationReason, token);
@@ -655,7 +665,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             return {
                 autoConfirmed: {
                     type: ToolConfirmKind.ConfirmationNotNeeded,
-                    reason: ( localize(5860, "Allowed by hook"))
+                    reason: ( localize(6353, "Allowed by hook"))
                 },
                 preparedInvocation
             };
@@ -671,14 +681,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 const fullReferenceName = getToolFullReferenceName(tool.data);
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    5861,
+                    6354,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(5862, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(6355, "{0} hook required confirmation", HookType.PreToolUse));
                 preparedInvocation.confirmationMessages = {
                     ...preparedInvocation.confirmationMessages,
-                    title: ( localize(5863, "Use the '{0}' tool?", fullReferenceName)),
+                    title: ( localize(6356, "Use the '{0}' tool?", fullReferenceName)),
                     message: ( new MarkdownString(`_${hookNote}_`)),
                     allowAutoConfirm: false
                 };
@@ -689,11 +699,11 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             } else {
                 const hookReason = hookResult.permissionDecisionReason;
                 const hookNote = hookReason ? ( localize(
-                    5864,
+                    6357,
                     "{0} hook required confirmation: {1}",
                     HookType.PreToolUse,
                     hookReason
-                )) : ( localize(5865, "{0} hook required confirmation", HookType.PreToolUse));
+                )) : ( localize(6358, "{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;
@@ -736,7 +746,6 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 parameters: dto.parameters,
                 toolCallId: dto.callId,
                 chatRequestId: dto.chatRequestId,
-                chatSessionId: dto.context?.sessionId,
                 chatSessionResource: dto.context?.sessionResource,
                 chatInteractionId: dto.chatInteractionId,
                 modelId: dto.modelId,
@@ -759,10 +768,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(5866, "Confirm tool execution")),
-                message: ( localize(5867, "Run the '{0}' tool?", fullReferenceName)),
-                disclaimer: ( new MarkdownString(( localize(
-                    5868,
+                title: ( localize(6359, "Confirm tool execution")),
+                message: ( localize(6360, "Run the '{0}' tool?", fullReferenceName)),
+                disclaimer: tool.data.id === toolIdThatCannotBeAutoApproved ? undefined : ( new MarkdownString(( localize(
+                    6361,
                     "Auto approval for '{0}' is restricted via {1}.",
                     getToolFullReferenceName(tool.data),
                     createMarkdownCommandLink({
@@ -777,8 +786,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             };
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
-            prepared.confirmationMessages.disclaimer = ( new MarkdownString(( localize(
-                5868,
+            prepared.confirmationMessages.disclaimer = tool.data.id === toolIdThatCannotBeAutoApproved ? undefined : ( new MarkdownString(( localize(
+                6361,
                 "Auto approval for '{0}' is restricted via {1}.",
                 getToolFullReferenceName(tool.data),
                 createMarkdownCommandLink({
@@ -873,6 +882,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (autoApproved) {
             return;
         }
+        const pendingInvocations = toolInvocations.filter(inv => !IChatToolInvocation.executionConfirmedOrDenied(inv));
+        if (pendingInvocations.length === 0) {
+            return;
+        }
         const setting = this._configurationService.getValue(AccessibilitySignal.chatUserActionRequired.settingsKey);
         if (!setting) {
             return;
@@ -881,7 +894,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         const announcementEnabled = this._accessibilityService.isScreenReaderOptimized() && setting.announcement === "auto";
         if (soundEnabled || announcementEnabled) {
             this._accessibilitySignalService.playSignal(AccessibilitySignal.chatUserActionRequired, {
-                customAlertMessage: this._instantiationService.invokeFunction(getToolConfirmationAlert, toolInvocations),
+                customAlertMessage: this._instantiationService.invokeFunction(getToolConfirmationAlert, pendingInvocations),
                 userGesture: true,
                 modality: !soundEnabled ? "announcement" : undefined
             });
@@ -934,6 +947,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (toolData.id === "copilot_fetchWebPage") {
             return true;
         }
+        if (toolData.id === toolIdThatCannotBeAutoApproved) {
+            return false;
+        }
         const eligibilityConfig = this._configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
         if (eligibilityConfig && typeof eligibilityConfig === "object" && fullReferenceName) {
             if (Object.prototype.hasOwnProperty.call(eligibilityConfig, fullReferenceName)) {
@@ -1019,19 +1035,22 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         const promptResult = await this._dialogService.prompt({
             type: Severity.Warning,
-            message: ( localize(5869, "Enable global auto approve?")),
+            message: ( localize(6362, "Enable global auto approve?")),
             buttons: [{
-                label: ( localize(5870, "Enable")),
+                label: ( localize(6363, "Enable")),
                 run: () => true
             }, {
-                label: ( localize(5871, "Disable")),
+                label: ( localize(6364, "Disable")),
                 run: () => false
             }],
             custom: {
                 icon: Codicon.warning,
-                disableCloseAction: true,
                 markdownDetails: [{
-                    markdown: ( new MarkdownString(globalAutoApproveDescription.value))
+                    markdown: ( new MarkdownString(globalAutoApproveDescription.value, {
+                        isTrusted: {
+                            enabledCommands: ["workbench.action.openSettings"]
+                        }
+                    }))
                 }]
             }
         });
@@ -1070,6 +1089,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         for (const [toolCallId, invocation] of this._pendingToolCalls) {
             if (invocation.chatRequestId === requestId) {
+                invocation.cancelFromStreaming(ToolConfirmKind.Skipped);
                 this._pendingToolCalls.delete(toolCallId);
             }
         }
@@ -1303,7 +1323,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     add(alias, fullReferenceName);
                 }
                 if (tool.legacyToolReferenceFullNames) {
+                    const slashIndex = fullReferenceName.lastIndexOf("/");
+                    const toolSetPrefix = slashIndex !== -1 ? fullReferenceName.substring(0, slashIndex + 1) : undefined;
                     for (const legacyName of tool.legacyToolReferenceFullNames) {
+                        if (toolSetPrefix && !legacyName.includes("/")) {
+                            add(toolSetPrefix + legacyName, fullReferenceName);
+                        }
                         if (legacyName.includes("/")) {
                             const toolSetFullName = legacyName.substring(0, legacyName.lastIndexOf("/"));
                             if (!( knownToolSetNames.has(toolSetFullName))) {

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

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

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

@@ -0,0 +1,242 @@
+
+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';
+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 { 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 { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+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 { 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 { resolveToolUri, 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.
+
+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".
+- "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.
+
+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.`;
+let RenameTool = class RenameTool extends Disposable {
+    constructor(
+        _languageFeaturesService,
+        _textModelService,
+        _workspaceContextService,
+        _chatService,
+        _bulkEditService
+    ) {
+        super();
+        this._languageFeaturesService = _languageFeaturesService;
+        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;
+        let modelDescription = BaseModelDescription;
+        if (( languageIds.has("*"))) {
+            modelDescription += "\n\nSupported for all languages.";
+        } else if (languageIds.size > 0) {
+            const sorted = [...languageIds].sort();
+            modelDescription += `\n\nCurrently supported for: ${sorted.join(", ")}.`;
+        } else {
+            modelDescription += "\n\nNo languages currently have rename providers registered.";
+        }
+        return {
+            id: RenameToolId,
+            toolReferenceName: "rename",
+            canBeReferencedInPrompt: false,
+            icon: ThemeIcon.fromId(Codicon.rename.id),
+            displayName: ( localize(6365, "Rename Symbol")),
+            userDescription: ( localize(6366, "Rename a symbol across the workspace")),
+            modelDescription,
+            source: ToolDataSource.Internal,
+            when: ( ContextKeyExpr.has("config.chat.tools.renameTool.enabled")),
+            inputSchema: {
+                type: "object",
+                properties: {
+                    symbol: {
+                        type: "string",
+                        description: "The exact current name of the symbol to rename."
+                    },
+                    newName: {
+                        type: "string",
+                        description: "The new name for the symbol."
+                    },
+                    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\"."
+                    },
+                    filePath: {
+                        type: "string",
+                        description: "A workspace-relative file path where the symbol appears (e.g. \"src/utils/helpers.ts\"). Provide either \"uri\" or \"filePath\"."
+                    },
+                    lineContent: {
+                        type: "string",
+                        description: "A substring of the line of code where the symbol appears. Used to locate the exact position. Must be actual text from the file."
+                    }
+                },
+                required: ["symbol", "newName", "lineContent"]
+            }
+        };
+    }
+    async prepareToolInvocation(context, _token) {
+        const input = context.parameters;
+        return {
+            invocationMessage: ( localize(6367, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const input = invocation.parameters;
+        const uri = resolveToolUri(input, this._workspaceContextService);
+        if (!uri) {
+            return errorResult(
+                "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify the file."
+            );
+        }
+        const ref = await this._textModelService.createModelReference(uri);
+        try {
+            const model = ref.object.textEditorModel;
+            if (!( this._languageFeaturesService.renameProvider.has(model))) {
+                return errorResult(
+                    `No rename provider available for this file's language. The rename tool may not support this language.`
+                );
+            }
+            const lineNumber = findLineNumber(model, input.lineContent);
+            if (lineNumber === undefined) {
+                return errorResult(`Could not find line content "${input.lineContent}" in ${( uri.toString())}. Provide the exact text from the line where the symbol appears.`);
+            }
+            const lineText = model.getLineContent(lineNumber);
+            const column = findSymbolColumn(lineText, input.symbol);
+            if (column === undefined) {
+                return errorResult(
+                    `Could not find symbol "${input.symbol}" in the matched line. Ensure the symbol name is correct and appears in the provided line content.`
+                );
+            }
+            const position = ( new Position(lineNumber, column));
+            const renameResult = await rename(
+                this._languageFeaturesService.renameProvider,
+                model,
+                position,
+                input.newName
+            );
+            if (renameResult.rejectReason) {
+                return errorResult(`Rename rejected: ${renameResult.rejectReason}`);
+            }
+            if (renameResult.edits.length === 0) {
+                return errorResult(`Rename produced no edits.`);
+            }
+            if (invocation.context) {
+                const chatModel = this._chatService.getSession(invocation.context.sessionResource);
+                const request = chatModel?.getRequests().at(-1);
+                if (chatModel && request) {
+                    const editsByUri = ( new ResourceMap());
+                    for (const edit of renameResult.edits) {
+                        if (ResourceTextEdit.is(edit)) {
+                            let edits = editsByUri.get(edit.resource);
+                            if (!edits) {
+                                edits = [];
+                                editsByUri.set(edit.resource, edits);
+                            }
+                            edits.push(edit.textEdit);
+                        }
+                    }
+                    for (const [editUri, edits] of editsByUri) {
+                        chatModel.acceptResponseProgress(request, {
+                            kind: "textEdit",
+                            uri: editUri,
+                            edits: []
+                        });
+                        chatModel.acceptResponseProgress(request, {
+                            kind: "textEdit",
+                            uri: editUri,
+                            edits
+                        });
+                        chatModel.acceptResponseProgress(request, {
+                            kind: "textEdit",
+                            uri: editUri,
+                            edits: [],
+                            done: true
+                        });
+                    }
+                    return this._successResult(input, editsByUri.size, renameResult.edits.length);
+                }
+            }
+            await this._bulkEditService.apply(renameResult);
+            const fileCount = ( new ResourceSet(( renameResult.edits.filter(ResourceTextEdit.is).map(e => e.resource)))).size;
+            return this._successResult(input, fileCount, renameResult.edits.length);
+        } finally {
+            ref.dispose();
+        }
+    }
+    _successResult(input, fileCount, editCount) {
+        const text = editCount === 1 ? ( localize(
+            6368,
+            "Renamed `{0}` to `{1}` - 1 edit in {2} file.",
+            input.symbol,
+            input.newName,
+            fileCount
+        )) : ( localize(
+            6369,
+            "Renamed `{0}` to `{1}` - {2} edits across {3} files.",
+            input.symbol,
+            input.newName,
+            editCount,
+            fileCount
+        ));
+        const result = createToolSimpleTextResult(text);
+        result.toolResultMessage = ( new MarkdownString(text));
+        return result;
+    }
+};
+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";
+    }
+    constructor(toolsService, instantiationService) {
+        super();
+        const renameTool = this._store.add(instantiationService.createInstance(RenameTool));
+        let registration;
+        const registerRenameTool = () => {
+            registration?.dispose();
+            toolsService.flushToolUpdates();
+            const toolData = renameTool.getToolData();
+            registration = toolsService.registerTool(toolData, renameTool);
+        };
+        registerRenameTool();
+        this._store.add(renameTool.onDidUpdateToolData(registerRenameTool));
+        this._store.add({
+            dispose: () => {
+                registration?.dispose();
+            }
+        });
+    }
+};
+RenameToolContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService))], RenameToolContribution));
+
+export { RenameTool, RenameToolContribution, RenameToolId };

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

@@ -0,0 +1,34 @@
+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 { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IToolResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export interface ISymbolToolInput {
+    symbol: string;
+    uri?: string;
+    filePath?: string;
+    lineContent: string;
+}
+/**
+ * Resolves a URI from tool input. Accepts either a full URI string or a
+ * workspace-relative file path.
+ */
+export declare function resolveToolUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService): 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.
+ *
+ * @returns The 1-based line number, or `undefined` if not found.
+ */
+export declare function findLineNumber(model: ITextModel, lineContent: string): number | undefined;
+/**
+ * Finds the 1-based column of a symbol within a line of text using word
+ * boundary matching.
+ *
+ * @returns The 1-based column, or `undefined` if not found.
+ */
+export declare function findSymbolColumn(lineText: string, symbol: string): number | undefined;
+/**
+ * Creates an error tool result with the given message as both the content
+ * and the tool result message.
+ */
+export declare function errorResult(message: string): IToolResult;