@codingame/monaco-vscode-chat-service-override 21.5.1 → 22.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatToolActions.js

@@ -22,14 +22,29 @@ import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ToolsScope } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/chatSelectedTools';
 import { CHAT_CATEGORY } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { AcceptToolConfirmationActionId } from '@codingame/monaco-vscode-eda30bac-0984-5b42-9362-c68996b85232-common/vscode/vs/workbench/contrib/chat/browser/actions/chatConstants';
+import { AcceptToolConfirmationActionId, SkipToolConfirmationActionId } from '@codingame/monaco-vscode-eda30bac-0984-5b42-9362-c68996b85232-common/vscode/vs/workbench/contrib/chat/browser/actions/chatConstants';
 import { showToolsPicker } from './chatToolPicker.js';
 
-class AcceptToolConfirmation extends Action2 {
+class ToolConfirmationAction extends Action2 {
+    run(accessor, ...args) {
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const widget = chatWidgetService.lastFocusedWidget;
+        const lastItem = widget?.viewModel?.getItems().at(-1);
+        if (!isResponseVM(lastItem)) {
+            return;
+        }
+        const unconfirmedToolInvocation = lastItem.model.response.value.find((item) => item.kind === 'toolInvocation' && item.isConfirmed === undefined);
+        if (unconfirmedToolInvocation) {
+            unconfirmedToolInvocation.confirmed.complete(this.getReason());
+        }
+        widget?.focusInput();
+    }
+}
+class AcceptToolConfirmation extends ToolConfirmationAction {
     constructor() {
         super({
             id: AcceptToolConfirmationActionId,
-            title: ( localize2(4707, "Accept")),
+            title: ( localize2(4735, "Accept")),
             f1: false,
             category: CHAT_CATEGORY,
             keybinding: {
@@ -39,18 +54,26 @@ class AcceptToolConfirmation extends Action2 {
             },
         });
     }
-    run(accessor, ...args) {
-        const chatWidgetService = accessor.get(IChatWidgetService);
-        const widget = chatWidgetService.lastFocusedWidget;
-        const lastItem = widget?.viewModel?.getItems().at(-1);
-        if (!isResponseVM(lastItem)) {
-            return;
-        }
-        const unconfirmedToolInvocation = lastItem.model.response.value.find((item) => item.kind === 'toolInvocation' && item.isConfirmed === undefined);
-        if (unconfirmedToolInvocation) {
-            unconfirmedToolInvocation.confirmed.complete({ type: ToolConfirmKind.UserAction });
-        }
-        widget?.focusInput();
+    getReason() {
+        return { type: ToolConfirmKind.UserAction };
+    }
+}
+class SkipToolConfirmation extends ToolConfirmationAction {
+    constructor() {
+        super({
+            id: SkipToolConfirmationActionId,
+            title: ( localize2(4736, "Skip")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            keybinding: {
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ChatContextKeys.Editing.hasToolConfirmation)),
+                primary: KeyMod.CtrlCmd | KeyCode.Enter | KeyMod.Alt,
+                weight: KeybindingWeight.WorkbenchContrib + 1,
+            },
+        });
+    }
+    getReason() {
+        return { type: ToolConfirmKind.Skipped };
     }
 }
 class ConfigureToolsAction extends Action2 {
@@ -58,7 +81,7 @@ class ConfigureToolsAction extends Action2 {
     constructor() {
         super({
             id: ConfigureToolsAction.ID,
-            title: ( localize(4708, "Configure Tools...")),
+            title: ( localize(4737, "Configure Tools...")),
             icon: Codicon.tools,
             f1: false,
             category: CHAT_CATEGORY,
@@ -93,26 +116,26 @@ class ConfigureToolsAction extends Action2 {
         const { entriesScope, entriesMap } = widget.input.selectedToolsModel;
         switch (entriesScope) {
             case ToolsScope.Session:
-                placeholder = ( localize(4709, "Select tools for this chat session"));
+                placeholder = ( localize(4738, "Select tools for this chat session"));
                 description = ( localize(
-                    4710,
+                    4739,
                     "The selected tools were configured by a prompt command and only apply to this chat session."
                 ));
                 break;
             case ToolsScope.Mode:
-                placeholder = ( localize(4711, "Select tools for this chat mode"));
+                placeholder = ( localize(4740, "Select tools for this chat mode"));
                 description = ( localize(
-                    4712,
+                    4741,
                     "The selected tools are configured by the '{0}' chat mode. Changes to the tools will be applied to the mode file as well.",
                     widget.input.currentModeObs.get().label
                 ));
                 break;
             case ToolsScope.Global:
-                placeholder = ( localize(4713, "Select tools that are available to chat."));
+                placeholder = ( localize(4742, "Select tools that are available to chat."));
                 description = undefined;
                 break;
         }
-        const result = await instaService.invokeFunction(showToolsPicker, placeholder, description, entriesMap.get());
+        const result = await instaService.invokeFunction(showToolsPicker, placeholder, description, () => entriesMap.get());
         if (result) {
             widget.input.selectedToolsModel.set(result, false);
         }
@@ -157,7 +180,7 @@ let ConfigureToolsActionRendering = class ConfigureToolsActionRendering {
                 getTooltip() {
                     if (this.isAboveToolLimit()) {
                         const warningMessage = ( localize(
-                            4714,
+                            4743,
                             'More than {0} tools are enabled, you may experience degraded tool calling.',
                             this._contextKeyService.getContextKeyValue(ChatContextKeys.chatToolGroupingThreshold.key)
                         ));
@@ -185,6 +208,7 @@ ConfigureToolsActionRendering = ( __decorate([
 ], ConfigureToolsActionRendering));
 function registerChatToolActions() {
     registerAction2(AcceptToolConfirmation);
+    registerAction2(SkipToolConfirmation);
     registerAction2(ConfigureToolsAction);
     registerWorkbenchContribution2(ConfigureToolsActionRendering.ID, ConfigureToolsActionRendering, WorkbenchPhase.BlockRestore);
 }

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

@@ -15,4 +15,4 @@ import { IToolData, ToolSet } from "@codingame/monaco-vscode-api/vscode/vs/workb
  * @param onUpdate - Optional callback fired when the selection changes
  * @returns Promise resolving to the final selection map, or undefined if cancelled
  */
-export declare function showToolsPicker(accessor: ServicesAccessor, placeHolder: string, description?: string, toolsEntries?: ReadonlyMap<ToolSet | IToolData, boolean>): Promise<ReadonlyMap<ToolSet | IToolData, boolean> | undefined>;
+export declare function showToolsPicker(accessor: ServicesAccessor, placeHolder: string, description?: string, getToolsEntries?: () => ReadonlyMap<ToolSet | IToolData, boolean>): Promise<ReadonlyMap<ToolSet | IToolData, boolean> | undefined>;

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatToolPicker.js

@@ -1,28 +1,29 @@
 
 import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { markdownCommandLink } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
 import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { ExtensionEditorTab } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions';
 import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
-import { McpCommandIds } from '@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
+import { McpCommandIds } from '@codingame/monaco-vscode-37b3b402-09f5-5f69-89ef-ce30559f63cc-common/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { McpServerEditorTab, McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { McpServerEditorTab, McpConnectionState, McpServerCacheState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { IMcpService, IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { startServerAndWaitForLiveTools } from '@codingame/monaco-vscode-37b3b402-09f5-5f69-89ef-ce30559f63cc-common/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 import { ToolDataSource } 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';
 import { ConfigureToolSets } from '../tools/toolSetsContribution.js';
-import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
-import { markdownCommandLink } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 
 var BucketOrdinal;
 (function (BucketOrdinal) {
@@ -76,7 +77,7 @@ function createToolSetTreeItem(toolset, checked, editorService) {
         const resource = toolset.source.file;
         buttons.push({
             iconClass: ThemeIcon.asClassName(Codicon.edit),
-            tooltip: ( localize(4715, "Edit Tool Set")),
+            tooltip: ( localize(4744, "Edit Tool Set")),
             action: () => editorService.openEditor({ resource })
         });
     }
@@ -93,7 +94,7 @@ function createToolSetTreeItem(toolset, checked, editorService) {
         ...iconProps
     };
 }
-async function showToolsPicker(accessor, placeHolder, description, toolsEntries) {
+async function showToolsPicker(accessor, placeHolder, description, getToolsEntries) {
     const quickPickService = accessor.get(IQuickInputService);
     const mcpService = accessor.get(IMcpService);
     const mcpRegistry = accessor.get(IMcpRegistry);
@@ -109,171 +110,225 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries)
             mcpServerByTool.set(tool.id, server);
         }
     }
-    if (!toolsEntries) {
-        const defaultEntries = ( new Map());
-        for (const tool of toolsService.getTools()) {
-            if (tool.canBeReferencedInPrompt) {
-                defaultEntries.set(tool, false);
+    function computeItems(previousToolsEntries) {
+        let toolsEntries = getToolsEntries ? ( new Map(getToolsEntries())) : undefined;
+        if (!toolsEntries) {
+            const defaultEntries = ( new Map());
+            for (const tool of toolsService.getTools()) {
+                if (tool.canBeReferencedInPrompt) {
+                    defaultEntries.set(tool, false);
+                }
             }
+            for (const toolSet of toolsService.toolSets.get()) {
+                defaultEntries.set(toolSet, false);
+            }
+            toolsEntries = defaultEntries;
         }
+        previousToolsEntries?.forEach((value, key) => {
+            toolsEntries.set(key, value);
+        });
+        const treeItems = [];
+        const bucketMap = ( new Map());
+        const getKey = (source) => {
+            switch (source.type) {
+                case 'mcp':
+                case 'extension':
+                    return ToolDataSource.toKey(source);
+                case 'internal':
+                    return ( BucketOrdinal.BuiltIn.toString());
+                case 'user':
+                    return ( BucketOrdinal.User.toString());
+                case 'external':
+                    throw ( new Error('should not be reachable'));
+                default:
+                    assertNever();
+            }
+        };
+        const mcpServers = ( new Map(( mcpService.servers.get().map(s => [s.definition.id, { server: s, seen: false }]))));
+        const createBucket = (source, key) => {
+            if (source.type === 'mcp') {
+                const mcpServerEntry = mcpServers.get(source.definitionId);
+                if (!mcpServerEntry) {
+                    return undefined;
+                }
+                mcpServerEntry.seen = true;
+                const mcpServer = mcpServerEntry.server;
+                const buttons = [];
+                const collection = mcpRegistry.collections.get().find(c => c.id === mcpServer.collection.id);
+                if (collection?.source) {
+                    buttons.push({
+                        iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                        tooltip: ( localize(4745, "Configure {0}", collection.label)),
+                        action: () => collection.source ? collection.source instanceof ExtensionIdentifier ? extensionsWorkbenchService.open(collection.source.value, { tab: ExtensionEditorTab.Features, feature: 'mcp' }) : mcpWorkbenchService.open(collection.source, { tab: McpServerEditorTab.Configuration }) : undefined
+                    });
+                }
+                else if (collection?.presentation?.origin) {
+                    buttons.push({
+                        iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                        tooltip: ( localize(4745, "Configure {0}", collection.label)),
+                        action: () => editorService.openEditor({
+                            resource: collection.presentation.origin,
+                        })
+                    });
+                }
+                if (mcpServer.connectionState.get().state === McpConnectionState.Kind.Error) {
+                    buttons.push({
+                        iconClass: ThemeIcon.asClassName(Codicon.warning),
+                        tooltip: ( localize(4746, "Show Output")),
+                        action: () => mcpServer.showOutput(),
+                    });
+                }
+                const cacheState = mcpServer.cacheState.get();
+                const children = [];
+                let collapsed = true;
+                if (cacheState === McpServerCacheState.Unknown || cacheState === McpServerCacheState.Outdated) {
+                    collapsed = false;
+                    children.push({
+                        itemType: 'callback',
+                        iconClass: ThemeIcon.asClassName(Codicon.sync),
+                        label: ( localize(4747, "Update Tools")),
+                        pickable: false,
+                        run: () => {
+                            treePicker.busy = true;
+                            (async () => {
+                                const ok = await startServerAndWaitForLiveTools(mcpServer, { promptType: 'all-untrusted' });
+                                if (!ok) {
+                                    mcpServer.showOutput();
+                                    treePicker.hide();
+                                    return;
+                                }
+                                treePicker.busy = false;
+                                computeItems(collectResults());
+                            })();
+                            return false;
+                        },
+                    });
+                }
+                const bucket = {
+                    itemType: 'bucket',
+                    ordinal: BucketOrdinal.Mcp,
+                    id: key,
+                    label: ( localize(4748, "MCP Server: {0}", source.label)),
+                    checked: undefined,
+                    collapsed,
+                    children,
+                    buttons,
+                };
+                const iconURI = mcpServer.serverMetadata.get()?.icons.getUrl(22);
+                if (iconURI) {
+                    bucket.iconPath = { dark: iconURI, light: iconURI };
+                }
+                else {
+                    bucket.iconClass = ThemeIcon.asClassName(Codicon.mcp);
+                }
+                return bucket;
+            }
+            else if (source.type === 'extension') {
+                return {
+                    itemType: 'bucket',
+                    ordinal: BucketOrdinal.Extension,
+                    id: key,
+                    label: ( localize(4749, 'Extension: {0}', source.label)),
+                    checked: undefined,
+                    children: [],
+                    buttons: [],
+                    collapsed: true,
+                    iconClass: ThemeIcon.asClassName(Codicon.extensions)
+                };
+            }
+            else if (source.type === 'internal') {
+                return {
+                    itemType: 'bucket',
+                    ordinal: BucketOrdinal.BuiltIn,
+                    id: key,
+                    label: ( localize(4750, "Built-In")),
+                    checked: undefined,
+                    children: [],
+                    buttons: [],
+                    collapsed: false
+                };
+            }
+            else {
+                return {
+                    itemType: 'bucket',
+                    ordinal: BucketOrdinal.User,
+                    id: key,
+                    label: ( localize(4751, "User Defined Tool Sets")),
+                    checked: undefined,
+                    children: [],
+                    buttons: [],
+                    collapsed: true
+                };
+            }
+        };
+        const getBucket = (source) => {
+            const key = getKey(source);
+            let bucket = bucketMap.get(key);
+            if (!bucket) {
+                bucket = createBucket(source, key);
+                if (bucket) {
+                    bucketMap.set(key, bucket);
+                }
+            }
+            return bucket;
+        };
         for (const toolSet of toolsService.toolSets.get()) {
-            defaultEntries.set(toolSet, false);
-        }
-        toolsEntries = defaultEntries;
-    }
-    const treeItems = [];
-    const bucketMap = ( new Map());
-    const getKey = (source) => {
-        switch (source.type) {
-            case 'mcp':
-            case 'extension':
-                return ToolDataSource.toKey(source);
-            case 'internal':
-                return ( BucketOrdinal.BuiltIn.toString());
-            case 'user':
-                return ( BucketOrdinal.User.toString());
-            case 'external':
-                throw ( new Error('should not be reachable'));
-            default:
-                assertNever();
-        }
-    };
-    const createBucket = (source, key) => {
-        if (source.type === 'mcp') {
-            const { definitionId } = source;
-            const mcpServer = mcpService.servers.get().find(candidate => candidate.definition.id === definitionId);
-            if (!mcpServer) {
-                return undefined;
+            if (!( toolsEntries.has(toolSet))) {
+                continue;
             }
-            const buttons = [];
-            const collection = mcpRegistry.collections.get().find(c => c.id === mcpServer.collection.id);
-            if (collection?.source) {
-                buttons.push({
-                    iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
-                    tooltip: ( localize(4716, "Configure {0}", collection.label)),
-                    action: () => collection.source ? collection.source instanceof ExtensionIdentifier ? extensionsWorkbenchService.open(collection.source.value, { tab: ExtensionEditorTab.Features, feature: 'mcp' }) : mcpWorkbenchService.open(collection.source, { tab: McpServerEditorTab.Configuration }) : undefined
-                });
+            const bucket = getBucket(toolSet.source);
+            if (!bucket) {
+                continue;
             }
-            else if (collection?.presentation?.origin) {
-                buttons.push({
-                    iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
-                    tooltip: ( localize(4716, "Configure {0}", collection.label)),
-                    action: () => editorService.openEditor({
-                        resource: collection.presentation.origin,
-                    })
-                });
+            const toolSetChecked = toolsEntries.get(toolSet) === true;
+            if (toolSet.source.type === 'mcp') {
+                bucket.toolset = toolSet;
+                if (toolSetChecked) {
+                    bucket.checked = toolSetChecked;
+                }
             }
-            if (mcpServer.connectionState.get().state === McpConnectionState.Kind.Error) {
-                buttons.push({
-                    iconClass: ThemeIcon.asClassName(Codicon.warning),
-                    tooltip: ( localize(4717, "Show Output")),
-                    action: () => mcpServer.showOutput(),
-                });
+            else {
+                const treeItem = createToolSetTreeItem(toolSet, toolSetChecked, editorService);
+                bucket.children.push(treeItem);
+                const children = [];
+                for (const tool of toolSet.getTools()) {
+                    const toolChecked = toolSetChecked || toolsEntries.get(tool) === true;
+                    const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
+                    children.push(toolTreeItem);
+                }
+                if (children.length > 0) {
+                    treeItem.children = children;
+                }
             }
-            return {
-                itemType: 'bucket',
-                ordinal: BucketOrdinal.Mcp,
-                id: key,
-                label: ( localize(4718, "MCP Server: {0}", source.label)),
-                checked: undefined,
-                collapsed: true,
-                children: [],
-                buttons,
-                iconClass: ThemeIcon.asClassName(Codicon.mcp)
-            };
-        }
-        else if (source.type === 'extension') {
-            return {
-                itemType: 'bucket',
-                ordinal: BucketOrdinal.Extension,
-                id: key,
-                label: ( localize(4719, 'Extension: {0}', source.label)),
-                checked: undefined,
-                children: [],
-                buttons: [],
-                collapsed: true,
-                iconClass: ThemeIcon.asClassName(Codicon.extensions)
-            };
-        }
-        else if (source.type === 'internal') {
-            return {
-                itemType: 'bucket',
-                ordinal: BucketOrdinal.BuiltIn,
-                id: key,
-                label: ( localize(4720, "Built-In")),
-                checked: undefined,
-                children: [],
-                buttons: [],
-                collapsed: false
-            };
-        }
-        else {
-            return {
-                itemType: 'bucket',
-                ordinal: BucketOrdinal.User,
-                id: key,
-                label: ( localize(4721, "User Defined Tool Sets")),
-                checked: undefined,
-                children: [],
-                buttons: [],
-                collapsed: true
-            };
         }
-    };
-    const getBucket = (source) => {
-        const key = getKey(source);
-        let bucket = bucketMap.get(key);
-        if (!bucket) {
-            bucket = createBucket(source, key);
-            if (bucket) {
-                bucketMap.set(key, bucket);
+        for (const tool of toolsService.getTools()) {
+            if (!tool.canBeReferencedInPrompt || !( toolsEntries.has(tool))) {
+                continue;
             }
-        }
-        return bucket;
-    };
-    for (const toolSet of toolsService.toolSets.get()) {
-        if (!( toolsEntries.has(toolSet))) {
-            continue;
-        }
-        const bucket = getBucket(toolSet.source);
-        if (!bucket) {
-            continue;
-        }
-        const toolSetChecked = toolsEntries.get(toolSet) === true;
-        if (toolSet.source.type === 'mcp') {
-            bucket.toolset = toolSet;
-            if (toolSetChecked) {
-                bucket.checked = toolSetChecked;
+            const bucket = getBucket(tool.source);
+            if (!bucket) {
+                continue;
             }
+            const toolChecked = bucket.checked === true || toolsEntries.get(tool) === true;
+            const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
+            bucket.children.push(toolTreeItem);
         }
-        else {
-            const treeItem = createToolSetTreeItem(toolSet, toolSetChecked, editorService);
-            bucket.children.push(treeItem);
-            const children = [];
-            for (const tool of toolSet.getTools()) {
-                const toolChecked = toolSetChecked || toolsEntries.get(tool) === true;
-                const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
-                children.push(toolTreeItem);
-            }
-            if (children.length > 0) {
-                treeItem.children = children;
+        for (const { server, seen } of ( mcpServers.values())) {
+            const cacheState = server.cacheState.get();
+            if (!seen && (cacheState === McpServerCacheState.Unknown || cacheState === McpServerCacheState.Outdated)) {
+                getBucket({ type: 'mcp', definitionId: server.definition.id, label: server.definition.label, instructions: '', serverLabel: '', collectionId: server.collection.id });
             }
         }
-    }
-    for (const tool of toolsService.getTools()) {
-        if (!tool.canBeReferencedInPrompt || !( toolsEntries.has(tool))) {
-            continue;
+        const sortedBuckets = Array.from(( bucketMap.values())).sort((a, b) => a.ordinal - b.ordinal);
+        treeItems.push(...sortedBuckets);
+        if (treeItems.length === 0) {
+            treePicker.placeholder = ( localize(4752, "Add tools to chat"));
         }
-        const bucket = getBucket(tool.source);
-        if (!bucket) {
-            continue;
+        else {
+            treePicker.placeholder = placeHolder;
         }
-        const toolChecked = bucket.checked === true || toolsEntries.get(tool) === true;
-        const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
-        bucket.children.push(toolTreeItem);
+        treePicker.setItemTree(treeItems);
     }
-    const sortedBuckets = Array.from(( bucketMap.values())).sort((a, b) => a.ordinal - b.ordinal);
-    treeItems.push(...sortedBuckets);
     const store = ( new DisposableStore());
     const treePicker = store.add(quickPickService.createQuickTree());
     treePicker.placeholder = placeHolder;
@@ -281,10 +336,7 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries)
     treePicker.description = description;
     treePicker.matchOnDescription = true;
     treePicker.matchOnLabel = true;
-    if (treeItems.length === 0) {
-        treePicker.placeholder = ( localize(4722, "Add tools to chat"));
-    }
-    treePicker.setItemTree(treeItems);
+    computeItems();
     store.add(treePicker.onDidTriggerItemButton(e => {
         if (e.button && typeof e.button.action === 'function') {
             e.button.action();
@@ -306,11 +358,11 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries)
                     }
                 }
             };
-            traverse(treeItems);
+            traverse(treePicker.itemTree);
             if (count > toolLimit) {
                 treePicker.severity = Severity.Warning;
                 treePicker.validationMessage = ( localize(
-                    4723,
+                    4753,
                     "{0} tools are enabled. You may experience degraded tool calling above {1} tools.",
                     count,
                     markdownCommandLink({ title: String(toolLimit), id: '_chat.toolPicker.closeAndOpenVirtualThreshold' })
@@ -341,11 +393,11 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries)
                     }
                 }
                 else if (isToolTreeItem(item)) {
-                    result.set(item.tool, item.checked);
+                    result.set(item.tool, item.checked || result.get(item.tool) === true);
                 }
             }
         };
-        traverse(treeItems);
+        traverse(treePicker.itemTree);
         return result;
     };
     store.add(CommandsRegistry.registerCommand({
@@ -357,29 +409,33 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries)
     }));
     store.add(treePicker.onDidChangeCheckedLeafItems(() => updateToolLimitMessage()));
     let didAccept = false;
+    const didAcceptFinalItem = store.add(( new Emitter()));
     store.add(treePicker.onDidAccept(() => {
         const activeItems = treePicker.activeItems;
         const callbackItem = activeItems.find(isCallbackTreeItem);
-        if (callbackItem) {
-            callbackItem.run();
-        }
-        else {
+        if (!callbackItem) {
             didAccept = true;
+            treePicker.hide();
+            return;
+        }
+        const ret = callbackItem.run();
+        if (ret !== false) {
+            didAcceptFinalItem.fire();
         }
     }));
     const addMcpServerButton = {
         iconClass: ThemeIcon.asClassName(Codicon.mcp),
-        tooltip: ( localize(4724, 'Add MCP Server...'))
+        tooltip: ( localize(4754, 'Add MCP Server...'))
     };
     const installExtension = {
         iconClass: ThemeIcon.asClassName(Codicon.extensions),
-        tooltip: ( localize(4725, 'Install Extension...'))
+        tooltip: ( localize(4755, 'Install Extension...'))
     };
     const configureToolSets = {
         iconClass: ThemeIcon.asClassName(Codicon.gear),
-        tooltip: ( localize(4726, 'Configure Tool Sets...'))
+        tooltip: ( localize(4756, 'Configure Tool Sets...'))
     };
-    treePicker.title = ( localize(4727, "Configure Tools"));
+    treePicker.title = ( localize(4757, "Configure Tools"));
     treePicker.buttons = [addMcpServerButton, installExtension, configureToolSets];
     store.add(treePicker.onDidTriggerButton(button => {
         if (button === addMcpServerButton) {
@@ -394,7 +450,7 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries)
         treePicker.hide();
     }));
     treePicker.show();
-    await Promise.race([Event.toPromise(Event.any(treePicker.onDidAccept, treePicker.onDidHide), store)]);
+    await Promise.race([Event.toPromise(Event.any(treePicker.onDidHide, didAcceptFinalItem.event), store)]);
     store.dispose();
     return didAccept ? collectResults() : undefined;
 }