@codingame/monaco-vscode-chat-service-override 22.1.8 → 23.0.0

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

@@ -13,9 +13,10 @@ import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
-import { IVariableReference } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModes";
+import { IVariableReference } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModes";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
 import { ChatRequestToolReferenceEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries";
+import { ILanguageModelToolsConfirmationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsConfirmationService.service";
 import { CountTokensCallback, IToolAndToolSetEnablementMap, IToolData, IToolImpl, IToolInvocation, IToolResult, ToolDataSource, ToolSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
 export declare const globalAutoApproveDescription: import("@codingame/monaco-vscode-api/vscode/vs/nls").ILocalizedString;
@@ -31,21 +32,25 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     private readonly _accessibilityService;
     private readonly _accessibilitySignalService;
     private readonly _storageService;
+    private readonly _confirmationService;
     _serviceBrand: undefined;
     private _onDidChangeTools;
     readonly onDidChangeTools: Event<void>;
+    private _onDidPrepareToolCallBecomeUnresponsive;
+    readonly onDidPrepareToolCallBecomeUnresponsive: Event<{
+        sessionId: string;
+        toolData: IToolData;
+    }>;
     /** Throttle tools updates because it sends all tools and runs on context key updates */
     private _onDidChangeToolsScheduler;
     private _tools;
     private _toolContextKeys;
     private readonly _ctxToolsCount;
     private _callsByRequestId;
-    private _workspaceToolConfirmStore;
-    private _profileToolConfirmStore;
-    private _memoryToolConfirmStore;
-    constructor(_instantiationService: IInstantiationService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService, _chatService: IChatService, _dialogService: IDialogService, _telemetryService: ITelemetryService, _logService: ILogService, _configurationService: IConfigurationService, _accessibilityService: IAccessibilityService, _accessibilitySignalService: IAccessibilitySignalService, _storageService: IStorageService);
+    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);
     dispose(): void;
     registerToolData(toolData: IToolData): IDisposable;
+    flushToolUpdates(): void;
     private _refreshAllToolContextKeys;
     registerToolImplementation(id: string, tool: IToolImpl): IDisposable;
     registerTool(toolData: IToolData, tool: IToolImpl): IDisposable;
@@ -53,26 +58,26 @@ export declare class LanguageModelToolsService extends Disposable implements ILa
     getTool(id: string): IToolData | undefined;
     private _getToolEntry;
     getToolByName(name: string, includeDisabled?: boolean): IToolData | undefined;
-    setToolAutoConfirmation(toolId: string, scope: "workspace" | "profile" | "session" | "never"): void;
-    getToolAutoConfirmation(toolId: string): "workspace" | "profile" | "session" | "never";
-    resetToolAutoConfirmation(): void;
     invokeTool(dto: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
     private prepareToolInvocation;
-    private informScreenReader;
     private playAccessibilitySignal;
     private ensureToolDetails;
     private formatToolInput;
     private toolResultToIO;
     private shouldAutoConfirm;
+    private shouldAutoConfirmPostExecution;
     private _checkGlobalAutoApprove;
     private cleanupCallDisposables;
     cancelToolCallsForRequest(requestId: string): void;
+    private _githubToVSCodeToolMap;
+    private _githubPrefixToVSCodePrefix;
+    mapGithubToolName(name: string): string;
     /**
      * Create a map that contains all tools and toolsets with their enablement state.
      * @param toolOrToolSetNames A list of tool or toolset names that are enabled.
      * @returns A map of tool or toolset instances to their enablement state.
      */
-    toToolAndToolSetEnablementMap(enabledQualifiedToolOrToolSetNames: readonly string[]): IToolAndToolSetEnablementMap;
+    toToolAndToolSetEnablementMap(enabledQualifiedToolOrToolSetNames: readonly string[], target: string | undefined): IToolAndToolSetEnablementMap;
     toQualifiedToolNames(map: IToolAndToolSetEnablementMap): string[];
     toToolReferences(variableReferences: readonly IVariableReference[]): ChatRequestToolReferenceEntry[];
     private readonly _toolSets;

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

@@ -1,9 +1,8 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
-import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
 import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
-import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { RunOnceScheduler, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
@@ -12,11 +11,10 @@ import { CancellationError, isCancellationError } from '@codingame/monaco-vscode
 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 { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
 import { Disposable, DisposableStore, toDisposable, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
 import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
 import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
@@ -32,18 +30,18 @@ import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { AccessibilityWorkbenchSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 import { ChatToolInvocation } from '../common/chatProgressTypes/chatToolInvocation.js';
-import { ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
 import { toToolSetVariableEntry, toToolVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { createToolSchemaUri, stringifyPromptTsxPart, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
-import { getToolConfirmationAlert } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatAccessibilityProvider';
+import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsConfirmationService.service';
+import { VSCodeToolReference, GithubCopilotToolReference, createToolSchemaUri, stringifyPromptTsxPart, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { Target } from '@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
+import { getToolConfirmationAlert } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/chatAccessibilityProvider';
 import { ObservableSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/set';
 
-var ToolConfirmStore_1;
 const jsonSchemaRegistry = ( Registry.as(Extensions.JSONContribution));
 var AutoApproveStorageKeys;
 (function (AutoApproveStorageKeys) {
@@ -51,11 +49,11 @@ var AutoApproveStorageKeys;
 })(AutoApproveStorageKeys || (AutoApproveStorageKeys = {}));
 const SkipAutoApproveConfirmationKey = 'vscode.chat.tools.global.autoApprove.testMode';
 const globalAutoApproveDescription = ( localize2(
-    5416,
+    5603,
     '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.**'
 ));
 let LanguageModelToolsService = class LanguageModelToolsService extends Disposable {
-    constructor(_instantiationService, _extensionService, _contextKeyService, _chatService, _dialogService, _telemetryService, _logService, _configurationService, _accessibilityService, _accessibilitySignalService, _storageService) {
+    constructor(_instantiationService, _extensionService, _contextKeyService, _chatService, _dialogService, _telemetryService, _logService, _configurationService, _accessibilityService, _accessibilitySignalService, _storageService, _confirmationService) {
         super();
         this._instantiationService = _instantiationService;
         this._extensionService = _extensionService;
@@ -68,21 +66,24 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this._accessibilityService = _accessibilityService;
         this._accessibilitySignalService = _accessibilitySignalService;
         this._storageService = _storageService;
-        this._onDidChangeTools = ( new Emitter());
+        this._confirmationService = _confirmationService;
+        this._onDidChangeTools = this._register(( new Emitter()));
         this.onDidChangeTools = this._onDidChangeTools.event;
+        this._onDidPrepareToolCallBecomeUnresponsive = this._register(( new Emitter()));
+        this.onDidPrepareToolCallBecomeUnresponsive = this._onDidPrepareToolCallBecomeUnresponsive.event;
         this._onDidChangeToolsScheduler = ( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750));
         this._tools = ( new Map());
         this._toolContextKeys = ( new Set());
         this._callsByRequestId = ( new Map());
-        this._memoryToolConfirmStore = ( new Set());
+        this._githubToVSCodeToolMap = {
+            [GithubCopilotToolReference.shell]: VSCodeToolReference.runCommands,
+            [GithubCopilotToolReference.customAgent]: VSCodeToolReference.runSubagent,
+            'github/*': 'github/github-mcp-server/*',
+            'playwright/*': 'microsoft/playwright-mcp/*',
+        };
+        this._githubPrefixToVSCodePrefix = [['github', 'github/github-mcp-server'], ['playwright', 'microsoft/playwright-mcp']];
         this._toolSets = ( new ObservableSet());
         this.toolSets = this._toolSets.observable;
-        this._workspaceToolConfirmStore = ( new Lazy(
-            () => this._register(this._instantiationService.createInstance(ToolConfirmStore, StorageScope.WORKSPACE))
-        ));
-        this._profileToolConfirmStore = ( new Lazy(
-            () => this._register(this._instantiationService.createInstance(ToolConfirmStore, StorageScope.PROFILE))
-        ));
         this._register(this._contextKeyService.onDidChangeContext(e => {
             if (e.affectsSome(this._toolContextKeys)) {
                 this._onDidChangeToolsScheduler.schedule();
@@ -130,6 +131,9 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             this._onDidChangeToolsScheduler.schedule();
         });
     }
+    flushToolUpdates() {
+        this._onDidChangeToolsScheduler.flush();
+    }
     _refreshAllToolContextKeys() {
         this._toolContextKeys.clear();
         for (const tool of ( this._tools.values())) {
@@ -181,33 +185,6 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return undefined;
     }
-    setToolAutoConfirmation(toolId, scope) {
-        this._workspaceToolConfirmStore.value.setAutoConfirm(toolId, scope === 'workspace');
-        this._profileToolConfirmStore.value.setAutoConfirm(toolId, scope === 'profile');
-        if (scope === 'session') {
-            this._memoryToolConfirmStore.add(toolId);
-        }
-        else {
-            this._memoryToolConfirmStore.delete(toolId);
-        }
-    }
-    getToolAutoConfirmation(toolId) {
-        if (this._workspaceToolConfirmStore.value.getAutoConfirm(toolId)) {
-            return 'workspace';
-        }
-        if (this._profileToolConfirmStore.value.getAutoConfirm(toolId)) {
-            return 'profile';
-        }
-        if (( this._memoryToolConfirmStore.has(toolId))) {
-            return 'session';
-        }
-        return 'never';
-    }
-    resetToolAutoConfirmation() {
-        this._workspaceToolConfirmStore.value.reset();
-        this._profileToolConfirmStore.value.reset();
-        this._memoryToolConfirmStore.clear();
-    }
     async invokeTool(dto, countTokens, token) {
         this._logService.trace(`[LanguageModelToolsService#invokeTool] Invoking tool ${dto.toolId} with parameters ${JSON.stringify(dto.parameters)}`);
         let tool = this._tools.get(dto.toolId);
@@ -225,16 +202,20 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         let requestId;
         let store;
         let toolResult;
+        let prepareTimeWatch;
+        let invocationTimeWatch;
+        let preparedInvocation;
         try {
             if (dto.context) {
                 store = ( new DisposableStore());
-                const model = this._chatService.getSession(dto.context?.sessionId);
+                const model = this._chatService.getSessionByLegacyId(dto.context.sessionId);
                 if (!model) {
                     throw ( new Error(`Tool called for unknown chat session`));
                 }
                 const request = model.getRequests().at(-1);
                 requestId = request.id;
                 dto.modelId = request.modelId;
+                dto.userSelectedTools = request.userSelectedTools;
                 if (!( this._callsByRequestId.has(requestId))) {
                     this._callsByRequestId.set(requestId, []);
                 }
@@ -245,28 +226,35 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     source.dispose(true);
                 }));
                 store.add(token.onCancellationRequested(() => {
-                    toolInvocation?.confirmed.complete({ type: ToolConfirmKind.Denied });
+                    IChatToolInvocation.confirmWith(toolInvocation, { type: ToolConfirmKind.Denied });
                     source.cancel();
                 }));
                 store.add(source.token.onCancellationRequested(() => {
-                    toolInvocation?.confirmed.complete({ type: ToolConfirmKind.Denied });
+                    IChatToolInvocation.confirmWith(toolInvocation, { type: ToolConfirmKind.Denied });
                 }));
                 token = source.token;
-                const prepared = await this.prepareToolInvocation(tool, dto, token);
-                toolInvocation = ( new ChatToolInvocation(prepared, tool.data, dto.callId, dto.fromSubAgent));
+                prepareTimeWatch = StopWatch.create(true);
+                preparedInvocation = await this.prepareToolInvocation(tool, dto, token);
+                prepareTimeWatch.stop();
+                toolInvocation = ( new ChatToolInvocation(
+                    preparedInvocation,
+                    tool.data,
+                    dto.callId,
+                    dto.fromSubAgent,
+                    dto.parameters
+                ));
                 trackedCall.invocation = toolInvocation;
-                const autoConfirmed = await this.shouldAutoConfirm(tool.data.id, tool.data.runsInWorkspace);
+                const autoConfirmed = await this.shouldAutoConfirm(tool.data.id, tool.data.runsInWorkspace, tool.data.source, dto.parameters);
                 if (autoConfirmed) {
-                    toolInvocation.confirmed.complete(autoConfirmed);
+                    IChatToolInvocation.confirmWith(toolInvocation, autoConfirmed);
                 }
                 model.acceptResponseProgress(request, toolInvocation);
                 dto.toolSpecificData = toolInvocation?.toolSpecificData;
-                this.informScreenReader(prepared?.invocationMessage ?? `${tool.data.displayName} started`);
-                if (prepared?.confirmationMessages) {
-                    if (!toolInvocation.isConfirmed?.type && !autoConfirmed) {
+                if (preparedInvocation?.confirmationMessages?.title) {
+                    if (!IChatToolInvocation.executionConfirmedOrDenied(toolInvocation) && !autoConfirmed) {
                         this.playAccessibilitySignal([toolInvocation]);
                     }
-                    const userConfirmed = await toolInvocation.confirmed.p;
+                    const userConfirmed = await IChatToolInvocation.awaitConfirmation(toolInvocation, token);
                     if (userConfirmed.type === ToolConfirmKind.Denied) {
                         throw ( new CancellationError());
                     }
@@ -286,30 +274,54 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 }
             }
             else {
-                const prepared = await this.prepareToolInvocation(tool, dto, token);
-                if (prepared?.confirmationMessages && !(await this.shouldAutoConfirm(tool.data.id, tool.data.runsInWorkspace))) {
-                    const result = await this._dialogService.confirm({ message: renderAsPlaintext(prepared.confirmationMessages.title), detail: renderAsPlaintext(prepared.confirmationMessages.message) });
+                prepareTimeWatch = StopWatch.create(true);
+                preparedInvocation = await this.prepareToolInvocation(tool, dto, token);
+                prepareTimeWatch.stop();
+                if (preparedInvocation?.confirmationMessages?.title && !(await this.shouldAutoConfirm(tool.data.id, tool.data.runsInWorkspace, tool.data.source, dto.parameters))) {
+                    const result = await this._dialogService.confirm({ message: renderAsPlaintext(preparedInvocation.confirmationMessages.title), detail: renderAsPlaintext(preparedInvocation.confirmationMessages.message) });
                     if (!result.confirmed) {
                         throw ( new CancellationError());
                     }
                 }
-                dto.toolSpecificData = prepared?.toolSpecificData;
+                dto.toolSpecificData = preparedInvocation?.toolSpecificData;
             }
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
+            invocationTimeWatch = StopWatch.create(true);
             toolResult = await tool.impl.invoke(dto, countTokens, {
                 report: step => {
                     toolInvocation?.acceptProgress(step);
                 }
             }, 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);
+                if (autoConfirmedPost) {
+                    IChatToolInvocation.confirmWith(toolInvocation, autoConfirmedPost);
+                }
+                const postConfirm = await IChatToolInvocation.awaitPostConfirmation(toolInvocation, token);
+                if (postConfirm.type === ToolConfirmKind.Denied) {
+                    throw ( new CancellationError());
+                }
+                if (postConfirm.type === ToolConfirmKind.Skipped) {
+                    toolResult = {
+                        content: [{
+                                kind: 'text',
+                                value: 'The tool executed but the user chose not to share the results'
+                            }]
+                    };
+                }
+            }
             this._telemetryService.publicLog2('languageModelToolInvoked', {
                 result: 'success',
                 chatSessionId: dto.context?.sessionId,
                 toolId: tool.data.id,
                 toolExtensionId: tool.data.source.type === 'extension' ? tool.data.source.extensionId.value : undefined,
                 toolSourceKind: tool.data.source.type,
+                prepareTimeMs: prepareTimeWatch?.elapsed(),
+                invocationTimeMs: invocationTimeWatch?.elapsed(),
             });
             return toolResult;
         }
@@ -321,6 +333,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 toolId: tool.data.id,
                 toolExtensionId: tool.data.source.type === 'extension' ? tool.data.source.extensionId.value : undefined,
                 toolSourceKind: tool.data.source.type,
+                prepareTimeMs: prepareTimeWatch?.elapsed(),
+                invocationTimeMs: invocationTimeWatch?.elapsed(),
             });
             this._logService.error(`[LanguageModelToolsService#invokeTool] Error from tool ${dto.toolId} with parameters ${JSON.stringify(dto.parameters)}:\n${toErrorMessage(err, true)}`);
             toolResult ??= { content: [] };
@@ -331,25 +345,34 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             throw err;
         }
         finally {
-            toolInvocation?.complete(toolResult);
-            if (ChatContextKeys.requestInProgress.getValue(this._contextKeyService)) {
-                this.informScreenReader(toolInvocation?.pastTenseMessage ?? `${tool.data.displayName} finished`);
-            }
+            toolInvocation?.didExecuteTool(toolResult, true);
             if (store) {
                 this.cleanupCallDisposables(requestId, store);
             }
         }
     }
     async prepareToolInvocation(tool, dto, token) {
-        const prepared = tool.impl.prepareToolInvocation ?
-            await tool.impl.prepareToolInvocation({
+        let prepared;
+        if (tool.impl.prepareToolInvocation) {
+            const preparePromise = tool.impl.prepareToolInvocation({
                 parameters: dto.parameters,
                 chatRequestId: dto.chatRequestId,
                 chatSessionId: dto.context?.sessionId,
                 chatInteractionId: dto.chatInteractionId
-            }, token)
-            : undefined;
-        if (prepared?.confirmationMessages) {
+            }, token);
+            const raceResult = await Promise.race([
+                timeout(3000, token).then(() => 'timeout'),
+                preparePromise
+            ]);
+            if (raceResult === 'timeout') {
+                this._onDidPrepareToolCallBecomeUnresponsive.fire({
+                    sessionId: dto.context?.sessionId ?? '',
+                    toolData: tool.data
+                });
+            }
+            prepared = await preparePromise;
+        }
+        if (prepared?.confirmationMessages?.title) {
             if (prepared.toolSpecificData?.kind !== 'terminal' && typeof prepared.confirmationMessages.allowAutoConfirm !== 'boolean') {
                 prepared.confirmationMessages.allowAutoConfirm = true;
             }
@@ -362,11 +385,6 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return prepared;
     }
-    informScreenReader(msg) {
-        if (this._configurationService.getValue(AccessibilityWorkbenchSettingId.VerboseChatProgressUpdates)) {
-            alert(typeof msg === 'string' ? msg : msg.value);
-        }
-    }
     playAccessibilitySignal(toolInvocations) {
         const autoApproved = this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove);
         if (autoApproved) {
@@ -409,15 +427,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
         }));
     }
-    async shouldAutoConfirm(toolId, runsInWorkspace) {
-        if (this._workspaceToolConfirmStore.value.getAutoConfirm(toolId)) {
-            return { type: ToolConfirmKind.LmServicePerTool, scope: 'workspace' };
-        }
-        if (this._profileToolConfirmStore.value.getAutoConfirm(toolId)) {
-            return { type: ToolConfirmKind.LmServicePerTool, scope: 'profile' };
-        }
-        if (( this._memoryToolConfirmStore.has(toolId))) {
-            return { type: ToolConfirmKind.LmServicePerTool, scope: 'session' };
+    async shouldAutoConfirm(toolId, runsInWorkspace, source, parameters) {
+        const reason = this._confirmationService.getPreConfirmAction({ toolId, source, parameters });
+        if (reason) {
+            return reason;
         }
         const config = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
         let value = config.value ?? config.defaultValue;
@@ -435,6 +448,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return undefined;
     }
+    async shouldAutoConfirmPostExecution(toolId, runsInWorkspace, source, parameters) {
+        if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove) && (await this._checkGlobalAutoApprove())) {
+            return { type: ToolConfirmKind.Setting, id: ChatConfiguration.GlobalAutoApprove };
+        }
+        return this._confirmationService.getPostConfirmAction({ toolId, source, parameters });
+    }
     async _checkGlobalAutoApprove() {
         const optedIn = this._storageService.getBoolean(AutoApproveStorageKeys.GlobalAutoApproveOptIn, StorageScope.APPLICATION, false);
         if (optedIn) {
@@ -445,14 +464,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         const promptResult = await this._dialogService.prompt({
             type: Severity.Warning,
-            message: ( localize(5417, 'Enable global auto approve?')),
+            message: ( localize(5604, 'Enable global auto approve?')),
             buttons: [
                 {
-                    label: ( localize(5418, 'Enable')),
+                    label: ( localize(5605, 'Enable')),
                     run: () => true
                 },
                 {
-                    label: ( localize(5419, 'Disable')),
+                    label: ( localize(5606, 'Disable')),
                     run: () => false
                 },
             ],
@@ -493,7 +512,24 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             this._callsByRequestId.delete(requestId);
         }
     }
-    toToolAndToolSetEnablementMap(enabledQualifiedToolOrToolSetNames) {
+    mapGithubToolName(name) {
+        const mapped = this._githubToVSCodeToolMap[name];
+        if (mapped) {
+            return mapped;
+        }
+        for (const [fromPrefix, toPrefix] of this._githubPrefixToVSCodePrefix) {
+            const regexp = ( new RegExp(`^${fromPrefix}(/[^/]+)$`));
+            const m = name.match(regexp);
+            if (m) {
+                return toPrefix + m[1];
+            }
+        }
+        return name;
+    }
+    toToolAndToolSetEnablementMap(enabledQualifiedToolOrToolSetNames, target) {
+        if (target === undefined || target === Target.GitHubCopilot) {
+            enabledQualifiedToolOrToolSetNames = ( enabledQualifiedToolOrToolSetNames.map(name => this.mapGithubToolName(name)));
+        }
         const toolOrToolSetNames = ( new Set(enabledQualifiedToolOrToolSetNames));
         const result = ( new Map());
         for (const [tool, toolReferenceName] of this.getPromptReferencableTools()) {
@@ -657,7 +693,8 @@ LanguageModelToolsService = ( __decorate([
     ( __param(7, IConfigurationService)),
     ( __param(8, IAccessibilityService)),
     ( __param(9, IAccessibilitySignalService)),
-    ( __param(10, IStorageService))
+    ( __param(10, IStorageService)),
+    ( __param(11, ILanguageModelToolsConfirmationService))
 ], LanguageModelToolsService));
 function getToolReferenceName(tool, toolSet) {
     const toolName = tool.toolReferenceName ?? tool.displayName;
@@ -675,51 +712,5 @@ function getToolSetReferenceName(toolSet) {
     }
     return toolSet.referenceName;
 }
-let ToolConfirmStore = class ToolConfirmStore extends Disposable {
-    static { ToolConfirmStore_1 = this; }
-    static { this.STORED_KEY = 'chat/autoconfirm'; }
-    constructor(_scope, storageService) {
-        super();
-        this._scope = _scope;
-        this.storageService = storageService;
-        this._autoConfirmTools = ( new LRUCache(100));
-        this._didChange = false;
-        const stored = storageService.getObject(ToolConfirmStore_1.STORED_KEY, this._scope);
-        if (stored) {
-            for (const key of stored) {
-                this._autoConfirmTools.set(key, true);
-            }
-        }
-        this._register(storageService.onWillSaveState(() => {
-            if (this._didChange) {
-                this.storageService.store(ToolConfirmStore_1.STORED_KEY, [...( this._autoConfirmTools.keys())], this._scope, StorageTarget.MACHINE);
-                this._didChange = false;
-            }
-        }));
-    }
-    reset() {
-        this._autoConfirmTools.clear();
-        this._didChange = true;
-    }
-    getAutoConfirm(toolId) {
-        if (this._autoConfirmTools.get(toolId)) {
-            this._didChange = true;
-            return true;
-        }
-        return false;
-    }
-    setAutoConfirm(toolId, autoConfirm) {
-        if (autoConfirm) {
-            this._autoConfirmTools.set(toolId, true);
-        }
-        else {
-            this._autoConfirmTools.delete(toolId);
-        }
-        this._didChange = true;
-    }
-};
-ToolConfirmStore = ToolConfirmStore_1 = ( __decorate([
-    ( __param(1, IStorageService))
-], ToolConfirmStore));
 
 export { LanguageModelToolsService, globalAutoApproveDescription };

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatEditingEditorOverlay.css

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 .chat-editor-overlay-widget {
-	padding: 0px;
+	padding: 2px;
 	color: var(--vscode-button-foreground);
 	background-color: var(--vscode-button-background);
 	border-radius: 2px;
@@ -56,6 +56,7 @@
 .chat-editor-overlay-widget .action-item > .action-label {
 	padding: 5px;
 	font-size: 12px;
+	border-radius: 2px; /* same as overlay widget */
 }
 
 
@@ -84,6 +85,10 @@
 	}
 }
 
+.chat-diff-change-content-widget .action-item > .action-label {
+	border-radius: 2px; /* same as overlay widget */
+}
+
 
 .chat-editor-overlay-widget .action-item.label-item {
 	font-variant-numeric: tabular-nums;

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatEditorController.css

@@ -19,12 +19,13 @@
 	border-radius: 2px;
 	background-color: var(--vscode-button-background);
 	color: var(--vscode-button-foreground);
+	border: 1px solid var(--vscode-contrastBorder);
 }
 
 .chat-diff-change-content-widget .monaco-action-bar .action-item .action-label {
-	height: 14px;
 	border-radius: 2px;
 	color: var(--vscode-button-foreground);
+	padding: 2px 5px;
 }
 
 .chat-diff-change-content-widget .monaco-action-bar .action-item .action-label.codicon {

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatSessions.css

@@ -92,7 +92,7 @@
 	align-items: center;
 	font-size: 0.9em;
 	line-height: 1em;
-	margin: 2px 22px 0 22px;
+	margin: 2px 22px 0 20px;
 	overflow: hidden;
 	text-overflow: ellipsis;
 	white-space: nowrap;
@@ -115,6 +115,16 @@
 .chat-sessions-tree-container .chat-session-item .description-row .description {
 	opacity: 0.5;
 }
+
+.chat-sessions-tree-container .chat-session-item .description-row .description p {
+	display: flex;
+	align-items: center;
+}
+
+.chat-sessions-tree-container .chat-session-item .description-row .description p .codicon {
+	font-size: 14px;
+}
+
 .chat-sessions-tree-container .chat-session-item .description-row .statistics {
 	margin-left: 8px;
 }
@@ -260,3 +270,30 @@
 .chat-sessions-tree-container .chat-session-item[data-history-item="true"]:hover {
 	background-color: var(--vscode-list-hoverBackground);
 }
+
+/* Chat editor relative positioning for loading overlay */
+.chat-editor-relative {
+	position: relative;
+}
+
+/* Chat editor loading overlay styles */
+.chat-loading-overlay {
+	position: absolute;
+	inset: 0;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	background: var(--vscode-editor-background);
+	z-index: 1000;
+}
+
+.chat-loading-overlay .chat-loading-content {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	color: var(--vscode-editor-foreground);
+}
+
+.chat-loading-overlay .codicon {
+	font-size: 16px;
+}