@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -2,16 +2,13 @@
 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 { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { createMarkdownCommandLink } 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 { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.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';
@@ -20,48 +17,52 @@ import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 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-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
 import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { ConfigureToolSets } from '../tools/toolSetsContribution.js';
 
 var BucketOrdinal;
-(function (BucketOrdinal) {
+(function(BucketOrdinal) {
     BucketOrdinal[BucketOrdinal["User"] = 0] = "User";
     BucketOrdinal[BucketOrdinal["BuiltIn"] = 1] = "BuiltIn";
     BucketOrdinal[BucketOrdinal["Mcp"] = 2] = "Mcp";
     BucketOrdinal[BucketOrdinal["Extension"] = 3] = "Extension";
 })(BucketOrdinal || (BucketOrdinal = {}));
 function isBucketTreeItem(item) {
-    return item.itemType === 'bucket';
+    return item.itemType === "bucket";
 }
 function isToolSetTreeItem(item) {
-    return item.itemType === 'toolset';
+    return item.itemType === "toolset";
 }
 function isToolTreeItem(item) {
-    return item.itemType === 'tool';
+    return item.itemType === "tool";
 }
 function isCallbackTreeItem(item) {
-    return item.itemType === 'callback';
+    return item.itemType === "callback";
 }
 function mapIconToTreeItem(icon, useDefaultToolIcon = false) {
     if (!icon) {
         if (useDefaultToolIcon) {
-            return { iconClass: ThemeIcon.asClassName(Codicon.tools) };
+            return {
+                iconClass: ThemeIcon.asClassName(Codicon.tools)
+            };
         }
         return {};
     }
     if (ThemeIcon.isThemeIcon(icon)) {
-        return { iconClass: ThemeIcon.asClassName(icon) };
-    }
-    else {
-        return { iconPath: icon };
+        return {
+            iconClass: ThemeIcon.asClassName(icon)
+        };
+    } else {
+        return {
+            iconPath: icon
+        };
     }
 }
 function createToolTreeItemFromData(tool, checked) {
     const iconProps = mapIconToTreeItem(tool.icon, true);
     return {
-        itemType: 'tool',
+        itemType: "tool",
         tool,
         id: tool.id,
         label: tool.toolReferenceName ?? tool.displayName,
@@ -73,16 +74,18 @@ function createToolTreeItemFromData(tool, checked) {
 function createToolSetTreeItem(toolset, checked, editorService) {
     const iconProps = mapIconToTreeItem(toolset.icon);
     const buttons = [];
-    if (toolset.source.type === 'user') {
+    if (toolset.source.type === "user") {
         const resource = toolset.source.file;
         buttons.push({
             iconClass: ThemeIcon.asClassName(Codicon.edit),
-            tooltip: ( localize(4819, "Edit Tool Set")),
-            action: () => editorService.openEditor({ resource })
+            tooltip: ( localize(4862, "Edit Tool Set")),
+            action: () => editorService.openEditor({
+                resource
+            })
         });
     }
     return {
-        itemType: 'toolset',
+        itemType: "toolset",
         toolset,
         buttons,
         id: toolset.id,
@@ -94,7 +97,7 @@ function createToolSetTreeItem(toolset, checked, editorService) {
         ...iconProps
     };
 }
-async function showToolsPicker(accessor, placeHolder, description, getToolsEntries, token) {
+async function showToolsPicker(accessor, placeHolder, source, description, getToolsEntries, model, token) {
     const quickPickService = accessor.get(IQuickInputService);
     const mcpService = accessor.get(IMcpService);
     const mcpRegistry = accessor.get(IMcpRegistry);
@@ -103,7 +106,7 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
     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 telemetryService = accessor.get(ITelemetryService);
     const mcpServerByTool = ( new Map());
     for (const server of mcpService.servers.get()) {
         for (const tool of server.tools.get()) {
@@ -111,42 +114,45 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
         }
     }
     function computeItems(previousToolsEntries) {
-        let toolsEntries = getToolsEntries ? ( new Map(getToolsEntries())) : undefined;
+        let toolsEntries = getToolsEntries ? ( new Map(( [...getToolsEntries()].map(([k, enabled]) => [k.id, enabled])))) : undefined;
         if (!toolsEntries) {
             const defaultEntries = ( new Map());
-            for (const tool of toolsService.getTools()) {
+            for (const tool of toolsService.getTools(model)) {
                 if (tool.canBeReferencedInPrompt) {
                     defaultEntries.set(tool, false);
                 }
             }
-            for (const toolSet of toolsService.toolSets.get()) {
+            for (const toolSet of toolsService.getToolSetsForModel(model)) {
                 defaultEntries.set(toolSet, false);
             }
             toolsEntries = defaultEntries;
         }
         previousToolsEntries?.forEach((value, key) => {
-            toolsEntries.set(key, value);
+            toolsEntries.set(key.id, value);
         });
         const treeItems = [];
         const bucketMap = ( new Map());
-        const getKey = (source) => {
+        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();
+            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 mcpServers = ( new Map(( mcpService.servers.get().map(s => [s.definition.id, {
+            server: s,
+            seen: false
+        }]))));
         const createBucket = (source, key) => {
-            if (source.type === 'mcp') {
+            if (source.type === "mcp") {
                 const mcpServerEntry = mcpServers.get(source.definitionId);
                 if (!mcpServerEntry) {
                     return undefined;
@@ -158,24 +164,28 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
                 if (collection?.source) {
                     buttons.push({
                         iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
-                        tooltip: ( localize(4820, "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
+                        tooltip: ( localize(4863, "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) {
+                } else if (collection?.presentation?.origin) {
                     buttons.push({
                         iconClass: ThemeIcon.asClassName(Codicon.settingsGear),
-                        tooltip: ( localize(4820, "Configure {0}", collection.label)),
+                        tooltip: ( localize(4863, "Configure {0}", collection.label)),
                         action: () => editorService.openEditor({
-                            resource: collection.presentation.origin,
+                            resource: collection.presentation.origin
                         })
                     });
                 }
                 if (mcpServer.connectionState.get().state === McpConnectionState.Kind.Error) {
                     buttons.push({
                         iconClass: ThemeIcon.asClassName(Codicon.warning),
-                        tooltip: ( localize(4821, "Show Output")),
-                        action: () => mcpServer.showOutput(),
+                        tooltip: ( localize(4864, "Show Output")),
+                        action: () => mcpServer.showOutput()
                     });
                 }
                 const cacheState = mcpServer.cacheState.get();
@@ -184,14 +194,16 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
                 if (cacheState === McpServerCacheState.Unknown || cacheState === McpServerCacheState.Outdated) {
                     collapsed = false;
                     children.push({
-                        itemType: 'callback',
+                        itemType: "callback",
                         iconClass: ThemeIcon.asClassName(Codicon.sync),
-                        label: ( localize(4822, "Update Tools")),
+                        label: ( localize(4865, "Update Tools")),
                         pickable: false,
                         run: () => {
                             treePicker.busy = true;
                             (async () => {
-                                const ok = await startServerAndWaitForLiveTools(mcpServer, { promptType: 'all-untrusted' });
+                                const ok = await startServerAndWaitForLiveTools(mcpServer, {
+                                    promptType: "all-untrusted"
+                                });
                                 if (!ok) {
                                     mcpServer.showOutput();
                                     treePicker.hide();
@@ -201,11 +213,11 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
                                 computeItems(collectResults());
                             })();
                             return false;
-                        },
+                        }
                     });
                 }
                 const bucket = {
-                    itemType: 'bucket',
+                    itemType: "bucket",
                     ordinal: BucketOrdinal.Mcp,
                     id: key,
                     label: source.label,
@@ -213,20 +225,18 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
                     collapsed,
                     children,
                     buttons,
-                    sortOrder: 2,
+                    sortOrder: 2
                 };
                 const iconPath = mcpServer.serverMetadata.get()?.icons.getUrl(22);
                 if (iconPath) {
                     bucket.iconPath = iconPath;
-                }
-                else {
+                } else {
                     bucket.iconClass = ThemeIcon.asClassName(Codicon.mcp);
                 }
                 return bucket;
-            }
-            else if (source.type === 'extension') {
+            } else if (source.type === "extension") {
                 return {
-                    itemType: 'bucket',
+                    itemType: "bucket",
                     ordinal: BucketOrdinal.Extension,
                     id: key,
                     label: source.label,
@@ -235,37 +245,35 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
                     buttons: [],
                     collapsed: true,
                     iconClass: ThemeIcon.asClassName(Codicon.extensions),
-                    sortOrder: 3,
+                    sortOrder: 3
                 };
-            }
-            else if (source.type === 'internal') {
+            } else if (source.type === "internal") {
                 return {
-                    itemType: 'bucket',
+                    itemType: "bucket",
                     ordinal: BucketOrdinal.BuiltIn,
                     id: key,
-                    label: ( localize(4823, "Built-In")),
+                    label: ( localize(4866, "Built-In")),
                     checked: undefined,
                     children: [],
                     buttons: [],
                     collapsed: false,
-                    sortOrder: 1,
+                    sortOrder: 1
                 };
-            }
-            else {
+            } else {
                 return {
-                    itemType: 'bucket',
+                    itemType: "bucket",
                     ordinal: BucketOrdinal.User,
                     id: key,
-                    label: ( localize(4824, "User Defined Tool Sets")),
+                    label: ( localize(4867, "User Defined Tool Sets")),
                     checked: undefined,
                     children: [],
                     buttons: [],
                     collapsed: true,
-                    sortOrder: 4,
+                    sortOrder: 4
                 };
             }
         };
-        const getBucket = (source) => {
+        const getBucket = source => {
             const key = getKey(source);
             let bucket = bucketMap.get(key);
             if (!bucket) {
@@ -276,27 +284,26 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
             }
             return bucket;
         };
-        for (const toolSet of toolsService.toolSets.get()) {
-            if (!( toolsEntries.has(toolSet))) {
+        for (const toolSet of toolsService.getToolSetsForModel(model)) {
+            if (!( toolsEntries.has(toolSet.id))) {
                 continue;
             }
             const bucket = getBucket(toolSet.source);
             if (!bucket) {
                 continue;
             }
-            const toolSetChecked = toolsEntries.get(toolSet) === true;
-            if (toolSet.source.type === 'mcp') {
+            const toolSetChecked = toolsEntries.get(toolSet.id) === true;
+            if (toolSet.source.type === "mcp") {
                 bucket.toolset = toolSet;
                 if (toolSetChecked) {
                     bucket.checked = toolSetChecked;
                 }
-            }
-            else {
+            } 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 toolChecked = toolSetChecked || toolsEntries.get(tool.id) === true;
                     const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
                     children.push(toolTreeItem);
                 }
@@ -305,22 +312,32 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
                 }
             }
         }
-        for (const tool of toolsService.getTools()) {
-            if (!tool.canBeReferencedInPrompt || !( toolsEntries.has(tool))) {
+        for (const tool of toolsService.getAllToolsIncludingDisabled()) {
+            if (!tool.canBeReferencedInPrompt || !( toolsEntries.has(tool.id))) {
                 continue;
             }
             const bucket = getBucket(tool.source);
             if (!bucket) {
                 continue;
             }
-            const toolChecked = bucket.checked === true || toolsEntries.get(tool) === true;
+            const toolChecked = bucket.checked === true || toolsEntries.get(tool.id) === true;
             const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
             bucket.children.push(toolTreeItem);
         }
-        for (const { server, seen } of ( mcpServers.values())) {
+        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 });
+                getBucket({
+                    type: "mcp",
+                    definitionId: server.definition.id,
+                    label: server.definition.label,
+                    instructions: "",
+                    serverLabel: "",
+                    collectionId: server.collection.id
+                });
             }
         }
         const sortedBuckets = Array.from(( bucketMap.values())).sort((a, b) => {
@@ -339,9 +356,8 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
             }
         }
         if (treeItems.length === 0) {
-            treePicker.placeholder = ( localize(4825, "Add tools to chat"));
-        }
-        else {
+            treePicker.placeholder = ( localize(4868, "Add tools to chat"));
+        } else {
             treePicker.placeholder = placeHolder;
         }
         treePicker.setItemTree(treeItems);
@@ -349,53 +365,20 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
     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;
     treePicker.sortByLabel = false;
     computeItems();
     store.add(treePicker.onDidTriggerItemButton(e => {
-        if (e.button && typeof e.button.action === 'function') {
+        if (e.button && typeof e.button.action === "function") {
             e.button.action();
             store.dispose();
         }
     }));
-    const updateToolLimitMessage = () => {
-        if (toolLimit) {
-            let count = 0;
-            const traverse = (items) => {
-                for (const item of items) {
-                    if (isBucketTreeItem(item) || isToolSetTreeItem(item)) {
-                        if (item.children) {
-                            traverse(item.children);
-                        }
-                    }
-                    else if (isToolTreeItem(item) && item.checked) {
-                        count++;
-                    }
-                }
-            };
-            traverse(treePicker.itemTree);
-            if (count > toolLimit) {
-                treePicker.severity = Severity.Warning;
-                treePicker.validationMessage = ( localize(
-                    4826,
-                    "{0} tools are enabled. You may experience degraded tool calling above {1} tools.",
-                    count,
-                    createMarkdownCommandLink({ title: String(toolLimit), id: '_chat.toolPicker.closeAndOpenVirtualThreshold' })
-                ));
-            }
-            else {
-                treePicker.severity = Severity.Ignore;
-                treePicker.validationMessage = undefined;
-            }
-        }
-    };
-    updateToolLimitMessage();
     const collectResults = () => {
         const result = ( new Map());
-        const traverse = (items) => {
+        const traverse = items => {
             for (const item of items) {
                 if (isBucketTreeItem(item)) {
                     if (item.toolset) {
@@ -403,14 +386,12 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
                         result.set(item.toolset, allChecked);
                     }
                     traverse(item.children);
-                }
-                else if (isToolSetTreeItem(item)) {
+                } else if (isToolSetTreeItem(item)) {
                     result.set(item.toolset, item.checked === true);
                     if (item.children) {
                         traverse(item.children);
                     }
-                }
-                else if (isToolTreeItem(item)) {
+                } else if (isToolTreeItem(item)) {
                     result.set(item.tool, item.checked || result.get(item.tool) === true);
                 }
             }
@@ -418,14 +399,6 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
         traverse(treePicker.itemTree);
         return result;
     };
-    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(() => updateToolLimitMessage()));
     let didAccept = false;
     const didAcceptFinalItem = store.add(( new Emitter()));
     store.add(treePicker.onDidAccept(() => {
@@ -443,26 +416,24 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
     }));
     const addMcpServerButton = {
         iconClass: ThemeIcon.asClassName(Codicon.mcp),
-        tooltip: ( localize(4827, 'Add MCP Server...'))
+        tooltip: ( localize(4869, "Add MCP Server..."))
     };
     const installExtension = {
         iconClass: ThemeIcon.asClassName(Codicon.extensions),
-        tooltip: ( localize(4828, 'Install Extension...'))
+        tooltip: ( localize(4870, "Install Extension..."))
     };
     const configureToolSets = {
         iconClass: ThemeIcon.asClassName(Codicon.gear),
-        tooltip: ( localize(4829, 'Configure Tool Sets...'))
+        tooltip: ( localize(4871, "Configure Tool Sets..."))
     };
-    treePicker.title = ( localize(4830, "Configure Tools"));
+    treePicker.title = ( localize(4872, "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) {
+        } else if (button === installExtension) {
+            extensionsWorkbenchService.openSearch("@tag:language-model-tools");
+        } else if (button === configureToolSets) {
             commandService.executeCommand(ConfigureToolSets.ID);
         }
         treePicker.hide();
@@ -472,10 +443,159 @@ async function showToolsPicker(accessor, placeHolder, description, getToolsEntri
             treePicker.hide();
         }));
     }
+    const initialState = collectResults();
     treePicker.show();
-    await Promise.race([Event.toPromise(Event.any(treePicker.onDidHide, didAcceptFinalItem.event), store)]);
+    await Promise.race([
+        Event.toPromise(Event.any(treePicker.onDidHide, didAcceptFinalItem.event), store)
+    ]);
+    sendDidChangeEvent(source, telemetryService, initialState, collectResults(), mcpRegistry);
     store.dispose();
     return didAccept ? collectResults() : undefined;
 }
+function categorizeTool(item, mcpRegistry) {
+    const source = item.source;
+    switch (source.type) {
+    case "internal":
+        return {
+            category: "builtin",
+            name: item.id
+        };
+    case "extension":
+        return {
+            category: "extension",
+            name: item.id,
+            extensionId: source.extensionId.value
+        };
+    case "mcp":
+        {
+            const collection = mcpRegistry.collections.get().find(c => c.id === source.collectionId);
+            if (collection?.source instanceof ExtensionIdentifier) {
+                return {
+                    category: "extension-mcp",
+                    extensionId: collection.source.value
+                };
+            }
+            return {
+                category: "user-mcp"
+            };
+        }
+    case "user":
+        return {
+            category: "user-toolset"
+        };
+    case "external":
+        return {
+            category: "user-toolset"
+        };
+    default:
+        assertNever();
+    }
+}
+function computeToolToggleSummary(initialState, finalState, mcpRegistry) {
+    const summary = {
+        builtinEnabled: 0,
+        builtinDisabled: 0,
+        extensionEnabled: 0,
+        extensionDisabled: 0,
+        extensionMcpEnabled: 0,
+        extensionMcpDisabled: 0,
+        userMcpEnabled: 0,
+        userMcpDisabled: 0,
+        userToolsetEnabled: 0,
+        userToolsetDisabled: 0,
+        details: ""
+    };
+    const detailItems = [];
+    for (const [item, finalEnabled] of finalState) {
+        const initialEnabled = initialState.get(item) ?? false;
+        if (initialEnabled === finalEnabled) {
+            continue;
+        }
+        const categorized = categorizeTool(item, mcpRegistry);
+        const enabled = finalEnabled;
+        switch (categorized.category) {
+        case "builtin":
+            if (enabled) {
+                summary.builtinEnabled++;
+            } else {
+                summary.builtinDisabled++;
+            }
+            detailItems.push({
+                category: "builtin",
+                name: categorized.name,
+                enabled
+            });
+            break;
+        case "extension":
+            if (enabled) {
+                summary.extensionEnabled++;
+            } else {
+                summary.extensionDisabled++;
+            }
+            detailItems.push({
+                category: "extension",
+                name: categorized.name,
+                extensionId: categorized.extensionId,
+                enabled
+            });
+            break;
+        case "extension-mcp":
+            if (enabled) {
+                summary.extensionMcpEnabled++;
+            } else {
+                summary.extensionMcpDisabled++;
+            }
+            detailItems.push({
+                category: "extension-mcp",
+                extensionId: categorized.extensionId,
+                enabled
+            });
+            break;
+        case "user-mcp":
+            if (enabled) {
+                summary.userMcpEnabled++;
+            } else {
+                summary.userMcpDisabled++;
+            }
+            detailItems.push({
+                category: "user-mcp",
+                enabled
+            });
+            break;
+        case "user-toolset":
+            if (enabled) {
+                summary.userToolsetEnabled++;
+            } else {
+                summary.userToolsetDisabled++;
+            }
+            detailItems.push({
+                category: "user-toolset",
+                enabled
+            });
+            break;
+        }
+    }
+    summary.details = JSON.stringify(detailItems);
+    return summary;
+}
+function sendDidChangeEvent(source, telemetryService, initialState, finalState, mcpRegistry) {
+    const summary = computeToolToggleSummary(initialState, finalState, mcpRegistry);
+    const changed = summary.builtinEnabled > 0 || summary.builtinDisabled > 0 || summary.extensionEnabled > 0 || summary.extensionDisabled > 0 || summary.extensionMcpEnabled > 0 || summary.extensionMcpDisabled > 0 || summary.userMcpEnabled > 0 || summary.userMcpDisabled > 0 || summary.userToolsetEnabled > 0 || summary.userToolsetDisabled > 0;
+    telemetryService.publicLog2("chatToolPickerClosed", {
+        source,
+        changed,
+        builtinEnabled: summary.builtinEnabled,
+        builtinDisabled: summary.builtinDisabled,
+        extensionEnabled: summary.extensionEnabled,
+        extensionDisabled: summary.extensionDisabled,
+        extensionMcpEnabled: summary.extensionMcpEnabled,
+        extensionMcpDisabled: summary.extensionMcpDisabled,
+        userMcpEnabled: summary.userMcpEnabled,
+        userMcpDisabled: summary.userMcpDisabled,
+        userToolsetEnabled: summary.userToolsetEnabled,
+        userToolsetDisabled: summary.userToolsetDisabled,
+        details: summary.details
+    });
+}
 
 export { showToolsPicker };