@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

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

@@ -8,17 +8,26 @@ import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/th
 import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 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 { 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.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 { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
-import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { McpServerEditorTab, McpConnectionState } 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 { 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';
 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 { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+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) {
@@ -42,13 +51,372 @@ function isCallbackPick(obj) {
 function isActionableButton(obj) {
     return typeof obj.action === 'function';
 }
+function isBucketTreeItem(item) {
+    return item.itemType === 'bucket';
+}
+function isToolSetTreeItem(item) {
+    return item.itemType === 'toolset';
+}
+function isToolTreeItem(item) {
+    return item.itemType === 'tool';
+}
+function isCallbackTreeItem(item) {
+    return item.itemType === 'callback';
+}
+function mapIconToTreeItem(icon, useDefaultToolIcon = false) {
+    if (!icon) {
+        if (useDefaultToolIcon) {
+            return { iconClass: ThemeIcon.asClassName(Codicon.tools) };
+        }
+        return {};
+    }
+    if (ThemeIcon.isThemeIcon(icon)) {
+        return { iconClass: ThemeIcon.asClassName(icon) };
+    }
+    else {
+        return { iconPath: icon };
+    }
+}
+function createToolTreeItemFromData(tool, checked) {
+    const iconProps = mapIconToTreeItem(tool.icon, true);
+    return {
+        itemType: 'tool',
+        tool,
+        id: tool.id,
+        label: tool.toolReferenceName ?? tool.displayName,
+        description: tool.userDescription ?? tool.modelDescription,
+        checked,
+        ...iconProps
+    };
+}
+async function showToolsPickerTree(accessor, placeHolder, description, toolsEntries, onUpdate) {
+    const quickPickService = accessor.get(IQuickInputService);
+    const mcpService = accessor.get(IMcpService);
+    const mcpRegistry = accessor.get(IMcpRegistry);
+    const commandService = accessor.get(ICommandService);
+    const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+    const editorService = accessor.get(IEditorService);
+    const mcpWorkbenchService = accessor.get(IMcpWorkbenchService);
+    const toolsService = accessor.get(ILanguageModelToolsService);
+    const toolLimit = accessor.get(IContextKeyService).getContextKeyValue(ChatContextKeys.chatToolGroupingThreshold.key);
+    const mcpServerByTool = ( new Map());
+    for (const server of mcpService.servers.get()) {
+        for (const tool of server.tools.get()) {
+            mcpServerByTool.set(tool.id, server);
+        }
+    }
+    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;
+    }
+    const treeItems = [];
+    const bucketMap = ( new Map());
+    for (const [toolSetOrTool, picked] of toolsEntries) {
+        let bucketItem;
+        const buttons = [];
+        if (toolSetOrTool.source.type === 'mcp') {
+            const key = ToolDataSource.toKey(toolSetOrTool.source);
+            const { definitionId } = toolSetOrTool.source;
+            const mcpServer = mcpService.servers.get().find(candidate => candidate.definition.id === definitionId);
+            if (!mcpServer) {
+                continue;
+            }
+            bucketItem = bucketMap.get(key);
+            if (!bucketItem) {
+                const collection = mcpRegistry.collections.get().find(c => c.id === mcpServer.collection.id);
+                if (collection?.source) {
+                    buttons.push({
+                        iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                        tooltip: ( localize(4662, "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(4662, "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(4663, "Show Output")),
+                        action: () => mcpServer.showOutput(),
+                    });
+                }
+                bucketItem = {
+                    itemType: 'bucket',
+                    ordinal: BucketOrdinal.Mcp,
+                    id: key,
+                    label: ( localize(4664, "MCP Server: {0}", toolSetOrTool.source.label)),
+                    checked: false,
+                    collapsed: true,
+                    children: [],
+                    buttons,
+                    alwaysShow: true,
+                    iconClass: ThemeIcon.asClassName(Codicon.mcp)
+                };
+                bucketMap.set(key, bucketItem);
+            }
+            if (toolSetOrTool instanceof ToolSet) {
+                bucketItem.toolset = toolSetOrTool;
+                bucketItem.checked = picked;
+            }
+            else if (toolSetOrTool.canBeReferencedInPrompt) {
+                const toolTreeItem = createToolTreeItemFromData(toolSetOrTool, picked);
+                bucketItem.children = [...(bucketItem.children || []), toolTreeItem];
+            }
+        }
+        else {
+            let ordinal;
+            let label;
+            let key;
+            let collapsed;
+            if (toolSetOrTool.source.type === 'extension') {
+                ordinal = BucketOrdinal.Extension;
+                label = ( localize(4665, 'Extension: {0}', toolSetOrTool.source.label));
+                key = ToolDataSource.toKey(toolSetOrTool.source);
+                collapsed = true;
+            }
+            else if (toolSetOrTool.source.type === 'internal') {
+                ordinal = BucketOrdinal.BuiltIn;
+                label = ( localize(4666, "Built-In"));
+                key = ( ordinal.toString());
+            }
+            else if (toolSetOrTool.source.type === 'user') {
+                ordinal = BucketOrdinal.User;
+                label = ( localize(4667, "User Defined Tool Sets"));
+                key = ( ordinal.toString());
+                buttons.push({
+                    iconClass: ThemeIcon.asClassName(Codicon.edit),
+                    tooltip: ( localize(4668, "Edit Tool Set")),
+                    action: () => {
+                        assertType(toolSetOrTool.source.type === 'user');
+                        editorService.openEditor({ resource: toolSetOrTool.source.file });
+                    }
+                });
+            }
+            else {
+                assertNever();
+            }
+            bucketItem = bucketMap.get(key);
+            if (!bucketItem) {
+                const iconProps = toolSetOrTool.source.type === 'extension'
+                    ? { iconClass: ThemeIcon.asClassName(Codicon.extensions) }
+                    : {};
+                bucketItem = {
+                    itemType: 'bucket',
+                    ordinal,
+                    id: key,
+                    label,
+                    checked: false,
+                    children: [],
+                    buttons,
+                    collapsed,
+                    alwaysShow: true,
+                    ...iconProps
+                };
+                bucketMap.set(key, bucketItem);
+            }
+            if (toolSetOrTool instanceof ToolSet) {
+                const iconProps = mapIconToTreeItem(toolSetOrTool.icon);
+                const toolSetTreeItem = {
+                    itemType: 'toolset',
+                    toolset: toolSetOrTool,
+                    buttons,
+                    id: toolSetOrTool.id,
+                    label: toolSetOrTool.referenceName,
+                    description: toolSetOrTool.description,
+                    checked: picked,
+                    collapsed: true,
+                    ...iconProps
+                };
+                bucketItem.children = [...(bucketItem.children || []), toolSetTreeItem];
+            }
+            else if (toolSetOrTool.canBeReferencedInPrompt) {
+                const toolTreeItem = createToolTreeItemFromData(toolSetOrTool, picked);
+                bucketItem.children = [...(bucketItem.children || []), toolTreeItem];
+            }
+        }
+    }
+    const sortedBuckets = Array.from(( bucketMap.values())).sort((a, b) => a.ordinal - b.ordinal);
+    treeItems.push(...sortedBuckets);
+    for (const bucketItem of treeItems.filter(isBucketTreeItem)) {
+        if (bucketItem.checked) {
+            bucketItem.children?.forEach(child => {
+                child.checked = true;
+            });
+        }
+        else {
+            bucketItem.checked = bucketItem.children?.some(child => child.checked) || false;
+        }
+    }
+    const store = ( new DisposableStore());
+    const treePicker = store.add(quickPickService.createQuickTree());
+    treePicker.placeholder = placeHolder;
+    treePicker.ignoreFocusOut = true;
+    treePicker.description = description;
+    treePicker.matchOnDescription = true;
+    treePicker.matchOnLabel = true;
+    if (treeItems.length === 0) {
+        treePicker.placeholder = ( localize(4669, "Add tools to chat"));
+    }
+    treePicker.setItemTree(treeItems);
+    store.add(treePicker.onDidTriggerItemButton(e => {
+        if (e.button && typeof e.button.action === 'function') {
+            e.button.action();
+            store.dispose();
+        }
+    }));
+    const result = ( new Map());
+    const collectResults = () => {
+        result.clear();
+        let count = 0;
+        const traverse = (items) => {
+            for (const item of items) {
+                if (isBucketTreeItem(item)) {
+                    if (item.toolset) {
+                        const checked = typeof item.checked === 'boolean' ? item.checked : false;
+                        result.set(item.toolset, checked);
+                    }
+                    if (item.children) {
+                        traverse(item.children);
+                    }
+                }
+                else if (isToolSetTreeItem(item)) {
+                    const checked = typeof item.checked === 'boolean' ? item.checked : false;
+                    result.set(item.toolset, checked);
+                    if (item.children) {
+                        traverse(item.children);
+                    }
+                }
+                else if (isToolTreeItem(item)) {
+                    const checked = typeof item.checked === 'boolean' ? item.checked : false;
+                    if (checked) {
+                        count++;
+                    }
+                    result.set(item.tool, checked);
+                }
+            }
+        };
+        traverse(treeItems);
+        if (toolLimit) {
+            if (count > toolLimit) {
+                treePicker.severity = Severity.Warning;
+                treePicker.validationMessage = ( localize(
+                    4670,
+                    "{0} tools are enabled. You may experience degraded tool calling above {1} tools.",
+                    count,
+                    markdownCommandLink({ title: String(toolLimit), id: '_chat.toolPicker.closeAndOpenVirtualThreshold' })
+                ));
+            }
+            else {
+                treePicker.severity = Severity.Ignore;
+                treePicker.validationMessage = undefined;
+            }
+        }
+        for (const item of toolsService.toolSets.get()) {
+            if (item.source.type === 'mcp') {
+                const toolsInSet = Array.from(item.getTools());
+                result.set(item, toolsInSet.every(tool => result.get(tool)));
+            }
+        }
+    };
+    collectResults();
+    store.add(CommandsRegistry.registerCommand({
+        id: '_chat.toolPicker.closeAndOpenVirtualThreshold',
+        handler: () => {
+            treePicker.hide();
+            commandService.executeCommand('workbench.action.openSettings', 'github.copilot.chat.virtualTools.threshold');
+        }
+    }));
+    store.add(treePicker.onDidChangeCheckedLeafItems(() => {
+        collectResults();
+        if (onUpdate) {
+            let didChange = toolsEntries.size !== result.size;
+            for (const [key, value] of toolsEntries) {
+                if (didChange) {
+                    break;
+                }
+                didChange = result.get(key) !== value;
+            }
+            if (didChange) {
+                onUpdate(result);
+            }
+        }
+    }));
+    let didAccept = false;
+    store.add(treePicker.onDidAccept(() => {
+        const activeItems = treePicker.activeItems;
+        const callbackItem = activeItems.find(isCallbackTreeItem);
+        if (callbackItem) {
+            callbackItem.run();
+        }
+        else {
+            didAccept = true;
+        }
+    }));
+    const addMcpServerButton = {
+        iconClass: ThemeIcon.asClassName(Codicon.mcp),
+        tooltip: ( localize(4671, 'Add MCP Server...'))
+    };
+    const installExtension = {
+        iconClass: ThemeIcon.asClassName(Codicon.extensions),
+        tooltip: ( localize(4672, 'Install Extension...'))
+    };
+    const configureToolSets = {
+        iconClass: ThemeIcon.asClassName(Codicon.gear),
+        tooltip: ( localize(4673, 'Configure Tool Sets...'))
+    };
+    treePicker.title = ( localize(4674, "Configure Tools"));
+    treePicker.buttons = [addMcpServerButton, installExtension, configureToolSets];
+    store.add(treePicker.onDidTriggerButton(button => {
+        if (button === addMcpServerButton) {
+            commandService.executeCommand(McpCommandIds.AddConfiguration);
+        }
+        else if (button === installExtension) {
+            extensionsWorkbenchService.openSearch('@tag:language-model-tools');
+        }
+        else if (button === configureToolSets) {
+            commandService.executeCommand(ConfigureToolSets.ID);
+        }
+        treePicker.hide();
+    }));
+    treePicker.show();
+    await Promise.race([Event.toPromise(Event.any(treePicker.onDidAccept, treePicker.onDidHide), store)]);
+    store.dispose();
+    collectResults();
+    return didAccept ? result : undefined;
+}
 async function showToolsPicker(accessor, placeHolder, description, toolsEntries, onUpdate) {
+    const configurationService = accessor.get(IConfigurationService);
+    const useTreePicker = configurationService.getValue('chat.tools.useTreePicker');
+    if (useTreePicker) {
+        return showToolsPickerTree(accessor, placeHolder, description, toolsEntries, onUpdate);
+    }
+    else {
+        return showToolsPickerLegacy(accessor, placeHolder, description, toolsEntries, onUpdate);
+    }
+}
+async function showToolsPickerLegacy(accessor, placeHolder, description, toolsEntries, onUpdate) {
     const quickPickService = accessor.get(IQuickInputService);
     const mcpService = accessor.get(IMcpService);
     const mcpRegistry = accessor.get(IMcpRegistry);
     const commandService = accessor.get(ICommandService);
-    const extensionWorkbenchService = accessor.get(IExtensionsWorkbenchService);
+    const extensionsWorkbenchService = accessor.get(IExtensionsWorkbenchService);
     const editorService = accessor.get(IEditorService);
+    const mcpWorkbenchService = accessor.get(IMcpWorkbenchService);
     const toolsService = accessor.get(ILanguageModelToolsService);
     const mcpServerByTool = ( new Map());
     for (const server of mcpService.servers.get()) {
@@ -59,26 +427,27 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
     const builtinBucket = {
         type: 'item',
         children: [],
-        label: ( localize(4612, "Built-In")),
+        label: ( localize(4666, "Built-In")),
         ordinal: BucketOrdinal.BuiltIn,
         picked: false,
     };
     const userBucket = {
         type: 'item',
         children: [],
-        label: ( localize(4613, "User Defined Tool Sets")),
+        label: ( localize(4667, "User Defined Tool Sets")),
         ordinal: BucketOrdinal.User,
         alwaysShow: true,
         picked: false,
     };
-    const addMcpPick = { type: 'item', label: ( localize(4614, "Add MCP Server...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: () => commandService.executeCommand(McpCommandIds.AddConfiguration) };
-    const configureToolSetsPick = { type: 'item', label: ( localize(4615, "Configure Tool Sets...")), iconClass: ThemeIcon.asClassName(Codicon.gear), pickable: false, run: () => commandService.executeCommand(ConfigureToolSets.ID) };
-    const addExpPick = { type: 'item', label: ( localize(4616, "Install Extension...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: () => extensionWorkbenchService.openSearch('@tag:language-model-tools') };
+    const toolLimit = accessor.get(IContextKeyService).getContextKeyValue(ChatContextKeys.chatToolGroupingThreshold.key);
+    const addMcpPick = { type: 'item', label: ( localize(4675, "Add MCP Server...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: () => commandService.executeCommand(McpCommandIds.AddConfiguration) };
+    const configureToolSetsPick = { type: 'item', label: ( localize(4676, "Configure Tool Sets...")), iconClass: ThemeIcon.asClassName(Codicon.gear), pickable: false, run: () => commandService.executeCommand(ConfigureToolSets.ID) };
+    const addExpPick = { type: 'item', label: ( localize(4677, "Install Extension...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: () => extensionsWorkbenchService.openSearch('@tag:language-model-tools') };
     const addPick = {
-        type: 'item', label: ( localize(4617, "Add More Tools...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: async () => {
+        type: 'item', label: ( localize(4678, "Add More Tools...")), iconClass: ThemeIcon.asClassName(Codicon.add), pickable: false, run: async () => {
             const pick = await quickPickService.pick([addMcpPick, addExpPick], {
                 canPickMany: false,
-                placeHolder: ( localize(4618, "Add tools to chat"))
+                placeHolder: ( localize(4669, "Add tools to chat"))
             });
             pick?.run();
         }
@@ -109,7 +478,7 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
             const buttons = [];
             bucket = toolBuckets.get(key) ?? {
                 type: 'item',
-                label: ( localize(4619, "MCP Server: {0}", toolSetOrTool.source.label)),
+                label: ( localize(4664, "MCP Server: {0}", toolSetOrTool.source.label)),
                 ordinal: BucketOrdinal.Mcp,
                 picked: false,
                 alwaysShow: true,
@@ -118,10 +487,17 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
             };
             toolBuckets.set(key, bucket);
             const collection = mcpRegistry.collections.get().find(c => c.id === mcpServer.collection.id);
-            if (collection?.presentation?.origin) {
+            if (collection?.source) {
+                buttons.push({
+                    iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
+                    tooltip: ( localize(4662, "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(4620, "Configure {0}", collection.label)),
+                    tooltip: ( localize(4662, "Configure {0}", collection.label)),
                     action: () => editorService.openEditor({
                         resource: collection.presentation.origin,
                     })
@@ -130,7 +506,7 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
             if (mcpServer.connectionState.get().state === McpConnectionState.Kind.Error) {
                 buttons.push({
                     iconClass: ThemeIcon.asClassName(Codicon.warning),
-                    tooltip: ( localize(4621, "Show Output")),
+                    tooltip: ( localize(4663, "Show Output")),
                     action: () => mcpServer.showOutput(),
                 });
             }
@@ -139,7 +515,7 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
             const key = ToolDataSource.toKey(toolSetOrTool.source);
             bucket = toolBuckets.get(key) ?? {
                 type: 'item',
-                label: ( localize(4622, 'Extension: {0}', toolSetOrTool.source.label)),
+                label: ( localize(4665, 'Extension: {0}', toolSetOrTool.source.label)),
                 ordinal: BucketOrdinal.Extension,
                 picked: false,
                 alwaysShow: true,
@@ -154,7 +530,7 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
             bucket = userBucket;
             buttons.push({
                 iconClass: ThemeIcon.asClassName(Codicon.edit),
-                tooltip: ( localize(4623, "Edit Tool Set")),
+                tooltip: ( localize(4668, "Edit Tool Set")),
                 action: () => {
                     assertType(toolSetOrTool.source.type === 'user');
                     editorService.openEditor({ resource: toolSetOrTool.source.file });
@@ -221,13 +597,14 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
     }
     const picker = store.add(quickPickService.createQuickPick({ useSeparators: true }));
     picker.placeholder = placeHolder;
+    picker.ignoreFocusOut = true;
     picker.description = description;
     picker.canSelectMany = true;
     picker.keepScrollPosition = true;
     picker.sortByLabel = false;
     picker.matchOnDescription = true;
     if (picks.length === 0) {
-        picker.placeholder = ( localize(4618, "Add tools to chat"));
+        picker.placeholder = ( localize(4669, "Add tools to chat"));
         picker.canSelectMany = false;
         picks.push(addMcpPick, addExpPick);
     }
@@ -243,6 +620,7 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
             const items = picks.filter((p) => p.type === 'item' && Boolean(p.picked));
             lastSelectedItems = ( new Set(items));
             picker.selectedItems = items;
+            let count = 0;
             result.clear();
             for (const item of picks) {
                 if (item.type !== 'item') {
@@ -250,9 +628,11 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
                 }
                 if (isToolSetPick(item)) {
                     result.set(item.toolset, item.picked);
+                    count += Iterable.length(item.toolset.getTools());
                 }
                 else if (isToolPick(item)) {
                     result.set(item.tool, item.picked);
+                    count++;
                 }
                 else if (isBucketPick(item)) {
                     if (item.toolset) {
@@ -261,13 +641,30 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
                     for (const child of item.children) {
                         if (isToolSetPick(child)) {
                             result.set(child.toolset, item.picked);
+                            count += Iterable.length(child.toolset.getTools());
                         }
                         else if (isToolPick(child)) {
                             result.set(child.tool, item.picked);
+                            count++;
                         }
                     }
                 }
             }
+            if (toolLimit) {
+                if (count > toolLimit) {
+                    picker.severity = Severity.Warning;
+                    picker.validationMessage = ( localize(
+                        4670,
+                        "{0} tools are enabled. You may experience degraded tool calling above {1} tools.",
+                        count,
+                        toolLimit
+                    ));
+                }
+                else {
+                    picker.severity = Severity.Ignore;
+                    picker.validationMessage = undefined;
+                }
+            }
             if (onUpdate) {
                 let didChange = toolsEntries.size !== result.size;
                 for (const [key, value] of toolsEntries) {
@@ -300,8 +697,6 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
         }
         const addPick = selectedPicks.find(isCallbackPick);
         if (addPick) {
-            addPick.run();
-            picker.hide();
             return;
         }
         const { added, removed } = diffSets(lastSelectedItems, ( new Set(selectedPicks)));
@@ -331,8 +726,13 @@ async function showToolsPicker(accessor, placeHolder, description, toolsEntries,
     }));
     let didAccept = false;
     store.add(picker.onDidAccept(() => {
-        picker.activeItems.find(isCallbackPick)?.run();
-        didAccept = true;
+        const callbackPick = picker.activeItems.find(isCallbackPick);
+        if (callbackPick) {
+            callbackPick.run();
+        }
+        else {
+            didAccept = true;
+        }
     }));
     await Promise.race([Event.toPromise(Event.any(picker.onDidAccept, picker.onDidHide))]);
     store.dispose();

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

@@ -9,7 +9,7 @@ import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
 import { ICodeMapperService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatCodeMapperService.service";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
-import { ICodeBlockActionContext } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/codeBlockPart";
+import { ICodeBlockActionContext } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/browser/codeBlockPart";
 import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";