@codingame/monaco-vscode-chat-service-override 29.1.0 → 30.0.0

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

@@ -1,637 +0,0 @@
-
-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 { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-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 { 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';
-import { McpCommandIds } from '@codingame/monaco-vscode-api/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, 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 { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
-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) {
-    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";
-}
-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
-    };
-}
-function createToolSetTreeItem(toolset, checked, editorService) {
-    const iconProps = mapIconToTreeItem(toolset.icon);
-    const buttons = [];
-    if (toolset.source.type === "user") {
-        const resource = toolset.source.file;
-        buttons.push({
-            iconClass: ThemeIcon.asClassName(Codicon.edit),
-            tooltip: ( localize(5023, "Edit Tool Set")),
-            action: () => editorService.openEditor({
-                resource
-            })
-        });
-    }
-    return {
-        itemType: "toolset",
-        toolset,
-        buttons,
-        id: toolset.id,
-        label: toolset.referenceName,
-        description: toolset.description,
-        checked,
-        children: undefined,
-        collapsed: true,
-        ...iconProps
-    };
-}
-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);
-    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 confirmationService = accessor.get(ILanguageModelToolsConfirmationService);
-    const telemetryService = accessor.get(ITelemetryService);
-    const mcpServerByTool = ( new Map());
-    for (const server of mcpService.servers.get()) {
-        for (const tool of server.tools.get()) {
-            mcpServerByTool.set(tool.id, server);
-        }
-    }
-    function computeItems(previousToolsEntries) {
-        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(model)) {
-                if (tool.canBeReferencedInPrompt) {
-                    defaultEntries.set(tool, false);
-                }
-            }
-            for (const toolSet of toolsService.getToolSetsForModel(model)) {
-                defaultEntries.set(toolSet, false);
-            }
-            toolsEntries = defaultEntries;
-        }
-        previousToolsEntries?.forEach((value, key) => {
-            toolsEntries.set(key.id, 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(5024, "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(5024, "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(5025, "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(5026, "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: source.label,
-                    checked: undefined,
-                    collapsed,
-                    children,
-                    buttons,
-                    sortOrder: 2
-                };
-                const iconPath = mcpServer.serverMetadata.get()?.icons.getUrl(22);
-                if (iconPath) {
-                    bucket.iconPath = iconPath;
-                } else {
-                    bucket.iconClass = ThemeIcon.asClassName(Codicon.mcp);
-                }
-                return bucket;
-            } else if (source.type === "extension") {
-                return {
-                    itemType: "bucket",
-                    ordinal: BucketOrdinal.Extension,
-                    id: key,
-                    label: source.label,
-                    checked: undefined,
-                    children: [],
-                    buttons: [],
-                    collapsed: true,
-                    iconClass: ThemeIcon.asClassName(Codicon.extensions),
-                    sortOrder: 3
-                };
-            } else if (source.type === "internal") {
-                return {
-                    itemType: "bucket",
-                    ordinal: BucketOrdinal.BuiltIn,
-                    id: key,
-                    label: ( localize(5027, "Built-In")),
-                    checked: undefined,
-                    children: [],
-                    buttons: [],
-                    collapsed: false,
-                    sortOrder: 1
-                };
-            } else {
-                return {
-                    itemType: "bucket",
-                    ordinal: BucketOrdinal.User,
-                    id: key,
-                    label: ( localize(5028, "User Defined Tool Sets")),
-                    checked: undefined,
-                    children: [],
-                    buttons: [],
-                    collapsed: true,
-                    sortOrder: 4
-                };
-            }
-        };
-        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.getToolSetsForModel(model)) {
-            if (!( toolsEntries.has(toolSet.id))) {
-                continue;
-            }
-            const bucket = getBucket(toolSet.source);
-            if (!bucket) {
-                continue;
-            }
-            const toolSetChecked = toolsEntries.get(toolSet.id) === true;
-            if (toolSet.source.type === "mcp") {
-                bucket.toolset = toolSet;
-                if (toolSetChecked) {
-                    bucket.checked = toolSetChecked;
-                }
-            } 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.id) === true;
-                    const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
-                    children.push(toolTreeItem);
-                }
-                if (children.length > 0) {
-                    treeItem.children = children;
-                }
-            }
-        }
-        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.id) === true;
-            const toolTreeItem = createToolTreeItemFromData(tool, toolChecked);
-            bucket.children.push(toolTreeItem);
-        }
-        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
-                });
-            }
-        }
-        const sortedBuckets = Array.from(( bucketMap.values())).sort((a, b) => {
-            if (a.sortOrder !== b.sortOrder) {
-                return a.sortOrder - b.sortOrder;
-            }
-            return a.label.localeCompare(b.label);
-        });
-        for (const bucket of sortedBuckets) {
-            treeItems.push(bucket);
-            bucket.children.sort((a, b) => a.label.localeCompare(b.label));
-            for (const child of bucket.children) {
-                if (isToolSetTreeItem(child) && child.children) {
-                    child.children.sort((a, b) => a.label.localeCompare(b.label));
-                }
-            }
-        }
-        for (const bucket of sortedBuckets) {
-            const isMcpBucket = bucket.ordinal === BucketOrdinal.Mcp;
-            const addConfirmationButton = toolItem => {
-                if (!confirmationService.toolCanManageConfirmation(toolItem.tool)) {
-                    return;
-                }
-                const tool = toolItem.tool;
-                const manageTools = isMcpBucket ? bucket.children.flatMap(
-                    c => isToolTreeItem(c) ? [c.tool] : isToolSetTreeItem(c) && c.children ? ( c.children.filter(isToolTreeItem).map(gc => gc.tool)) : []
-                ) : [tool];
-                const buttons = toolItem.buttons ? [...toolItem.buttons] : [];
-                buttons.push({
-                    iconClass: ThemeIcon.asClassName(Codicon.pass),
-                    tooltip: ( localize(5029, "Manage Approval")),
-                    keepOpen: true,
-                    action: () => confirmationService.manageConfirmationPreferences(manageTools, {
-                        focusToolId: tool.id
-                    })
-                });
-                toolItem.buttons = buttons;
-            };
-            for (const child of bucket.children) {
-                if (isToolTreeItem(child)) {
-                    addConfirmationButton(child);
-                } else if (isToolSetTreeItem(child) && child.children) {
-                    for (const grandchild of child.children) {
-                        if (isToolTreeItem(grandchild)) {
-                            addConfirmationButton(grandchild);
-                        }
-                    }
-                }
-            }
-        }
-        if (treeItems.length === 0) {
-            treePicker.placeholder = ( localize(5030, "Add tools to chat"));
-        } else {
-            treePicker.placeholder = placeHolder;
-        }
-        treePicker.setItemTree(treeItems);
-    }
-    const store = ( new DisposableStore());
-    const treePicker = store.add(quickPickService.createQuickTree());
-    treePicker.placeholder = placeHolder;
-    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") {
-            const actionableButton = e.button;
-            actionableButton.action();
-            store.dispose();
-        }
-    }));
-    const collectResults = () => {
-        const result = ( new Map());
-        const traverse = items => {
-            for (const item of items) {
-                if (isBucketTreeItem(item)) {
-                    if (item.toolset) {
-                        const allChecked = item.checked === true;
-                        result.set(item.toolset, allChecked);
-                    }
-                    traverse(item.children);
-                } else if (isToolSetTreeItem(item)) {
-                    result.set(item.toolset, item.checked === true);
-                    if (item.children) {
-                        traverse(item.children);
-                    }
-                } else if (isToolTreeItem(item)) {
-                    result.set(item.tool, item.checked || result.get(item.tool) === true);
-                }
-            }
-        };
-        traverse(treePicker.itemTree);
-        return result;
-    };
-    let didAccept = false;
-    const didAcceptFinalItem = store.add(( new Emitter()));
-    store.add(treePicker.onDidAccept(() => {
-        const activeItems = treePicker.activeItems;
-        const callbackItem = activeItems.find(isCallbackTreeItem);
-        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(5031, "Add MCP Server..."))
-    };
-    const installExtension = {
-        iconClass: ThemeIcon.asClassName(Codicon.extensions),
-        tooltip: ( localize(5032, "Install Extension..."))
-    };
-    const configureToolSets = {
-        iconClass: ThemeIcon.asClassName(Codicon.gear),
-        tooltip: ( localize(5033, "Configure Tool Sets..."))
-    };
-    treePicker.title = ( localize(5034, "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();
-    }));
-    if (token) {
-        store.add(token.onCancellationRequested(() => {
-            treePicker.hide();
-        }));
-    }
-    const initialState = collectResults();
-    treePicker.show();
-    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 };

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

@@ -1,24 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
-import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
-import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
-import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
-import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
-import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
-export declare class UserToolSetsContributions extends Disposable implements IWorkbenchContribution {
-    private readonly _languageModelToolsService;
-    private readonly _userDataProfileService;
-    private readonly _fileService;
-    private readonly _logService;
-    static readonly ID = "chat.userToolSets";
-    constructor(extensionService: IExtensionService, lifecycleService: ILifecycleService, _languageModelToolsService: ILanguageModelToolsService, _userDataProfileService: IUserDataProfileService, _fileService: IFileService, _logService: ILogService);
-    private _initToolSets;
-}
-export declare class ConfigureToolSets extends Action2 {
-    static readonly ID = "chat.configureToolSets";
-    constructor();
-    run(accessor: ServicesAccessor): Promise<void>;
-}