@codingame/monaco-vscode-chat-service-override 22.1.9 → 23.0.0

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

@@ -0,0 +1,688 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Toggle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/toggle';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { LRUCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import { inputActiveOptionBackground, inputActiveOptionForeground, inputActiveOptionBorder } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+
+const RUN_WITHOUT_APPROVAL = ( localize(5571, "without approval"));
+const CONTINUE_WITHOUT_REVIEWING_RESULTS = ( localize(5572, "without reviewing result"));
+class GenericConfirmStore extends Disposable {
+    constructor(_storageKey, _instantiationService) {
+        super();
+        this._storageKey = _storageKey;
+        this._instantiationService = _instantiationService;
+        this._memoryStore = ( new Set());
+        this._workspaceStore = ( new Lazy(
+            () => this._register(this._instantiationService.createInstance(ToolConfirmStore, StorageScope.WORKSPACE, this._storageKey))
+        ));
+        this._profileStore = ( new Lazy(
+            () => this._register(this._instantiationService.createInstance(ToolConfirmStore, StorageScope.PROFILE, this._storageKey))
+        ));
+    }
+    setAutoConfirmation(id, scope) {
+        this._workspaceStore.value.setAutoConfirm(id, false);
+        this._profileStore.value.setAutoConfirm(id, false);
+        this._memoryStore.delete(id);
+        if (scope === 'workspace') {
+            this._workspaceStore.value.setAutoConfirm(id, true);
+        }
+        else if (scope === 'profile') {
+            this._profileStore.value.setAutoConfirm(id, true);
+        }
+        else if (scope === 'session') {
+            this._memoryStore.add(id);
+        }
+    }
+    getAutoConfirmation(id) {
+        if (this._workspaceStore.value.getAutoConfirm(id)) {
+            return 'workspace';
+        }
+        if (this._profileStore.value.getAutoConfirm(id)) {
+            return 'profile';
+        }
+        if (( this._memoryStore.has(id))) {
+            return 'session';
+        }
+        return 'never';
+    }
+    getAutoConfirmationIn(id, scope) {
+        if (scope === 'workspace') {
+            return this._workspaceStore.value.getAutoConfirm(id);
+        }
+        else if (scope === 'profile') {
+            return this._profileStore.value.getAutoConfirm(id);
+        }
+        else {
+            return ( this._memoryStore.has(id));
+        }
+    }
+    reset() {
+        this._workspaceStore.value.reset();
+        this._profileStore.value.reset();
+        this._memoryStore.clear();
+    }
+    checkAutoConfirmation(id) {
+        if (this._workspaceStore.value.getAutoConfirm(id)) {
+            return { type: ToolConfirmKind.LmServicePerTool, scope: 'workspace' };
+        }
+        if (this._profileStore.value.getAutoConfirm(id)) {
+            return { type: ToolConfirmKind.LmServicePerTool, scope: 'profile' };
+        }
+        if (( this._memoryStore.has(id))) {
+            return { type: ToolConfirmKind.LmServicePerTool, scope: 'session' };
+        }
+        return undefined;
+    }
+    getAllConfirmed() {
+        const all = ( new Set());
+        for (const key of this._workspaceStore.value.getAll()) {
+            all.add(key);
+        }
+        for (const key of this._profileStore.value.getAll()) {
+            all.add(key);
+        }
+        for (const key of this._memoryStore) {
+            all.add(key);
+        }
+        return all;
+    }
+}
+let ToolConfirmStore = class ToolConfirmStore extends Disposable {
+    constructor(_scope, _storageKey, storageService) {
+        super();
+        this._scope = _scope;
+        this._storageKey = _storageKey;
+        this.storageService = storageService;
+        this._autoConfirmTools = ( new LRUCache(100));
+        this._didChange = false;
+        const stored = storageService.getObject(this._storageKey, this._scope);
+        if (stored) {
+            for (const key of stored) {
+                this._autoConfirmTools.set(key, true);
+            }
+        }
+        this._register(storageService.onWillSaveState(() => {
+            if (this._didChange) {
+                this.storageService.store(this._storageKey, [...( this._autoConfirmTools.keys())], this._scope, StorageTarget.MACHINE);
+                this._didChange = false;
+            }
+        }));
+    }
+    reset() {
+        this._autoConfirmTools.clear();
+        this._didChange = true;
+    }
+    getAutoConfirm(id) {
+        if (this._autoConfirmTools.get(id)) {
+            this._didChange = true;
+            return true;
+        }
+        return false;
+    }
+    setAutoConfirm(id, autoConfirm) {
+        if (autoConfirm) {
+            this._autoConfirmTools.set(id, true);
+        }
+        else {
+            this._autoConfirmTools.delete(id);
+        }
+        this._didChange = true;
+    }
+    getAll() {
+        return [...( this._autoConfirmTools.keys())];
+    }
+};
+ToolConfirmStore = ( __decorate([
+    ( __param(2, IStorageService))
+], ToolConfirmStore));
+let LanguageModelToolsConfirmationService = class LanguageModelToolsConfirmationService extends Disposable {
+    constructor(_instantiationService, _quickInputService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._quickInputService = _quickInputService;
+        this._contributions = ( new Map());
+        this._preExecutionToolConfirmStore = this._register(( new GenericConfirmStore('chat/autoconfirm', this._instantiationService)));
+        this._postExecutionToolConfirmStore = this._register(( new GenericConfirmStore('chat/autoconfirm-post', this._instantiationService)));
+        this._preExecutionServerConfirmStore = this._register(( new GenericConfirmStore('chat/servers/autoconfirm', this._instantiationService)));
+        this._postExecutionServerConfirmStore = this._register(( new GenericConfirmStore('chat/servers/autoconfirm-post', this._instantiationService)));
+    }
+    getPreConfirmAction(ref) {
+        const contribution = this._contributions.get(ref.toolId);
+        if (contribution?.getPreConfirmAction) {
+            const result = contribution.getPreConfirmAction(ref);
+            if (result) {
+                return result;
+            }
+        }
+        if (contribution && contribution.canUseDefaultApprovals === false) {
+            return undefined;
+        }
+        const toolResult = this._preExecutionToolConfirmStore.checkAutoConfirmation(ref.toolId);
+        if (toolResult) {
+            return toolResult;
+        }
+        if (ref.source.type === 'mcp') {
+            const serverResult = this._preExecutionServerConfirmStore.checkAutoConfirmation(ref.source.definitionId);
+            if (serverResult) {
+                return serverResult;
+            }
+        }
+        return undefined;
+    }
+    getPostConfirmAction(ref) {
+        const contribution = this._contributions.get(ref.toolId);
+        if (contribution?.getPostConfirmAction) {
+            const result = contribution.getPostConfirmAction(ref);
+            if (result) {
+                return result;
+            }
+        }
+        if (contribution && contribution.canUseDefaultApprovals === false) {
+            return undefined;
+        }
+        const toolResult = this._postExecutionToolConfirmStore.checkAutoConfirmation(ref.toolId);
+        if (toolResult) {
+            return toolResult;
+        }
+        if (ref.source.type === 'mcp') {
+            const serverResult = this._postExecutionServerConfirmStore.checkAutoConfirmation(ref.source.definitionId);
+            if (serverResult) {
+                return serverResult;
+            }
+        }
+        return undefined;
+    }
+    getPreConfirmActions(ref) {
+        const actions = [];
+        const contribution = this._contributions.get(ref.toolId);
+        if (contribution?.getPreConfirmActions) {
+            actions.push(...contribution.getPreConfirmActions(ref));
+        }
+        if (contribution && contribution.canUseDefaultApprovals === false) {
+            return actions;
+        }
+        actions.push({
+            label: ( localize(5573, 'Allow in this Session')),
+            detail: ( localize(5574, 'Allow this tool to run in this session without confirmation.')),
+            divider: !!actions.length,
+            select: async () => {
+                this._preExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, 'session');
+                return true;
+            }
+        }, {
+            label: ( localize(5575, 'Allow in this Workspace')),
+            detail: ( localize(5576, 'Allow this tool to run in this workspace without confirmation.')),
+            select: async () => {
+                this._preExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, 'workspace');
+                return true;
+            }
+        }, {
+            label: ( localize(5577, 'Always Allow')),
+            detail: ( localize(5578, 'Always allow this tool to run without confirmation.')),
+            select: async () => {
+                this._preExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, 'profile');
+                return true;
+            }
+        });
+        if (ref.source.type === 'mcp') {
+            const { serverLabel, definitionId } = ref.source;
+            actions.push({
+                label: ( localize(5579, 'Allow Tools from {0} in this Session', serverLabel)),
+                detail: ( localize(
+                    5580,
+                    'Allow all tools from this server to run in this session without confirmation.'
+                )),
+                divider: true,
+                select: async () => {
+                    this._preExecutionServerConfirmStore.setAutoConfirmation(definitionId, 'session');
+                    return true;
+                }
+            }, {
+                label: ( localize(5581, 'Allow Tools from {0} in this Workspace', serverLabel)),
+                detail: ( localize(
+                    5582,
+                    'Allow all tools from this server to run in this workspace without confirmation.'
+                )),
+                select: async () => {
+                    this._preExecutionServerConfirmStore.setAutoConfirmation(definitionId, 'workspace');
+                    return true;
+                }
+            }, {
+                label: ( localize(5583, 'Always Allow Tools from {0}', serverLabel)),
+                detail: ( localize(
+                    5584,
+                    'Always allow all tools from this server to run without confirmation.'
+                )),
+                select: async () => {
+                    this._preExecutionServerConfirmStore.setAutoConfirmation(definitionId, 'profile');
+                    return true;
+                }
+            });
+        }
+        return actions;
+    }
+    getPostConfirmActions(ref) {
+        const actions = [];
+        const contribution = this._contributions.get(ref.toolId);
+        if (contribution?.getPostConfirmActions) {
+            actions.push(...contribution.getPostConfirmActions(ref));
+        }
+        if (contribution && contribution.canUseDefaultApprovals === false) {
+            return actions;
+        }
+        actions.push({
+            label: ( localize(5585, 'Allow Without Review in this Session')),
+            detail: ( localize(
+                5586,
+                'Allow results from this tool to be sent without confirmation in this session.'
+            )),
+            divider: !!actions.length,
+            select: async () => {
+                this._postExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, 'session');
+                return true;
+            }
+        }, {
+            label: ( localize(5587, 'Allow Without Review in this Workspace')),
+            detail: ( localize(
+                5588,
+                'Allow results from this tool to be sent without confirmation in this workspace.'
+            )),
+            select: async () => {
+                this._postExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, 'workspace');
+                return true;
+            }
+        }, {
+            label: ( localize(5589, 'Always Allow Without Review')),
+            detail: ( localize(
+                5590,
+                'Always allow results from this tool to be sent without confirmation.'
+            )),
+            select: async () => {
+                this._postExecutionToolConfirmStore.setAutoConfirmation(ref.toolId, 'profile');
+                return true;
+            }
+        });
+        if (ref.source.type === 'mcp') {
+            const { serverLabel, definitionId } = ref.source;
+            actions.push({
+                label: ( localize(5591, 'Allow Tools from {0} Without Review in this Session', serverLabel)),
+                detail: ( localize(
+                    5592,
+                    'Allow results from all tools from this server to be sent without confirmation in this session.'
+                )),
+                divider: true,
+                select: async () => {
+                    this._postExecutionServerConfirmStore.setAutoConfirmation(definitionId, 'session');
+                    return true;
+                }
+            }, {
+                label: ( localize(5593, 'Allow Tools from {0} Without Review in this Workspace', serverLabel)),
+                detail: ( localize(
+                    5594,
+                    'Allow results from all tools from this server to be sent without confirmation in this workspace.'
+                )),
+                select: async () => {
+                    this._postExecutionServerConfirmStore.setAutoConfirmation(definitionId, 'workspace');
+                    return true;
+                }
+            }, {
+                label: ( localize(5595, 'Always Allow Tools from {0} Without Review', serverLabel)),
+                detail: ( localize(
+                    5596,
+                    'Always allow results from all tools from this server to be sent without confirmation.'
+                )),
+                select: async () => {
+                    this._postExecutionServerConfirmStore.setAutoConfirmation(definitionId, 'profile');
+                    return true;
+                }
+            });
+        }
+        return actions;
+    }
+    registerConfirmationContribution(toolName, contribution) {
+        this._contributions.set(toolName, contribution);
+        return {
+            dispose: () => {
+                this._contributions.delete(toolName);
+            }
+        };
+    }
+    manageConfirmationPreferences(tools, options) {
+        const trackServerTool = (serverId, label, toolId, serversWithTools) => {
+            if (!( serversWithTools.has(serverId))) {
+                serversWithTools.set(serverId, { label, tools: ( new Set()) });
+            }
+            serversWithTools.get(serverId).tools.add(toolId);
+        };
+        const addServerToolFromSource = (source, toolId, serversWithTools) => {
+            if (source.type === 'mcp') {
+                trackServerTool(source.definitionId, source.serverLabel || source.label, toolId, serversWithTools);
+            }
+            else if (source.type === 'extension') {
+                trackServerTool(source.extensionId.value, source.label, toolId, serversWithTools);
+            }
+        };
+        const relevantTools = ( new Set());
+        const serversWithTools = ( new Map());
+        for (const tool of tools) {
+            if (tool.canRequestPreApproval || tool.canRequestPostApproval || ( this._contributions.has(tool.id))) {
+                relevantTools.add(tool.id);
+                addServerToolFromSource(tool.source, tool.id, serversWithTools);
+            }
+        }
+        for (const id of this._preExecutionToolConfirmStore.getAllConfirmed()) {
+            if (!( relevantTools.has(id))) {
+                const tool = tools.find(t => t.id === id);
+                if (tool) {
+                    relevantTools.add(id);
+                    addServerToolFromSource(tool.source, id, serversWithTools);
+                }
+            }
+        }
+        for (const id of this._postExecutionToolConfirmStore.getAllConfirmed()) {
+            if (!( relevantTools.has(id))) {
+                const tool = tools.find(t => t.id === id);
+                if (tool) {
+                    relevantTools.add(id);
+                    addServerToolFromSource(tool.source, id, serversWithTools);
+                }
+            }
+        }
+        if (relevantTools.size === 0) {
+            return;
+        }
+        let currentScope = options?.defaultScope ?? 'workspace';
+        const buildTreeItems = () => {
+            const treeItems = [];
+            for (const [serverId, serverInfo] of serversWithTools) {
+                const serverChildren = [];
+                const hasAnyPre = ( Array.from(serverInfo.tools).some(toolId => {
+                    const tool = tools.find(t => t.id === toolId);
+                    return tool?.canRequestPreApproval;
+                }));
+                const hasAnyPost = ( Array.from(serverInfo.tools).some(toolId => {
+                    const tool = tools.find(t => t.id === toolId);
+                    return tool?.canRequestPostApproval;
+                }));
+                const serverPreConfirmed = this._preExecutionServerConfirmStore.getAutoConfirmationIn(serverId, currentScope);
+                const serverPostConfirmed = this._postExecutionServerConfirmStore.getAutoConfirmationIn(serverId, currentScope);
+                for (const toolId of serverInfo.tools) {
+                    const tool = tools.find(t => t.id === toolId);
+                    if (!tool) {
+                        continue;
+                    }
+                    const toolChildren = [];
+                    const hasPre = !serverPreConfirmed && (tool.canRequestPreApproval || this._preExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope));
+                    const hasPost = !serverPostConfirmed && (tool.canRequestPostApproval || this._postExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope));
+                    if (hasPre && hasPost) {
+                        toolChildren.push({
+                            type: 'tool-pre',
+                            toolId: tool.id,
+                            label: RUN_WITHOUT_APPROVAL,
+                            checked: this._preExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope)
+                        });
+                        toolChildren.push({
+                            type: 'tool-post',
+                            toolId: tool.id,
+                            label: CONTINUE_WITHOUT_REVIEWING_RESULTS,
+                            checked: this._postExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope)
+                        });
+                    }
+                    const preApproval = this._preExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope);
+                    const postApproval = this._postExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope);
+                    let checked;
+                    let description;
+                    if (hasPre && hasPost) {
+                        checked = preApproval && postApproval ? true : (!preApproval && !postApproval ? false : 'mixed');
+                    }
+                    else if (hasPre) {
+                        checked = preApproval;
+                        description = RUN_WITHOUT_APPROVAL;
+                    }
+                    else if (hasPost) {
+                        checked = postApproval;
+                        description = CONTINUE_WITHOUT_REVIEWING_RESULTS;
+                    }
+                    else {
+                        continue;
+                    }
+                    serverChildren.push({
+                        type: 'tool',
+                        toolId: tool.id,
+                        label: tool.displayName || tool.id,
+                        description,
+                        checked,
+                        collapsed: true,
+                        children: toolChildren.length > 0 ? toolChildren : undefined
+                    });
+                }
+                serverChildren.sort((a, b) => a.label.localeCompare(b.label));
+                if (hasAnyPost) {
+                    serverChildren.unshift({
+                        type: 'server-post',
+                        serverId,
+                        iconClass: ThemeIcon.asClassName(Codicon.play),
+                        label: ( localize(5597, "Continue without reviewing any tool results")),
+                        checked: serverPostConfirmed
+                    });
+                }
+                if (hasAnyPre) {
+                    serverChildren.unshift({
+                        type: 'server-pre',
+                        serverId,
+                        iconClass: ThemeIcon.asClassName(Codicon.play),
+                        label: ( localize(5598, "Run any tool without approval")),
+                        checked: serverPreConfirmed
+                    });
+                }
+                const serverHasPre = this._preExecutionServerConfirmStore.getAutoConfirmationIn(serverId, currentScope);
+                const serverHasPost = this._postExecutionServerConfirmStore.getAutoConfirmationIn(serverId, currentScope);
+                let serverChecked;
+                if (hasAnyPre && hasAnyPost) {
+                    serverChecked = serverHasPre && serverHasPost ? true : (!serverHasPre && !serverHasPost ? false : 'mixed');
+                }
+                else if (hasAnyPre) {
+                    serverChecked = serverHasPre;
+                }
+                else if (hasAnyPost) {
+                    serverChecked = serverHasPost;
+                }
+                else {
+                    serverChecked = false;
+                }
+                const existingItem = quickTree.itemTree.find(i => i.serverId === serverId);
+                treeItems.push({
+                    type: 'server',
+                    serverId,
+                    label: serverInfo.label,
+                    checked: serverChecked,
+                    children: serverChildren,
+                    collapsed: existingItem ? quickTree.isCollapsed(existingItem) : true,
+                    pickable: false
+                });
+            }
+            const sortedTools = tools.slice().sort((a, b) => a.displayName.localeCompare(b.displayName));
+            for (const tool of sortedTools) {
+                if (!( relevantTools.has(tool.id))) {
+                    continue;
+                }
+                if (tool.source.type === 'mcp' || tool.source.type === 'extension') {
+                    continue;
+                }
+                const contributed = this._contributions.get(tool.id);
+                const toolChildren = [];
+                const manageActions = contributed?.getManageActions?.();
+                if (manageActions) {
+                    toolChildren.push(...( manageActions.map(action => ({
+                        type: 'manage',
+                        ...action,
+                    }))));
+                }
+                let checked = false;
+                let description;
+                let pickable = false;
+                if (contributed?.canUseDefaultApprovals !== false) {
+                    pickable = true;
+                    const hasPre = tool.canRequestPreApproval || this._preExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope);
+                    const hasPost = tool.canRequestPostApproval || this._postExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope);
+                    if (hasPre && hasPost) {
+                        toolChildren.push({
+                            type: 'tool-pre',
+                            toolId: tool.id,
+                            label: RUN_WITHOUT_APPROVAL,
+                            checked: this._preExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope)
+                        });
+                        toolChildren.push({
+                            type: 'tool-post',
+                            toolId: tool.id,
+                            label: CONTINUE_WITHOUT_REVIEWING_RESULTS,
+                            checked: this._postExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope)
+                        });
+                    }
+                    const preApproval = this._preExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope);
+                    const postApproval = this._postExecutionToolConfirmStore.getAutoConfirmationIn(tool.id, currentScope);
+                    if (hasPre && hasPost) {
+                        checked = preApproval && postApproval ? true : (!preApproval && !postApproval ? false : 'mixed');
+                    }
+                    else if (hasPre) {
+                        checked = preApproval;
+                        description = RUN_WITHOUT_APPROVAL;
+                    }
+                    else if (hasPost) {
+                        checked = postApproval;
+                        description = CONTINUE_WITHOUT_REVIEWING_RESULTS;
+                    }
+                    else {
+                        checked = false;
+                    }
+                }
+                treeItems.push({
+                    type: 'tool',
+                    toolId: tool.id,
+                    label: tool.displayName || tool.id,
+                    description,
+                    checked,
+                    pickable,
+                    collapsed: true,
+                    children: toolChildren.length > 0 ? toolChildren : undefined
+                });
+            }
+            return treeItems;
+        };
+        const disposables = ( new DisposableStore());
+        const quickTree = disposables.add(this._quickInputService.createQuickTree());
+        quickTree.ignoreFocusOut = true;
+        quickTree.sortByLabel = false;
+        if (currentScope !== 'session') {
+            const scopeToggle = disposables.add(( new Toggle({
+                title: ( localize(5599, "Configure for this workspace only")),
+                icon: Codicon.folder,
+                isChecked: currentScope === 'workspace',
+                inputActiveOptionBorder: asCssVariable(inputActiveOptionBorder),
+                inputActiveOptionForeground: asCssVariable(inputActiveOptionForeground),
+                inputActiveOptionBackground: asCssVariable(inputActiveOptionBackground)
+            })));
+            quickTree.toggles = [scopeToggle];
+            disposables.add(scopeToggle.onChange(() => {
+                currentScope = currentScope === 'workspace' ? 'profile' : 'workspace';
+                updatePlaceholder();
+                quickTree.setItemTree(buildTreeItems());
+            }));
+        }
+        const updatePlaceholder = () => {
+            if (currentScope === 'session') {
+                quickTree.placeholder = ( localize(5600, "Configure session tool approvals"));
+            }
+            else {
+                quickTree.placeholder = currentScope === 'workspace'
+                    ? ( localize(5601, "Configure workspace tool approvals"))
+                    : ( localize(5602, "Configure global tool approvals"));
+            }
+        };
+        updatePlaceholder();
+        quickTree.setItemTree(buildTreeItems());
+        disposables.add(quickTree.onDidChangeCheckboxState(item => {
+            const newState = item.checked ? currentScope : 'never';
+            if (item.type === 'server' && item.serverId) {
+                const serverInfo = serversWithTools.get(item.serverId);
+                if (serverInfo) {
+                    this._preExecutionServerConfirmStore.setAutoConfirmation(item.serverId, newState);
+                    this._postExecutionServerConfirmStore.setAutoConfirmation(item.serverId, newState);
+                }
+            }
+            else if (item.type === 'tool' && item.toolId) {
+                const tool = tools.find(t => t.id === item.toolId);
+                if (tool?.canRequestPostApproval || newState === 'never') {
+                    this._postExecutionToolConfirmStore.setAutoConfirmation(item.toolId, newState);
+                }
+                if (tool?.canRequestPreApproval || newState === 'never') {
+                    this._preExecutionToolConfirmStore.setAutoConfirmation(item.toolId, newState);
+                }
+            }
+            else if (item.type === 'tool-pre' && item.toolId) {
+                this._preExecutionToolConfirmStore.setAutoConfirmation(item.toolId, newState);
+            }
+            else if (item.type === 'tool-post' && item.toolId) {
+                this._postExecutionToolConfirmStore.setAutoConfirmation(item.toolId, newState);
+            }
+            else if (item.type === 'server-pre' && item.serverId) {
+                this._preExecutionServerConfirmStore.setAutoConfirmation(item.serverId, newState);
+                quickTree.setItemTree(buildTreeItems());
+            }
+            else if (item.type === 'server-post' && item.serverId) {
+                this._postExecutionServerConfirmStore.setAutoConfirmation(item.serverId, newState);
+                quickTree.setItemTree(buildTreeItems());
+            }
+            else if (item.type === 'manage') {
+                item.onDidChangeChecked?.(!!item.checked);
+            }
+        }));
+        disposables.add(quickTree.onDidTriggerItemButton(i => {
+            if (i.item.type === 'manage') {
+                i.item.onDidTriggerItemButton?.(i.button);
+            }
+        }));
+        disposables.add(quickTree.onDidAccept(() => {
+            quickTree.hide();
+        }));
+        disposables.add(quickTree.onDidHide(() => {
+            disposables.dispose();
+        }));
+        quickTree.show();
+    }
+    resetToolAutoConfirmation() {
+        this._preExecutionToolConfirmStore.reset();
+        this._postExecutionToolConfirmStore.reset();
+        this._preExecutionServerConfirmStore.reset();
+        this._postExecutionServerConfirmStore.reset();
+        for (const contribution of ( this._contributions.values())) {
+            contribution.reset?.();
+        }
+    }
+};
+LanguageModelToolsConfirmationService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IQuickInputService))
+], LanguageModelToolsConfirmationService));
+
+export { LanguageModelToolsConfirmationService };