@codingame/monaco-vscode-mcp-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/mcp/common/mcpLanguageModelToolContribution.js

@@ -25,6 +25,7 @@ import { McpToolVisibility, McpToolResourceLinkMimeType, McpResourceURI } from '
 import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { mcpServerToSourceData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypesUtils';
 import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { McpServer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpServer';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 let McpLanguageModelToolContribution = class McpLanguageModelToolContribution extends Disposable {
@@ -66,7 +67,7 @@ let McpLanguageModelToolContribution = class McpLanguageModelToolContribution ex
                     const toolSet = store.add(
                         this._toolsService.createToolSet(source, server.definition.id, referenceName, {
                             icon: Codicon.mcp,
-                            description: ( localize(9533, "{0}: All Tools", server.definition.label))
+                            description: ( localize(10423, "{0}: All Tools", server.definition.label))
                         })
                     );
                     return {
@@ -181,30 +182,37 @@ let McpToolImplementation = class McpToolImplementation {
     async prepareToolInvocation(context) {
         const tool = this._tool;
         const server = this._server;
+        const sandboxEnabled = await McpServer.callOn(server, async (_handler, connection) => {
+            return connection.definition.sandboxEnabled;
+        });
+        const isSandboxedServer = sandboxEnabled === true;
         const mcpToolWarning = ( localize(
-            9534,
+            10424,
             "Note that MCP servers or malicious conversation content may attempt to misuse '{0}' through tools.",
             this._productService.nameShort
         ));
         const title = tool.definition.annotations?.title || tool.definition.title || ("`" + tool.definition.name + "`");
-        const confirm = {};
-        if (!tool.definition.annotations?.readOnlyHint) {
-            confirm.title = ( new MarkdownString(( localize(9535, "Run {0}", title))));
-            confirm.message = ( new MarkdownString(tool.definition.description, {
-                supportThemeIcons: true
-            }));
-            confirm.disclaimer = mcpToolWarning;
-            confirm.allowAutoConfirm = true;
-        }
-        if (tool.definition.annotations?.openWorldHint) {
-            confirm.confirmResults = true;
+        let confirm;
+        if (!isSandboxedServer) {
+            confirm = {};
+            if (!tool.definition.annotations?.readOnlyHint) {
+                confirm.title = ( new MarkdownString(( localize(10425, "Run {0}", title))));
+                confirm.message = ( new MarkdownString(tool.definition.description, {
+                    supportThemeIcons: true
+                }));
+                confirm.disclaimer = mcpToolWarning;
+                confirm.allowAutoConfirm = true;
+            }
+            if (tool.definition.annotations?.openWorldHint) {
+                confirm.confirmResults = true;
+            }
         }
         const mcpUiEnabled = this._configurationService.getValue(mcpAppsEnabledConfig);
         return {
             confirmationMessages: confirm,
-            invocationMessage: ( new MarkdownString(( localize(9536, "Running {0}", title)))),
-            pastTenseMessage: ( new MarkdownString(( localize(9537, "Ran {0} ", title)))),
-            originMessage: ( localize(9538, "{0} (MCP Server)", server.definition.label)),
+            invocationMessage: ( new MarkdownString(( localize(10426, "Running {0}", title)))),
+            pastTenseMessage: ( new MarkdownString(( localize(10427, "Ran {0} ", title)))),
+            originMessage: ( localize(10428, "{0} (MCP Server)", server.definition.label)),
             toolSpecificData: {
                 kind: "input",
                 rawInput: context.parameters,
@@ -222,7 +230,7 @@ let McpToolImplementation = class McpToolImplementation {
         };
         const callResult = await this._tool.callWithProgress(invocation.parameters, progress, {
             chatRequestId: invocation.chatRequestId,
-            chatSessionId: invocation.context?.sessionId
+            chatSessionResource: invocation.context?.sessionResource
         }, token);
         const details = {
             input: JSON.stringify(invocation.parameters, undefined, 2),

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistry.d.ts

@@ -17,6 +17,7 @@ import { IResolvedValue } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IMcpHostDelegate, IMcpResolveConnectionOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
 import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service";
 import { IMcpServerConnection, LazyCollectionState, McpCollectionDefinition, McpDefinitionReference, McpServerDefinition } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 export declare class McpRegistry extends Disposable implements IMcpRegistry {
     private readonly _instantiationService;
@@ -27,6 +28,7 @@ export declare class McpRegistry extends Disposable implements IMcpRegistry {
     private readonly _quickInputService;
     private readonly _labelService;
     private readonly _logService;
+    private readonly _mcpSandboxService;
     private readonly _workspaceTrustManagementService;
     private readonly _workspaceTrustRequestService;
     readonly _serviceBrand: undefined;
@@ -44,7 +46,7 @@ export declare class McpRegistry extends Disposable implements IMcpRegistry {
     get delegates(): IObservable<readonly IMcpHostDelegate[]>;
     private readonly _onDidChangeInputs;
     readonly onDidChangeInputs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
-    constructor(_instantiationService: IInstantiationService, _configurationResolverService: IConfigurationResolverService, _dialogService: IDialogService, _notificationService: INotificationService, _editorService: IEditorService, configurationService: IConfigurationService, _quickInputService: IQuickInputService, _labelService: ILabelService, _logService: ILogService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _workspaceTrustRequestService: IWorkspaceTrustRequestService);
+    constructor(_instantiationService: IInstantiationService, _configurationResolverService: IConfigurationResolverService, _dialogService: IDialogService, _notificationService: INotificationService, _editorService: IEditorService, configurationService: IConfigurationService, _quickInputService: IQuickInputService, _labelService: ILabelService, _logService: ILogService, _mcpSandboxService: IMcpSandboxService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _workspaceTrustRequestService: IWorkspaceTrustRequestService);
     registerDelegate(delegate: IMcpHostDelegate): IDisposable;
     registerCollection(collection: McpCollectionDefinition): IDisposable;
     getServerDefinition(collectionRef: McpDefinitionReference, definitionRef: McpDefinitionReference): IObservable<{

package/vscode/src/vs/workbench/contrib/mcp/common/mcpRegistry.js

@@ -31,6 +31,7 @@ import { AUX_WINDOW_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workben
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IMcpDevModeDebugging } from './mcpDevMode.service.js';
 import { McpRegistryInputStorage } from './mcpRegistryInputStorage.js';
+import { IMcpSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service';
 import { McpServerConnection } from './mcpServerConnection.js';
 import { LazyCollectionState, UserInteractionRequiredError, McpServerTrust, McpStartServerInteraction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
@@ -53,6 +54,7 @@ let McpRegistry = class McpRegistry extends Disposable {
         _quickInputService,
         _labelService,
         _logService,
+        _mcpSandboxService,
         _workspaceTrustManagementService,
         _workspaceTrustRequestService
     ) {
@@ -65,6 +67,7 @@ let McpRegistry = class McpRegistry extends Disposable {
         this._quickInputService = _quickInputService;
         this._labelService = _labelService;
         this._logService = _logService;
+        this._mcpSandboxService = _mcpSandboxService;
         this._workspaceTrustManagementService = _workspaceTrustManagementService;
         this._workspaceTrustRequestService = _workspaceTrustRequestService;
         this._collections = observableValue("collections", []);
@@ -224,7 +227,7 @@ let McpRegistry = class McpRegistry extends Disposable {
             if (errorOnUserInteraction) {
                 throw ( new UserInteractionRequiredError("workspaceTrust"));
             } else if (!(await this._workspaceTrustRequestService.requestWorkspaceTrust({
-                message: ( localize(9539, "This MCP server definition is defined in your workspace files."))
+                message: ( localize(10429, "This MCP server definition is defined in your workspace files."))
             }))) {
                 return false;
             }
@@ -302,7 +305,7 @@ let McpRegistry = class McpRegistry extends Disposable {
             const originURI = r.definition.presentation?.origin?.uri || r.collection.presentation?.origin;
             let labelWithOrigin = originURI ? `[\`${r.definition.label}\`](${originURI})` : "`" + r.definition.label + "`";
             if (r.collection.source instanceof ExtensionIdentifier) {
-                labelWithOrigin += ` (${( localize(9540, "from {0}", r.collection.source.value))})`;
+                labelWithOrigin += ` (${( localize(10430, "from {0}", r.collection.source.value))})`;
             }
             return labelWithOrigin;
         }
@@ -312,12 +315,12 @@ let McpRegistry = class McpRegistry extends Disposable {
             const {
                 result
             } = await this._dialogService.prompt({
-                message: ( localize(9541, "Trust and run MCP server {0}?", def.definition.label)),
+                message: ( localize(10431, "Trust and run MCP server {0}?", def.definition.label)),
                 custom: {
                     icon: Codicon.shield,
                     markdownDetails: [{
                         markdown: ( new MarkdownString(( localize(
-                            9542,
+                            10432,
                             "The MCP server {0} was updated. MCP servers may add context to your chat session and lead to unexpected behavior. Do you want to trust and run this server?",
                             labelFor(def)
                         )))),
@@ -330,10 +333,10 @@ let McpRegistry = class McpRegistry extends Disposable {
                     }]
                 },
                 buttons: [{
-                    label: ( localize(9543, "Trust")),
+                    label: ( localize(10433, "Trust")),
                     run: () => true
                 }, {
-                    label: ( localize(9544, "Do not trust")),
+                    label: ( localize(10434, "Do not trust")),
                     run: () => false
                 }]
             });
@@ -343,12 +346,12 @@ let McpRegistry = class McpRegistry extends Disposable {
         const {
             result
         } = await this._dialogService.prompt({
-            message: ( localize(9545, "Trust and run {0} MCP servers?", definitions.length)),
+            message: ( localize(10435, "Trust and run {0} MCP servers?", definitions.length)),
             custom: {
                 icon: Codicon.shield,
                 markdownDetails: [{
                     markdown: ( new MarkdownString(( localize(
-                        9546,
+                        10436,
                         "Several updated MCP servers were discovered:\n\n{0}\n\n MCP servers may add context to your chat session and lead to unexpected behavior. Do you want to trust and run these server?",
                         list
                     )))),
@@ -361,13 +364,13 @@ let McpRegistry = class McpRegistry extends Disposable {
                 }]
             },
             buttons: [{
-                label: ( localize(9543, "Trust")),
+                label: ( localize(10433, "Trust")),
                 run: () => "all"
             }, {
-                label: ( localize(9547, "Pick Trusted")),
+                label: ( localize(10437, "Pick Trusted")),
                 run: () => "pick"
             }, {
-                label: ( localize(9544, "Do not trust")),
+                label: ( localize(10434, "Do not trust")),
                 run: () => "none"
             }]
         });
@@ -423,13 +426,13 @@ let McpRegistry = class McpRegistry extends Disposable {
             }
         }));
         return ( new Promise(resolve => {
-            picker.onDidAccept(() => {
+            store.add(picker.onDidAccept(() => {
                 resolve(( picker.selectedItems.map(item => item.definitonId)));
                 picker.hide();
-            });
-            picker.onDidHide(() => {
+            }));
+            store.add(picker.onDidHide(() => {
                 resolve(undefined);
-            });
+            }));
             picker.show();
         })).finally(() => store.dispose());
     }
@@ -518,20 +521,26 @@ let McpRegistry = class McpRegistry extends Disposable {
                     accessor => accessor.get(IMcpDevModeDebugging).transform(definition, launch)
                 );
             }
+            launch = await this._mcpSandboxService.launchInSandboxIfEnabled(
+                definition,
+                launch,
+                collection.remoteAuthority ?? undefined,
+                collection.configTarget
+            );
         } catch (e) {
             if (e instanceof UserInteractionRequiredError) {
                 throw e;
             }
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( localize(9548, "Error starting {0}: {1}", definition.label, String(e))),
+                message: ( localize(10438, "Error starting {0}: {1}", definition.label, String(e))),
                 actions: {
                     primary: collection.presentation?.origin && [{
                         id: "mcp.launchError.openConfig",
                         class: undefined,
                         enabled: true,
                         tooltip: "",
-                        label: ( localize(9549, "Open Configuration")),
+                        label: ( localize(10439, "Open Configuration")),
                         run: () => this._editorService.openEditor({
                             resource: collection.presentation.origin,
                             options: {
@@ -555,6 +564,6 @@ let McpRegistry = class McpRegistry extends Disposable {
         );
     }
 };
-McpRegistry = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationResolverService)), ( __param(2, IDialogService)), ( __param(3, INotificationService)), ( __param(4, IEditorService)), ( __param(5, IConfigurationService)), ( __param(6, IQuickInputService)), ( __param(7, ILabelService)), ( __param(8, ILogService)), ( __param(9, IWorkspaceTrustManagementService)), ( __param(10, IWorkspaceTrustRequestService))], McpRegistry));
+McpRegistry = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationResolverService)), ( __param(2, IDialogService)), ( __param(3, INotificationService)), ( __param(4, IEditorService)), ( __param(5, IConfigurationService)), ( __param(6, IQuickInputService)), ( __param(7, ILabelService)), ( __param(8, ILogService)), ( __param(9, IMcpSandboxService)), ( __param(10, IWorkspaceTrustManagementService)), ( __param(11, IWorkspaceTrustRequestService))], McpRegistry));
 
 export { McpRegistry };

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingLog.js

@@ -41,7 +41,7 @@ let McpSamplingLog = class McpSamplingLog extends Disposable {
         }
         const parts = [];
         const total = record.bins.reduce((sum, value) => sum + value, 0);
-        parts.push(( localize(9550, "{0} total requests in the last 7 days.", total)));
+        parts.push(( localize(10440, "{0} total requests in the last 7 days.", total)));
         parts.push(this._formatRecentRequests(record));
         return parts.join("\n");
     }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingService.d.ts

@@ -32,6 +32,7 @@ export declare class McpSamplingService extends Disposable implements IMcpSampli
      * a reason why no model could be selected.
      */
     private _getMatchingModelInner;
+    private _getDefaultModels;
     private _configKey;
     getConfig(server: IMcpServer): IMcpServerSamplingConfiguration;
     /**

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSamplingService.js

@@ -13,11 +13,10 @@ import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform
 import { ConfigurationTarget, getConfigValueInTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
-import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
 import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
-import { ChatConfiguration, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { McpCommandIds } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
@@ -85,7 +84,7 @@ let McpSamplingService = class McpSamplingService extends Disposable {
             });
         }
         const model = await this._modelSequencer.queue(() => this._getMatchingModel(opts));
-        const response = await this._languageModelsService.sendChatRequest(model, ( new ExtensionIdentifier("core")), messages, {}, token);
+        const response = await this._languageModelsService.sendChatRequest(model, undefined, messages, {}, token);
         let responseText = "";
         const streaming = (async () => {
             for await (const part of response.stream) {
@@ -132,11 +131,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                9551,
+                10441,
                 "Allow MCP tools from \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                9552,
+                10442,
                 "The MCP server \"{0}\" has issued a request to make a language model call. Do you want to allow it to make requests during chat?",
                 opts.server.definition.label
             )), this.allowButtons(opts.server, "allowedDuringChat"));
@@ -150,11 +149,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                9553,
+                10443,
                 "Allow MCP server \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                9554,
+                10444,
                 "The MCP server \"{0}\" has issued a request to make a language model call. Do you want to allow it to make requests, outside of tool calls during chat?",
                 opts.server.definition.label
             )), this.allowButtons(opts.server, "allowedOutsideChat"));
@@ -166,12 +165,12 @@ let McpSamplingService = class McpSamplingService extends Disposable {
             throw McpError.notAllowed();
         } else if (model === ModelMatch.NoMatchingModel) {
             const newlyPickedModels = opts.isDuringToolCall ? await this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server) : await this._notify(( localize(
-                9555,
+                10445,
                 "MCP server \"{0}\" triggered a language model request, but it has no allowlisted models.",
                 opts.server.definition.label
             )), {
-                [( localize(9556, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
-                [( localize(9557, "Cancel"))]: () => Promise.resolve(undefined)
+                [( localize(10446, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
+                [( localize(10447, "Cancel"))]: () => Promise.resolve(undefined)
             });
             if (newlyPickedModels) {
                 return this._getMatchingModel(opts);
@@ -182,19 +181,19 @@ let McpSamplingService = class McpSamplingService extends Disposable {
     }
     allowButtons(server, key) {
         return {
-            [( localize(9558, "Allow in this Session"))]: async () => {
+            [( localize(10448, "Allow in this Session"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, true);
                 return true;
             },
-            [( localize(9559, "Always"))]: async () => {
+            [( localize(10449, "Always"))]: async () => {
                 await this.updateConfig(server, c => c[key] = true);
                 return true;
             },
-            [( localize(9560, "Not Now"))]: async () => {
+            [( localize(10450, "Not Now"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, false);
                 return false;
             },
-            [( localize(9561, "Never"))]: async () => {
+            [( localize(10451, "Never"))]: async () => {
                 await this.updateConfig(server, c => c[key] = false);
                 return false;
             }
@@ -232,10 +231,7 @@ let McpSamplingService = class McpSamplingService extends Disposable {
         } else if (!isDuringToolCall && !config.allowedOutsideChat && !( this._sessionSets.allowedOutsideChat.has(server.definition.id))) {
             return config.allowedOutsideChat === undefined ? ModelMatch.UnsureAllowedOutsideChat : ModelMatch.NotAllowed;
         }
-        const foundModelIdsDeep = config.allowedModels?.filter(m => !!this._languageModelsService.lookupLanguageModel(m)) || this._languageModelsService.getLanguageModelIds().filter(
-            m => this._languageModelsService.lookupLanguageModel(m)?.isDefaultForLocation[ChatAgentLocation.Chat]
-        );
-        const foundModelIds = foundModelIdsDeep.flat().sort((a, b) => b.length - a.length);
+        const foundModelIds = config.allowedModels?.filter(m => !!this._languageModelsService.lookupLanguageModel(m)) || this._getDefaultModels();
         if (!foundModelIds.length) {
             return ModelMatch.NoMatchingModel;
         }
@@ -250,6 +246,20 @@ let McpSamplingService = class McpSamplingService extends Disposable {
         }
         return foundModelIds[0];
     }
+    _getDefaultModels() {
+        const candidates = ( this._languageModelsService.getLanguageModelIds().map(m => {
+            const model = this._languageModelsService.lookupLanguageModel(m);
+            return model && !model.multiplierNumeric && !model.targetChatSessionType ? {
+                model,
+                id: m
+            } : undefined;
+        })).filter(isDefined);
+        const someDefault = candidates.findIndex(c => ( ( Object.values(c.model.isDefaultForLocation)).some(Boolean)));
+        if (someDefault !== -1) {
+            [candidates[0], candidates[someDefault]] = [candidates[someDefault], candidates[0]];
+        }
+        return ( candidates.map(c => c.id));
+    }
     _configKey(server) {
         return `${server.collection.label}: ${server.definition.label}`;
     }

package/vscode/src/vs/workbench/contrib/mcp/common/mcpSandboxService.d.ts

@@ -0,0 +1,47 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IMcpResourceScannerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpResourceScannerService.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IMcpSandboxConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
+import { IMcpPotentialSandboxBlock, McpServerDefinition, McpServerLaunch } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpSandboxService.service";
+export type SandboxConfigSuggestionResult = {
+    message: string;
+    sandboxConfig: IMcpSandboxConfiguration;
+};
+export declare class McpSandboxService extends Disposable implements IMcpSandboxService {
+    private readonly _fileService;
+    private readonly _environmentService;
+    private readonly _logService;
+    private readonly _mcpResourceScannerService;
+    private readonly _remoteAgentService;
+    readonly _serviceBrand: undefined;
+    private _sandboxSettingsId;
+    private _remoteEnvDetailsPromise;
+    private readonly _defaultAllowedDomains;
+    private _sandboxConfigPerConfigurationTarget;
+    constructor(_fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _mcpResourceScannerService: IMcpResourceScannerService, _remoteAgentService: IRemoteAgentService);
+    isEnabled(serverDef: McpServerDefinition, remoteAuthority?: string): Promise<boolean>;
+    launchInSandboxIfEnabled(serverDef: McpServerDefinition, launch: McpServerLaunch, remoteAuthority: string | undefined, configTarget: ConfigurationTarget): Promise<McpServerLaunch>;
+    getSandboxConfigSuggestionMessage(serverLabel: string, potentialBlocks: readonly IMcpPotentialSandboxBlock[], existingSandboxConfig?: IMcpSandboxConfiguration): SandboxConfigSuggestionResult | undefined;
+    applySandboxConfigSuggestion(serverDef: McpServerDefinition, mcpResource: URI, configTarget: ConfigurationTarget, potentialBlocks: readonly IMcpPotentialSandboxBlock[], suggestedSandboxConfig?: IMcpSandboxConfiguration): Promise<boolean>;
+    private _getSandboxConfigSuggestions;
+    private _toMcpResourceTarget;
+    private _resolveSandboxLaunchDetails;
+    private _getExecPath;
+    private _getSandboxEnvVariables;
+    private _getSandboxCommandArgs;
+    private _getRemoteEnv;
+    private _getOperatingSystem;
+    private _getAppRoot;
+    private _getTempDir;
+    private _updateSandboxConfig;
+    private _withDefaultSandboxConfig;
+    private _getDefaultAllowWrite;
+    private _pathJoin;
+    private _getPathDelimiter;
+}