@codingame/monaco-vscode-chat-service-override 23.3.0 → 24.1.0

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

@@ -6,15 +6,17 @@ import { RunOnceScheduler, timeout } from '@codingame/monaco-vscode-api/vscode/v
 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';
+import { itemsEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
 import { CancellationError, isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { MarkdownString, markdownCommandLink } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { MarkdownString, createMarkdownCommandLink } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { Disposable, DisposableStore, toDisposable, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 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 { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 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';
@@ -25,6 +27,7 @@ import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
@@ -37,11 +40,13 @@ import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 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 { 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 { ToolDataSource, VSCodeToolReference, SpecedToolAliases, ToolSet, createToolSchemaUri, stringifyPromptTsxPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { getToolConfirmationAlert } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatAccessibilityProvider';
+import { observableFromEventOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 import { ObservableSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/set';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
+var LanguageModelToolsService_1;
 const jsonSchemaRegistry = ( Registry.as(Extensions.JSONContribution));
 var AutoApproveStorageKeys;
 (function (AutoApproveStorageKeys) {
@@ -49,10 +54,11 @@ var AutoApproveStorageKeys;
 })(AutoApproveStorageKeys || (AutoApproveStorageKeys = {}));
 const SkipAutoApproveConfirmationKey = 'vscode.chat.tools.global.autoApprove.testMode';
 const globalAutoApproveDescription = ( localize2(
-    5623,
+    5729,
     '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 {
+    static { LanguageModelToolsService_1 = this; }
     constructor(_instantiationService, _extensionService, _contextKeyService, _chatService, _dialogService, _telemetryService, _logService, _configurationService, _accessibilityService, _accessibilitySignalService, _storageService, _confirmationService) {
         super();
         this._instantiationService = _instantiationService;
@@ -75,22 +81,39 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this._tools = ( new Map());
         this._toolContextKeys = ( new Set());
         this._callsByRequestId = ( new Map());
-        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.toolsObservable = observableFromEventOpts({ equalsFn: itemsEquals() }, this.onDidChangeTools, () => Array.from(this.getTools()));
         this._toolSets = ( new ObservableSet());
-        this.toolSets = this._toolSets.observable;
+        this.toolSets = derived(this, reader => {
+            const allToolSets = Array.from(this._toolSets.observable.read(reader));
+            return allToolSets.filter(toolSet => this.isPermitted(toolSet, reader));
+        });
+        this.toolsWithFullReferenceName = derived(reader => {
+            const result = [];
+            const coveredByToolSets = ( new Set());
+            for (const toolSet of this.toolSets.read(reader)) {
+                if (toolSet.source.type !== 'user') {
+                    result.push([toolSet, getToolSetFullReferenceName(toolSet)]);
+                    for (const tool of toolSet.getTools()) {
+                        result.push([tool, getToolFullReferenceName(tool, toolSet)]);
+                        coveredByToolSets.add(tool);
+                    }
+                }
+            }
+            for (const tool of this.toolsObservable.read(reader)) {
+                if (tool.canBeReferencedInPrompt && !( coveredByToolSets.has(tool)) && this.isPermitted(tool, reader)) {
+                    result.push([tool, getToolFullReferenceName(tool)]);
+                }
+            }
+            return result;
+        });
+        this._isAgentModeEnabled = observableConfigValue(ChatConfiguration.AgentEnabled, true, this._configurationService);
         this._register(this._contextKeyService.onDidChangeContext(e => {
             if (e.affectsSome(this._toolContextKeys)) {
                 this._onDidChangeToolsScheduler.schedule();
             }
         }));
         this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(ChatConfiguration.ExtensionToolsEnabled)) {
+            if (e.affectsConfiguration(ChatConfiguration.ExtensionToolsEnabled) || e.affectsConfiguration(ChatConfiguration.AgentEnabled)) {
                 this._onDidChangeToolsScheduler.schedule();
             }
         }));
@@ -102,6 +125,32 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
         }));
         this._ctxToolsCount = ChatContextKeys.Tools.toolsCount.bindTo(_contextKeyService);
+        this.vscodeToolSet = this._register(this.createToolSet(ToolDataSource.Internal, 'vscode', VSCodeToolReference.vscode, {
+            icon: ThemeIcon.fromId(Codicon.vscode.id),
+            description: ( localize(5730, 'Use VS Code features')),
+        }));
+        this.executeToolSet = this._register(this.createToolSet(ToolDataSource.Internal, 'execute', SpecedToolAliases.execute, {
+            icon: ThemeIcon.fromId(Codicon.terminal.id),
+            description: ( localize(5731, 'Execute code and applications on your machine')),
+        }));
+        this.readToolSet = this._register(this.createToolSet(ToolDataSource.Internal, 'read', SpecedToolAliases.read, {
+            icon: ThemeIcon.fromId(Codicon.eye.id),
+            description: ( localize(5732, 'Read files in your workspace')),
+        }));
+    }
+    isPermitted(toolOrToolSet, reader) {
+        const agentModeEnabled = this._isAgentModeEnabled.read(reader);
+        if (agentModeEnabled !== false) {
+            return true;
+        }
+        const permittedInternalToolSetIds = [SpecedToolAliases.read, SpecedToolAliases.search, SpecedToolAliases.web];
+        if (toolOrToolSet instanceof ToolSet) {
+            const permitted = toolOrToolSet.source.type === 'internal' && permittedInternalToolSetIds.includes(toolOrToolSet.referenceName);
+            this._logService.trace(`LanguageModelToolsService#isPermitted: ToolSet ${toolOrToolSet.id} (${toolOrToolSet.referenceName}) permitted=${permitted}`);
+            return permitted;
+        }
+        this._logService.trace(`LanguageModelToolsService#isPermitted: Tool ${toolOrToolSet.id} (${toolOrToolSet.toolReferenceName}) permitted=false`);
+        return false;
     }
     dispose() {
         super.dispose();
@@ -162,7 +211,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return Iterable.filter(toolDatas, toolData => {
             const satisfiesWhenClause = includeDisabled || !toolData.when || this._contextKeyService.contextMatchesRules(toolData.when);
             const satisfiesExternalToolCheck = toolData.source.type !== 'extension' || !!extensionToolsEnabled;
-            return satisfiesWhenClause && satisfiesExternalToolCheck;
+            const satisfiesPermittedCheck = includeDisabled || this.isPermitted(toolData);
+            return satisfiesWhenClause && satisfiesExternalToolCheck && satisfiesPermittedCheck;
         });
     }
     getTool(id) {
@@ -208,14 +258,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         try {
             if (dto.context) {
                 store = ( new DisposableStore());
-                const model = this._chatService.getSessionByLegacyId(dto.context.sessionId);
+                const model = this._chatService.getSession(dto.context.sessionResource);
                 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;
+                dto.userSelectedTools = request.userSelectedTools && { ...request.userSelectedTools };
                 if (!( this._callsByRequestId.has(requestId))) {
                     this._callsByRequestId.set(requestId, []);
                 }
@@ -248,7 +298,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 if (autoConfirmed) {
                     IChatToolInvocation.confirmWith(toolInvocation, autoConfirmed);
                 }
-                model.acceptResponseProgress(request, toolInvocation);
+                this._chatService.appendProgress(request, toolInvocation);
                 dto.toolSpecificData = toolInvocation?.toolSpecificData;
                 if (preparedInvocation?.confirmationMessages?.title) {
                     if (!IChatToolInvocation.executionConfirmedOrDenied(toolInvocation) && !autoConfirmed) {
@@ -377,26 +427,26 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             if (!prepared) {
                 prepared = {};
             }
-            const toolReferenceName = getToolReferenceName(tool.data);
+            const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(5624, 'Allow tool to execute?')),
-                message: ( localize(5625, 'Run the \'{0}\' tool?', toolReferenceName)),
+                title: ( localize(5733, 'Allow tool to execute?')),
+                message: ( localize(5734, 'Run the \'{0}\' tool?', fullReferenceName)),
                 disclaimer: ( new MarkdownString(( localize(
-                    5626,
+                    5735,
                     'Auto approval for \'{0}\' is restricted via {1}.',
-                    getToolReferenceName(tool.data),
-                    markdownCommandLink({ title: '`' + ChatConfiguration.EligibleForAutoApproval + '`', id: 'workbench.action.openSettings', arguments: [ChatConfiguration.EligibleForAutoApproval] }, false)
+                    getToolFullReferenceName(tool.data),
+                    createMarkdownCommandLink({ title: '`' + ChatConfiguration.EligibleForAutoApproval + '`', id: 'workbench.action.openSettings', arguments: [ChatConfiguration.EligibleForAutoApproval] }, false)
                 )), { isTrusted: true })),
                 allowAutoConfirm: false,
             };
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
             prepared.confirmationMessages.disclaimer = ( new MarkdownString(( localize(
-                5626,
+                5735,
                 'Auto approval for \'{0}\' is restricted via {1}.',
-                getToolReferenceName(tool.data),
-                markdownCommandLink({ title: '`' + ChatConfiguration.EligibleForAutoApproval + '`', id: 'workbench.action.openSettings', arguments: [ChatConfiguration.EligibleForAutoApproval] }, false)
+                getToolFullReferenceName(tool.data),
+                createMarkdownCommandLink({ title: '`' + ChatConfiguration.EligibleForAutoApproval + '`', id: 'workbench.action.openSettings', arguments: [ChatConfiguration.EligibleForAutoApproval] }, false)
             )), { isTrusted: true }));
         }
         if (prepared?.confirmationMessages?.title) {
@@ -454,21 +504,37 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
         }));
     }
-    getEligbleForAutoApprovalSpecialCase(toolData) {
+    getEligibleForAutoApprovalSpecialCase(toolData) {
         if (toolData.id === 'vscode_fetchWebPage_internal') {
             return 'fetch';
         }
         return undefined;
     }
     isToolEligibleForAutoApproval(toolData) {
-        const toolReferenceName = this.getEligbleForAutoApprovalSpecialCase(toolData) ?? getToolReferenceName(toolData);
+        const fullReferenceName = this.getEligibleForAutoApprovalSpecialCase(toolData) ?? getToolFullReferenceName(toolData);
         if (toolData.id === 'copilot_fetchWebPage') {
             return true;
         }
         const eligibilityConfig = this._configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
-        return eligibilityConfig && typeof eligibilityConfig === 'object' && toolReferenceName
-            ? (eligibilityConfig[toolReferenceName] ?? true)
-            : true;
+        if (eligibilityConfig && typeof eligibilityConfig === 'object' && fullReferenceName) {
+            if (Object.prototype.hasOwnProperty.call(eligibilityConfig, fullReferenceName)) {
+                return eligibilityConfig[fullReferenceName];
+            }
+            if (toolData.legacyToolReferenceFullNames) {
+                for (const legacyName of toolData.legacyToolReferenceFullNames) {
+                    if (Object.prototype.hasOwnProperty.call(eligibilityConfig, legacyName)) {
+                        return eligibilityConfig[legacyName];
+                    }
+                    if (legacyName.includes('/')) {
+                        const trimmedLegacyName = legacyName.split('/').pop();
+                        if (trimmedLegacyName && Object.prototype.hasOwnProperty.call(eligibilityConfig, trimmedLegacyName)) {
+                            return eligibilityConfig[trimmedLegacyName];
+                        }
+                    }
+                }
+            }
+        }
+        return true;
     }
     async shouldAutoConfirm(toolId, runsInWorkspace, source, parameters) {
         const tool = this._tools.get(toolId);
@@ -514,14 +580,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         const promptResult = await this._dialogService.prompt({
             type: Severity.Warning,
-            message: ( localize(5627, 'Enable global auto approve?')),
+            message: ( localize(5736, 'Enable global auto approve?')),
             buttons: [
                 {
-                    label: ( localize(5628, 'Enable')),
+                    label: ( localize(5737, 'Enable')),
                     run: () => true
                 },
                 {
-                    label: ( localize(5629, 'Disable')),
+                    label: ( localize(5738, 'Disable')),
                     run: () => false
                 },
             ],
@@ -562,29 +628,71 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             this._callsByRequestId.delete(requestId);
         }
     }
-    mapGithubToolName(name) {
-        const mapped = this._githubToVSCodeToolMap[name];
-        if (mapped) {
-            return mapped;
+    static { this.githubMCPServerAliases = ['github/github-mcp-server', 'io.github.github/github-mcp-server', 'github-mcp-server']; }
+    static { this.playwrightMCPServerAliases = ['microsoft/playwright-mcp', 'com.microsoft/playwright-mcp']; }
+    *getToolSetAliases(toolSet, fullReferenceName) {
+        if (fullReferenceName !== toolSet.referenceName) {
+            yield toolSet.referenceName;
+        }
+        if (toolSet.legacyFullNames) {
+            yield* toolSet.legacyFullNames;
         }
-        for (const [fromPrefix, toPrefix] of this._githubPrefixToVSCodePrefix) {
-            const regexp = ( new RegExp(`^${fromPrefix}(/[^/]+)$`));
-            const m = name.match(regexp);
-            if (m) {
-                return toPrefix + m[1];
+        switch (toolSet.referenceName) {
+            case 'github':
+                for (const alias of LanguageModelToolsService_1.githubMCPServerAliases) {
+                    yield alias + '/*';
+                }
+                break;
+            case 'playwright':
+                for (const alias of LanguageModelToolsService_1.playwrightMCPServerAliases) {
+                    yield alias + '/*';
+                }
+                break;
+            case SpecedToolAliases.execute:
+                yield 'shell';
+                break;
+            case SpecedToolAliases.agent:
+                yield VSCodeToolReference.runSubagent;
+                yield 'custom-agent';
+                break;
+        }
+    }
+    *getToolAliases(toolSet, fullReferenceName) {
+        const referenceName = toolSet.toolReferenceName ?? toolSet.displayName;
+        if (fullReferenceName !== referenceName && referenceName !== VSCodeToolReference.runSubagent) {
+            yield referenceName;
+        }
+        if (toolSet.legacyToolReferenceFullNames) {
+            for (const legacyName of toolSet.legacyToolReferenceFullNames) {
+                yield legacyName;
+                const lastSlashIndex = legacyName.lastIndexOf('/');
+                if (lastSlashIndex !== -1) {
+                    yield legacyName.substring(lastSlashIndex + 1);
+                }
             }
         }
-        return name;
-    }
-    toToolAndToolSetEnablementMap(enabledQualifiedToolOrToolSetNames, target) {
-        if (target === undefined || target === Target.GitHubCopilot) {
-            enabledQualifiedToolOrToolSetNames = ( enabledQualifiedToolOrToolSetNames.map(name => this.mapGithubToolName(name)));
+        const slashIndex = fullReferenceName.lastIndexOf('/');
+        if (slashIndex !== -1) {
+            switch (fullReferenceName.substring(0, slashIndex)) {
+                case 'github':
+                    for (const alias of LanguageModelToolsService_1.githubMCPServerAliases) {
+                        yield alias + fullReferenceName.substring(slashIndex);
+                    }
+                    break;
+                case 'playwright':
+                    for (const alias of LanguageModelToolsService_1.playwrightMCPServerAliases) {
+                        yield alias + fullReferenceName.substring(slashIndex);
+                    }
+                    break;
+            }
         }
-        const toolOrToolSetNames = ( new Set(enabledQualifiedToolOrToolSetNames));
+    }
+    toToolAndToolSetEnablementMap(fullReferenceNames, _target) {
+        const toolOrToolSetNames = ( new Set(fullReferenceNames));
         const result = ( new Map());
-        for (const [tool, toolReferenceName] of this.getPromptReferencableTools()) {
+        for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
             if (tool instanceof ToolSet) {
-                const enabled = ( toolOrToolSetNames.has(toolReferenceName)) || ( toolOrToolSetNames.has(tool.referenceName));
+                const enabled = ( toolOrToolSetNames.has(fullReferenceName)) || ( Iterable.some(this.getToolSetAliases(tool, fullReferenceName), name => ( toolOrToolSetNames.has(name))));
                 result.set(tool, enabled);
                 if (enabled) {
                     for (const memberTool of tool.getTools()) {
@@ -594,7 +702,12 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
             else {
                 if (!( result.has(tool))) {
-                    const enabled = ( toolOrToolSetNames.has(toolReferenceName)) || ( toolOrToolSetNames.has(tool.toolReferenceName ?? tool.displayName));
+                    const enabled = ( toolOrToolSetNames.has(fullReferenceName))
+                        || ( Iterable.some(this.getToolAliases(tool, fullReferenceName), name => ( toolOrToolSetNames.has(name))))
+                        || !!tool.legacyToolReferenceFullNames?.some(toolFullName => {
+                            const index = toolFullName.lastIndexOf('/');
+                            return index !== -1 && ( toolOrToolSetNames.has(toolFullName.substring(0, index)));
+                        });
                     result.set(tool, enabled);
                 }
             }
@@ -607,13 +720,13 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return result;
     }
-    toQualifiedToolNames(map) {
+    toFullReferenceNames(map) {
         const result = [];
         const toolsCoveredByEnabledToolSet = ( new Set());
-        for (const [tool, toolReferenceName] of this.getPromptReferencableTools()) {
+        for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
             if (tool instanceof ToolSet) {
                 if (map.get(tool)) {
-                    result.push(toolReferenceName);
+                    result.push(fullReferenceName);
                     for (const memberTool of tool.getTools()) {
                         toolsCoveredByEnabledToolSet.add(memberTool);
                     }
@@ -621,7 +734,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
             else {
                 if (map.get(tool) && !( toolsCoveredByEnabledToolSet.has(tool))) {
-                    result.push(toolReferenceName);
+                    result.push(fullReferenceName);
                 }
             }
         }
@@ -629,8 +742,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     }
     toToolReferences(variableReferences) {
         const toolsOrToolSetByName = ( new Map());
-        for (const [tool, toolReferenceName] of this.getPromptReferencableTools()) {
-            toolsOrToolSetByName.set(toolReferenceName, tool);
+        for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
+            toolsOrToolSetByName.set(fullReferenceName, tool);
         }
         const result = [];
         for (const ref of variableReferences) {
@@ -662,8 +775,18 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return undefined;
     }
+    getSpecedToolSetName(referenceName) {
+        if (LanguageModelToolsService_1.githubMCPServerAliases.includes(referenceName)) {
+            return 'github';
+        }
+        if (LanguageModelToolsService_1.playwrightMCPServerAliases.includes(referenceName)) {
+            return 'playwright';
+        }
+        return referenceName;
+    }
     createToolSet(source, id, referenceName, options) {
         const that = this;
+        referenceName = this.getSpecedToolSetName(referenceName);
         const result = new (class extends ToolSet {
             dispose() {
                 if (( that._toolSets.has(result))) {
@@ -671,68 +794,80 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     that._toolSets.delete(result);
                 }
             }
-        })(id, referenceName, options?.icon ?? Codicon.tools, source, options?.description);
+        })(id, referenceName, options?.icon ?? Codicon.tools, source, options?.description, options?.legacyFullNames);
         this._toolSets.add(result);
         return result;
     }
-    *getPromptReferencableTools() {
-        const coveredByToolSets = ( new Set());
-        for (const toolSet of this.toolSets.get()) {
-            if (toolSet.source.type !== 'user') {
-                yield [toolSet, getToolSetReferenceName(toolSet)];
-                for (const tool of toolSet.getTools()) {
-                    yield [tool, getToolReferenceName(tool, toolSet)];
-                    coveredByToolSets.add(tool);
-                }
-            }
-        }
-        for (const tool of this.getTools()) {
-            if (tool.canBeReferencedInPrompt && !( coveredByToolSets.has(tool))) {
-                yield [tool, getToolReferenceName(tool)];
-            }
-        }
-    }
-    *getQualifiedToolNames() {
-        for (const [, toolReferenceName] of this.getPromptReferencableTools()) {
-            yield toolReferenceName;
+    *getFullReferenceNames() {
+        for (const [, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
+            yield fullReferenceName;
         }
     }
-    getDeprecatedQualifiedToolNames() {
+    getDeprecatedFullReferenceNames() {
         const result = ( new Map());
-        const add = (name, toolReferenceName) => {
-            if (name !== toolReferenceName) {
-                result.set(name, toolReferenceName);
+        const knownToolSetNames = ( new Set());
+        const add = (name, fullReferenceName) => {
+            if (name !== fullReferenceName) {
+                if (!( result.has(name))) {
+                    result.set(name, ( new Set()));
+                }
+                result.get(name).add(fullReferenceName);
             }
         };
-        for (const [tool, toolReferenceName] of this.getPromptReferencableTools()) {
+        for (const [tool, _] of this.toolsWithFullReferenceName.get()) {
+            if (tool instanceof ToolSet) {
+                knownToolSetNames.add(tool.referenceName);
+                if (tool.legacyFullNames) {
+                    for (const legacyName of tool.legacyFullNames) {
+                        knownToolSetNames.add(legacyName);
+                    }
+                }
+            }
+        }
+        for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
             if (tool instanceof ToolSet) {
-                add(tool.referenceName, toolReferenceName);
+                for (const alias of this.getToolSetAliases(tool, fullReferenceName)) {
+                    add(alias, fullReferenceName);
+                }
             }
             else {
-                add(tool.toolReferenceName ?? tool.displayName, toolReferenceName);
+                for (const alias of this.getToolAliases(tool, fullReferenceName)) {
+                    add(alias, fullReferenceName);
+                }
+                if (tool.legacyToolReferenceFullNames) {
+                    for (const legacyName of tool.legacyToolReferenceFullNames) {
+                        if (legacyName.includes('/')) {
+                            const toolSetFullName = legacyName.substring(0, legacyName.lastIndexOf('/'));
+                            if (!( knownToolSetNames.has(toolSetFullName))) {
+                                add(toolSetFullName, fullReferenceName);
+                            }
+                        }
+                    }
+                }
             }
         }
         return result;
     }
-    getToolByQualifiedName(qualifiedName) {
-        for (const [tool, toolReferenceName] of this.getPromptReferencableTools()) {
-            if (qualifiedName === toolReferenceName) {
+    getToolByFullReferenceName(fullReferenceName) {
+        for (const [tool, toolFullReferenceName] of this.toolsWithFullReferenceName.get()) {
+            if (fullReferenceName === toolFullReferenceName) {
                 return tool;
             }
-            if (qualifiedName === (tool instanceof ToolSet ? tool.referenceName : tool.toolReferenceName ?? tool.displayName)) {
+            const aliases = tool instanceof ToolSet ? this.getToolSetAliases(tool, toolFullReferenceName) : this.getToolAliases(tool, toolFullReferenceName);
+            if (( Iterable.some(aliases, alias => fullReferenceName === alias))) {
                 return tool;
             }
         }
         return undefined;
     }
-    getQualifiedToolName(tool, toolSet) {
+    getFullReferenceName(tool, toolSet) {
         if (tool instanceof ToolSet) {
-            return getToolSetReferenceName(tool);
+            return getToolSetFullReferenceName(tool);
         }
-        return getToolReferenceName(tool, toolSet);
+        return getToolFullReferenceName(tool, toolSet);
     }
 };
-LanguageModelToolsService = ( __decorate([
+LanguageModelToolsService = LanguageModelToolsService_1 = ( __decorate([
     ( __param(0, IInstantiationService)),
     ( __param(1, IExtensionService)),
     ( __param(2, IContextKeyService)),
@@ -746,7 +881,7 @@ LanguageModelToolsService = ( __decorate([
     ( __param(10, IStorageService)),
     ( __param(11, ILanguageModelToolsConfirmationService))
 ], LanguageModelToolsService));
-function getToolReferenceName(tool, toolSet) {
+function getToolFullReferenceName(tool, toolSet) {
     const toolName = tool.toolReferenceName ?? tool.displayName;
     if (toolSet) {
         return `${toolSet.referenceName}/${toolName}`;
@@ -756,7 +891,7 @@ function getToolReferenceName(tool, toolSet) {
     }
     return toolName;
 }
-function getToolSetReferenceName(toolSet) {
+function getToolSetFullReferenceName(toolSet) {
     if (toolSet.source.type === 'mcp') {
         return `${toolSet.referenceName}/*`;
     }

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

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.interactive-session .interactive-input-part > .chat-input-widgets-container .chat-status-widget {
+	padding: 6px 3px 6px 3px;
+	box-sizing: border-box;
+	border: 1px solid var(--vscode-input-border, transparent);
+	background-color: var(--vscode-editor-background);
+	border-bottom: none;
+	border-top-left-radius: 4px;
+	border-top-right-radius: 4px;
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 8px;
+}
+
+.interactive-session .interactive-input-part > .chat-input-widgets-container .chat-status-widget .chat-status-content {
+	display: flex;
+	align-items: center;
+	flex: 1;
+	min-width: 0;
+	padding-left: 8px;
+}
+
+.interactive-session .interactive-input-part > .chat-input-widgets-container .chat-status-widget .chat-status-message {
+	font-size: 11px;
+	line-height: 16px;
+	color: var(--vscode-foreground);
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.interactive-session .interactive-input-part > .chat-input-widgets-container .chat-status-widget .chat-status-action {
+	flex-shrink: 0;
+	padding-right: 4px;
+}
+
+.interactive-session .interactive-input-part > .chat-input-widgets-container .chat-status-widget .chat-status-button {
+	font-size: 11px;
+	padding: 2px 8px;
+	min-width: unset;
+	height: 22px;
+}
+
+.interactive-session .interactive-input-part > .chat-input-widgets-container:has(.chat-status-widget:not([style*="display: none"])) + .chat-todo-list-widget-container .chat-todo-list-widget {
+	border-top-left-radius: 0;
+	border-top-right-radius: 0;
+}
+
+.interactive-session .interactive-input-part > .chat-input-widgets-container:has(.chat-status-widget:not([style*="display: none"])) + .chat-todo-list-widget-container:not(:has(.chat-todo-list-widget.has-todos)) + .chat-editing-session .chat-editing-session-container {
+	border-top-left-radius: 0;
+	border-top-right-radius: 0;
+}