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

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxService.js

@@ -1,8 +1,9 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { win32, posix, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { OS, OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
@@ -15,13 +16,27 @@ import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/fi
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-import { ITrustedDomainService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/url/common/trustedDomainService.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { WillShutdownJoinerOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { ISandboxHelperService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { ChatElicitationRequestPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatElicitationRequestPart';
+import { ChatModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
+import { ElicitationState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { SANDBOX_HELPER_CHANNEL_NAME, SandboxHelperChannelClient } from '../../../../../platform/sandbox/common/sandboxHelperIpc.js';
 
 var TerminalSandboxService_1;
+var TerminalSandboxPrerequisiteCheck;
+(function(TerminalSandboxPrerequisiteCheck) {
+    TerminalSandboxPrerequisiteCheck["Config"] = "config";
+    TerminalSandboxPrerequisiteCheck["Dependencies"] = "dependencies";
+})(
+    TerminalSandboxPrerequisiteCheck || (TerminalSandboxPrerequisiteCheck = {})
+);
 let TerminalSandboxService = class TerminalSandboxService extends Disposable {
     static {
         TerminalSandboxService_1 = this;
@@ -35,10 +50,11 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         _environmentService,
         _logService,
         _remoteAgentService,
-        _trustedDomainService,
         _workspaceContextService,
         _productService,
-        _lifecycleService
+        _lifecycleService,
+        _sandboxHelperService,
+        _chatService
     ) {
         super();
         this._configurationService = _configurationService;
@@ -46,10 +62,11 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         this._environmentService = _environmentService;
         this._logService = _logService;
         this._remoteAgentService = _remoteAgentService;
-        this._trustedDomainService = _trustedDomainService;
         this._workspaceContextService = _workspaceContextService;
         this._productService = _productService;
         this._lifecycleService = _lifecycleService;
+        this._sandboxHelperService = _sandboxHelperService;
+        this._chatService = _chatService;
         this._srtPathResolved = false;
         this._needsForceUpdateConfigFile = true;
         this._remoteEnvDetails = null;
@@ -66,14 +83,15 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         this._remoteEnvDetailsPromise = this._remoteAgentService.getEnvironment();
         this._register(
             Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
-                if (e?.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxEnabled) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowedDomains) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkDeniedDomains) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowTrustedDomains) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxLinuxFileSystem) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.TerminalSandboxMacFileSystem)) {
+                if (e?.affectsConfiguration(TerminalChatAgentToolsSettingId.AgentSandboxEnabled) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.AgentSandboxNetworkAllowedDomains) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.AgentSandboxNetworkDeniedDomains) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.AgentSandboxLinuxFileSystem) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.AgentSandboxMacFileSystem) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxEnabled) || e?.affectsConfiguration(
+                    TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxNetworkAllowedDomains
+                ) || e?.affectsConfiguration(
+                    TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxNetworkDeniedDomains
+                ) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxLinuxFileSystem) || e?.affectsConfiguration(TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxMacFileSystem)) {
                     this.setNeedsForceUpdateConfigFile();
                 }
             })
         );
-        this._register(this._trustedDomainService.onDidChangeTrustedDomains(() => {
-            this.setNeedsForceUpdateConfigFile();
-        }));
         this._register(this._workspaceContextService.onDidChangeWorkspaceFolders(() => {
             this.setNeedsForceUpdateConfigFile();
         }));
@@ -83,27 +101,26 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             }
             e.join(this._cleanupSandboxTempDir(), {
                 id: "join.deleteFilesInSandboxTempDir",
-                label: ( localize(13961, "Delete Files in Sandbox Temp Dir")),
+                label: ( localize(14040, "Delete Files in Sandbox Temp Dir")),
                 order: WillShutdownJoinerOrder.Default
             });
         }));
     }
     async isEnabled() {
-        const os = await this.getOS();
-        if (os === OperatingSystem.Windows) {
-            return false;
-        }
-        return this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxEnabled);
+        return await this._isSandboxConfiguredEnabled();
     }
     async getOS() {
         this._remoteEnvDetails = await this._remoteEnvDetailsPromise;
         this._os = this._remoteEnvDetails ? this._remoteEnvDetails.os : OS;
         return this._os;
     }
-    wrapCommand(command) {
+    wrapCommand(command, requestUnsandboxedExecution) {
         if (!this._sandboxConfigPath || !this._tempDir) {
             throw ( new Error("Sandbox config path or temp dir not initialized"));
         }
+        if (requestUnsandboxedExecution) {
+            return this._tempDir?.path ? `(TMPDIR="${this._tempDir.path}"; export TMPDIR; ${command})` : command;
+        }
         if (!this._execPath) {
             throw ( new Error("Executable path not set to run sandbox commands"));
         }
@@ -125,7 +142,40 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
     setNeedsForceUpdateConfigFile() {
         this._needsForceUpdateConfigFile = true;
     }
+    async checkForSandboxingPrereqs(forceRefresh = false) {
+        if (!(await this._isSandboxConfiguredEnabled())) {
+            return {
+                enabled: false,
+                sandboxConfigPath: undefined,
+                failedCheck: undefined
+            };
+        }
+        const sandboxConfigPath = await this.getSandboxConfigPath(forceRefresh);
+        if (!sandboxConfigPath) {
+            return {
+                enabled: true,
+                sandboxConfigPath,
+                failedCheck: TerminalSandboxPrerequisiteCheck.Config
+            };
+        }
+        if (!(await this._checkSandboxDependencies(forceRefresh))) {
+            return {
+                enabled: true,
+                sandboxConfigPath,
+                failedCheck: TerminalSandboxPrerequisiteCheck.Dependencies,
+                missingDependencies: await this.getMissingSandboxDependencies()
+            };
+        }
+        return {
+            enabled: true,
+            sandboxConfigPath,
+            failedCheck: undefined
+        };
+    }
     async getSandboxConfigPath(forceRefresh = false) {
+        if (!(await this._isSandboxConfiguredEnabled())) {
+            return undefined;
+        }
         await this._resolveSrtPath();
         if (!this._sandboxConfigPath || forceRefresh || this._needsForceUpdateConfigFile) {
             this._sandboxConfigPath = await this._createSandboxConfig();
@@ -133,9 +183,131 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         }
         return this._sandboxConfigPath;
     }
+    async _checkSandboxDependencies(forceRefresh = false) {
+        const os = await this.getOS();
+        if (os === OperatingSystem.Windows) {
+            return false;
+        }
+        const sandboxDependencyStatus = await this._resolveSandboxDependencyStatus(forceRefresh);
+        this._sandboxDependencyStatus = sandboxDependencyStatus;
+        if (sandboxDependencyStatus && !sandboxDependencyStatus.bubblewrapInstalled) {
+            this._logService.warn("TerminalSandboxService: bubblewrap (bwrap) is not installed");
+        }
+        if (sandboxDependencyStatus && !sandboxDependencyStatus.socatInstalled) {
+            this._logService.warn("TerminalSandboxService: socat is not installed");
+        }
+        return sandboxDependencyStatus ? sandboxDependencyStatus.bubblewrapInstalled && sandboxDependencyStatus.socatInstalled : true;
+    }
+    async getMissingSandboxDependencies() {
+        const os = await this.getOS();
+        if (os === OperatingSystem.Windows) {
+            return [];
+        }
+        if (!this._sandboxDependencyStatus || !this._sandboxDependencyStatus.bubblewrapInstalled || !this._sandboxDependencyStatus.socatInstalled) {
+            this._sandboxDependencyStatus = await this._resolveSandboxDependencyStatus(true);
+        }
+        const missing = [];
+        if (this._sandboxDependencyStatus && !this._sandboxDependencyStatus.bubblewrapInstalled) {
+            missing.push("bubblewrap");
+        }
+        if (this._sandboxDependencyStatus && !this._sandboxDependencyStatus.socatInstalled) {
+            missing.push("socat");
+        }
+        return missing;
+    }
+    async installMissingSandboxDependencies(missingDependencies, sessionResource, token, options) {
+        const depsList = missingDependencies.join(" ");
+        const installCommand = `sudo apt install -y ${depsList}`;
+        const instance = await options.createTerminal();
+        let installCommandSent = false;
+        const completionPromise = ( new Promise(resolve => {
+            const store = ( new DisposableStore());
+            let resolved = false;
+            const resolveOnce = code => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                store.dispose();
+                resolve(code);
+            };
+            const attachListener = () => {
+                const detection = instance.capabilities.get(TerminalCapability.CommandDetection);
+                if (detection) {
+                    store.add(detection.onCommandFinished(cmd => resolveOnce(cmd.exitCode)));
+                }
+            };
+            attachListener();
+            store.add(instance.capabilities.onDidAddCapability(e => {
+                if (e.id === TerminalCapability.CommandDetection) {
+                    attachListener();
+                }
+            }));
+            store.add(instance.onDisposed(() => resolveOnce(undefined)));
+            store.add(token.onCancellationRequested(() => resolveOnce(undefined)));
+            const safetyTimeout = timeout(5 * 60 * 1000);
+            store.add({
+                dispose: () => safetyTimeout.cancel()
+            });
+            safetyTimeout.then(() => resolveOnce(undefined));
+            const passwordPrompt = this._createMissingDependencyPasswordPrompt(sessionResource, {
+                focusTerminal: () => options.focusTerminal(instance),
+                onDidInputData: instance.onDidInputData,
+                onDisposed: instance.onDisposed,
+                didSendInstallCommand: () => installCommandSent
+            }, token);
+            store.add(passwordPrompt);
+        }));
+        await instance.sendText(installCommand, true);
+        installCommandSent = true;
+        return {
+            exitCode: await completionPromise
+        };
+    }
+    _createMissingDependencyPasswordPrompt(sessionResource, promptContext, token) {
+        const chatModel = sessionResource && this._chatService.getSession(sessionResource);
+        if (!(chatModel instanceof ChatModel)) {
+            return ( new DisposableStore());
+        }
+        const request = chatModel.getRequests().at(-1);
+        if (!request) {
+            return ( new DisposableStore());
+        }
+        const part = ( new ChatElicitationRequestPart(( localize(14041, "The terminal is awaiting input.")), ( new MarkdownString(( localize(
+            14042,
+            "Installing missing sandbox dependencies may prompt for your sudo password. Select Focus Terminal to type it in the terminal."
+        )))), "", ( localize(14043, "Focus Terminal")), undefined, async () => {
+            await promptContext.focusTerminal();
+            return ElicitationState.Pending;
+        }));
+        chatModel.acceptResponseProgress(request, part);
+        const store = ( new DisposableStore());
+        const disposePrompt = () => store.dispose();
+        store.add({
+            dispose: () => part.hide()
+        });
+        store.add(token.onCancellationRequested(disposePrompt));
+        store.add(promptContext.onDisposed(disposePrompt));
+        store.add(promptContext.onDidInputData(data => {
+            if (promptContext.didSendInstallCommand() && data.length > 0) {
+                disposePrompt();
+            }
+        }));
+        return store;
+    }
     _quoteShellArgument(value) {
         return `'${value.replace(/'/g, `'\\''`)}'`;
     }
+    async _isSandboxConfiguredEnabled() {
+        const os = await this.getOS();
+        if (os === OperatingSystem.Windows) {
+            return false;
+        }
+        return this._getSettingValue(
+            TerminalChatAgentToolsSettingId.AgentSandboxEnabled,
+            TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxEnabled
+        ) ?? false;
+    }
     async _resolveSrtPath() {
         if (this._srtPathResolved) {
             return;
@@ -161,21 +333,28 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             await this._initTempDir();
         }
         if (this._tempDir) {
-            const allowedDomainsSetting = this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowedDomains) ?? [];
-            const deniedDomainsSetting = this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkDeniedDomains) ?? [];
-            const allowTrustedDomains = this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowTrustedDomains) ?? false;
-            const linuxFileSystemSetting = this._os === OperatingSystem.Linux ? this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxLinuxFileSystem) ?? {} : {};
-            const macFileSystemSetting = this._os === OperatingSystem.Macintosh ? this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxMacFileSystem) ?? {} : {};
+            const allowedDomainsSetting = this._getSettingValue(
+                TerminalChatAgentToolsSettingId.AgentSandboxNetworkAllowedDomains,
+                TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxNetworkAllowedDomains
+            ) ?? [];
+            const deniedDomainsSetting = this._getSettingValue(
+                TerminalChatAgentToolsSettingId.AgentSandboxNetworkDeniedDomains,
+                TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxNetworkDeniedDomains
+            ) ?? [];
+            const linuxFileSystemSetting = this._os === OperatingSystem.Linux ? this._getSettingValue(
+                TerminalChatAgentToolsSettingId.AgentSandboxLinuxFileSystem,
+                TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxLinuxFileSystem
+            ) ?? {} : {};
+            const macFileSystemSetting = this._os === OperatingSystem.Macintosh ? this._getSettingValue(
+                TerminalChatAgentToolsSettingId.AgentSandboxMacFileSystem,
+                TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxMacFileSystem
+            ) ?? {} : {};
             const configFileUri = URI.joinPath(this._tempDir, `vscode-sandbox-settings-${this._sandboxSettingsId}.json`);
             const linuxAllowWrite = this._updateAllowWritePathsWithWorkspaceFolders(linuxFileSystemSetting.allowWrite);
             const macAllowWrite = this._updateAllowWritePathsWithWorkspaceFolders(macFileSystemSetting.allowWrite);
-            let allowedDomains = allowedDomainsSetting;
-            if (allowTrustedDomains) {
-                allowedDomains = this._addTrustedDomainsToAllowedDomains(allowedDomains);
-            }
             const sandboxSettings = {
                 network: {
-                    allowedDomains,
+                    allowedDomains: allowedDomainsSetting,
                     deniedDomains: deniedDomainsSetting
                 },
                 filesystem: {
@@ -252,31 +431,19 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
         return typeof windowId === "number" ? `tmp_vscode_${windowId}` : undefined;
     }
     getResolvedNetworkDomains() {
-        let allowedDomains = this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowedDomains) ?? [];
-        const deniedDomains = this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkDeniedDomains) ?? [];
-        const allowTrustedDomains = this._configurationService.getValue(TerminalChatAgentToolsSettingId.TerminalSandboxNetworkAllowTrustedDomains) ?? false;
-        if (allowTrustedDomains) {
-            allowedDomains = this._addTrustedDomainsToAllowedDomains(allowedDomains);
-        }
+        const allowedDomains = this._getSettingValue(
+            TerminalChatAgentToolsSettingId.AgentSandboxNetworkAllowedDomains,
+            TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxNetworkAllowedDomains
+        ) ?? [];
+        const deniedDomains = this._getSettingValue(
+            TerminalChatAgentToolsSettingId.AgentSandboxNetworkDeniedDomains,
+            TerminalChatAgentToolsSettingId.DeprecatedTerminalSandboxNetworkDeniedDomains
+        ) ?? [];
         return {
             allowedDomains,
             deniedDomains
         };
     }
-    _addTrustedDomainsToAllowedDomains(allowedDomains) {
-        const allowedDomainsSet = ( new Set(allowedDomains));
-        for (const domain of this._trustedDomainService.trustedDomains) {
-            try {
-                const uri = ( new URL(domain));
-                allowedDomainsSet.add(uri.hostname);
-            } catch {
-                if (domain !== "*") {
-                    allowedDomainsSet.add(domain);
-                }
-            }
-        }
-        return Array.from(allowedDomainsSet);
-    }
     _updateAllowWritePathsWithWorkspaceFolders(configuredAllowWrite) {
         const workspaceFolderPaths = ( this._workspaceContextService.getWorkspace().folders.map(folder => folder.uri.path));
         return [...( new Set([
@@ -285,7 +452,31 @@ let TerminalSandboxService = class TerminalSandboxService extends Disposable {
             ...(configuredAllowWrite ?? [])
         ]))];
     }
+    async _resolveSandboxDependencyStatus(forceRefresh = false) {
+        if (!forceRefresh && this._sandboxDependencyStatus) {
+            return this._sandboxDependencyStatus;
+        }
+        const connection = this._remoteAgentService.getConnection();
+        if (connection) {
+            return connection.withChannel(SANDBOX_HELPER_CHANNEL_NAME, channel => {
+                const sandboxHelper = ( new SandboxHelperChannelClient(channel));
+                return sandboxHelper.checkSandboxDependencies();
+            });
+        }
+        return this._sandboxHelperService.checkSandboxDependencies();
+    }
+    _getSettingValue(settingId, deprecatedSettingId) {
+        const setting = this._configurationService.inspect(settingId);
+        const deprecatedSetting = deprecatedSettingId ? this._configurationService.inspect(deprecatedSettingId) : undefined;
+        if (setting.userValue === undefined && deprecatedSetting?.userValue !== undefined) {
+            this._logService.warn(
+                `TerminalSandboxService: Using deprecated setting ${deprecatedSettingId} because ${settingId} is not set. Please update your settings to use ${settingId} instead.`
+            );
+            return deprecatedSetting.value;
+        }
+        return setting.value;
+    }
 };
-TerminalSandboxService = TerminalSandboxService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IFileService)), ( __param(2, IEnvironmentService)), ( __param(3, ILogService)), ( __param(4, IRemoteAgentService)), ( __param(5, ITrustedDomainService)), ( __param(6, IWorkspaceContextService)), ( __param(7, IProductService)), ( __param(8, ILifecycleService))], TerminalSandboxService));
+TerminalSandboxService = TerminalSandboxService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IFileService)), ( __param(2, IEnvironmentService)), ( __param(3, ILogService)), ( __param(4, IRemoteAgentService)), ( __param(5, IWorkspaceContextService)), ( __param(6, IProductService)), ( __param(7, ILifecycleService)), ( __param(8, ISandboxHelperService)), ( __param(9, IChatService))], TerminalSandboxService));
 
-export { TerminalSandboxService };
+export { TerminalSandboxPrerequisiteCheck, TerminalSandboxService };

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

@@ -1,14 +0,0 @@
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
-import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
-export interface IToolConfirmationActionContext {
-    readonly sessionResource?: URI;
-}
-export declare class ConfigureToolsAction extends Action2 {
-    static ID: string;
-    constructor();
-    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
-    private extractWidget;
-    private extractSource;
-}
-export declare function registerChatToolActions(): void;

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

@@ -1,208 +0,0 @@
-
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
-import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
-import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
-import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { ToolsScope } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatSelectedTools';
-import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { AcceptToolConfirmationActionId, SkipToolConfirmationActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatConstants';
-import { showToolsPicker } from './chatToolPicker.js';
-import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-
-class ToolConfirmationAction extends Action2 {
-    run(accessor, context) {
-        const chatWidgetService = accessor.get(IChatWidgetService);
-        const widget = context?.sessionResource ? chatWidgetService.getWidgetBySessionResource(context.sessionResource) : chatWidgetService.lastFocusedWidget;
-        const lastItem = widget?.viewModel?.getItems().at(-1);
-        if (!isResponseVM(lastItem)) {
-            return;
-        }
-        for (const item of lastItem.model.response.value) {
-            const state = item.kind === "toolInvocation" ? item.state.get() : undefined;
-            if (state?.type === IChatToolInvocation.StateKind.WaitingForConfirmation || state?.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-                state.confirm(this.getReason());
-                break;
-            }
-        }
-        widget?.focusInput();
-    }
-}
-class AcceptToolConfirmation extends ToolConfirmationAction {
-    constructor() {
-        super({
-            id: AcceptToolConfirmationActionId,
-            title: ( localize2(5012, "Accept")),
-            f1: false,
-            category: CHAT_CATEGORY,
-            keybinding: {
-                when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ChatContextKeys.Editing.hasToolConfirmation)),
-                primary: KeyMod.CtrlCmd | KeyCode.Enter,
-                weight: KeybindingWeight.WorkbenchContrib + 1
-            }
-        });
-    }
-    getReason() {
-        return {
-            type: ToolConfirmKind.UserAction
-        };
-    }
-}
-class SkipToolConfirmation extends ToolConfirmationAction {
-    constructor() {
-        super({
-            id: SkipToolConfirmationActionId,
-            title: ( localize2(5013, "Skip")),
-            f1: false,
-            category: CHAT_CATEGORY,
-            keybinding: {
-                when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ChatContextKeys.Editing.hasToolConfirmation)),
-                primary: KeyMod.CtrlCmd | KeyCode.Enter | KeyMod.Alt,
-                weight: KeybindingWeight.WorkbenchContrib + 1
-            }
-        });
-    }
-    getReason() {
-        return {
-            type: ToolConfirmKind.Skipped
-        };
-    }
-}
-class ConfigureToolsAction extends Action2 {
-    static {
-        this.ID = "workbench.action.chat.configureTools";
-    }
-    constructor() {
-        super({
-            id: ConfigureToolsAction.ID,
-            title: ( localize(5014, "Configure Tools...")),
-            icon: Codicon.settings,
-            f1: false,
-            category: CHAT_CATEGORY,
-            precondition: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
-            menu: [{
-                when: ( ContextKeyExpr.and(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ChatContextKeys.lockedToCodingAgent.negate()))),
-                id: MenuId.ChatInput,
-                group: "navigation",
-                order: 100
-            }]
-        });
-    }
-    async run(accessor, ...args) {
-        const instaService = accessor.get(IInstantiationService);
-        const chatWidgetService = accessor.get(IChatWidgetService);
-        const telemetryService = accessor.get(ITelemetryService);
-        let widget = chatWidgetService.lastFocusedWidget;
-        if (!widget) {
-            widget = this.extractWidget(args);
-        }
-        if (!widget) {
-            return;
-        }
-        const source = this.extractSource(args) ?? "chatInput";
-        let placeholder;
-        let description;
-        const {
-            entriesScope,
-            entriesMap
-        } = widget.input.selectedToolsModel;
-        switch (entriesScope) {
-        case ToolsScope.Session:
-            placeholder = ( localize(5015, "Select tools for this chat session"));
-            description = ( localize(5016, "The selected tools were configured only for this chat session."));
-            break;
-        case ToolsScope.Agent:
-            placeholder = ( localize(5017, "Select tools for this custom agent"));
-            description = ( localize(
-                5018,
-                "The selected tools are configured by the '{0}' custom agent. Changes to the tools will be applied to the custom agent file as well.",
-                widget.input.currentModeObs.get().label.get()
-            ));
-            break;
-        case ToolsScope.Agent_ReadOnly:
-            placeholder = ( localize(5019, "Select tools for this custom agent"));
-            description = ( localize(
-                5020,
-                "The selected tools are configured by the '{0}' custom agent. Changes to the tools will only be used for this session and will not change the '{0}' custom agent.",
-                widget.input.currentModeObs.get().label.get()
-            ));
-            break;
-        case ToolsScope.Global:
-            placeholder = ( localize(5021, "Select tools that are available to chat."));
-            description = ( localize(
-                5022,
-                "The selected tools will be applied globally for all chat sessions that use the default agent."
-            ));
-            break;
-        }
-        const cts = ( new CancellationTokenSource());
-        const initialMode = widget.input.currentModeObs.get();
-        const modeListener = autorun(reader => {
-            if (initialMode.id !== widget.input.currentModeObs.read(reader).id) {
-                cts.cancel();
-            }
-        });
-        try {
-            const result = await instaService.invokeFunction(
-                showToolsPicker,
-                placeholder,
-                source,
-                description,
-                () => entriesMap.get(),
-                widget.input.selectedLanguageModel.get()?.metadata,
-                cts.token
-            );
-            if (result) {
-                widget.input.selectedToolsModel.set(result, false);
-            }
-        } finally {
-            modeListener.dispose();
-            cts.dispose();
-        }
-        const tools = widget.input.selectedToolsModel.entriesMap.get();
-        telemetryService.publicLog2("chat/selectedTools", {
-            total: tools.size,
-            enabled: Iterable.reduce(tools, (prev, [_, enabled]) => enabled ? prev + 1 : prev, 0)
-        });
-    }
-    extractWidget(args) {
-        function isChatActionContext(obj) {
-            return !!obj && typeof obj === "object" && !!obj.widget;
-        }
-        for (const arg of args) {
-            if (isChatActionContext(arg)) {
-                return arg.widget;
-            }
-        }
-        return undefined;
-    }
-    extractSource(args) {
-        function isChatActionSource(obj) {
-            return !!obj && typeof obj === "object" && !!obj.source;
-        }
-        for (const arg of args) {
-            if (isChatActionSource(arg)) {
-                return arg.source;
-            }
-        }
-        return undefined;
-    }
-}
-function registerChatToolActions() {
-    registerAction2(AcceptToolConfirmation);
-    registerAction2(SkipToolConfirmation);
-    registerAction2(ConfigureToolsAction);
-}
-
-export { ConfigureToolsAction, registerChatToolActions };

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

@@ -1,22 +0,0 @@
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { ILanguageModelChatMetadata } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
-import { IToolData, IToolSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
-/**
- * New QuickTree implementation of the tools picker.
- * Uses IQuickTree to provide a true hierarchical tree structure with:
- * - Collapsible nodes for buckets and toolsets
- * - Checkbox state management with parent-child relationships
- * - Special handling for MCP servers (server as bucket, tools as direct children)
- * - Built-in filtering and search capabilities
- *
- * @param accessor - Service accessor for dependency injection
- * @param placeHolder - Placeholder text shown in the picker
- * @param description - Optional description text shown in the picker
- * @param toolsEntries - Optional initial selection state for tools and toolsets
- * @param modelId - Optional model ID to filter tools by supported models
- * @param onUpdate - Optional callback fired when the selection changes
- * @param token - Optional cancellation token to close the picker when cancelled
- * @returns Promise resolving to the final selection map, or undefined if cancelled
- */
-export declare function showToolsPicker(accessor: ServicesAccessor, placeHolder: string, source: string, description?: string, getToolsEntries?: () => ReadonlyMap<IToolSet | IToolData, boolean>, model?: ILanguageModelChatMetadata | undefined, token?: CancellationToken): Promise<ReadonlyMap<IToolSet | IToolData, boolean> | undefined>;