@codingame/monaco-vscode-api 27.0.0 → 28.0.1

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

@@ -3,6 +3,7 @@ import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { ICommandService } from "../../../../platform/commands/common/commands.service.js";
+import { IDialogService } from "../../../../platform/dialogs/common/dialogs.service.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
 import { ILogger } from "../../../../platform/log/common/log.js";
 import { ILoggerService } from "../../../../platform/log/common/log.service.js";
@@ -18,8 +19,9 @@ import { IOutputService } from "../../../services/output/common/output.service.j
 import { ToolProgress } from "../../chat/common/tools/languageModelToolsService.js";
 import { StoredMcpIcons } from "./mcpIcons.js";
 import { IMcpRegistry } from "./mcpRegistryTypes.service.js";
+import { IMcpSandboxService } from "./mcpSandboxService.service.js";
 import { McpServerRequestHandler } from "@codingame/monaco-vscode-mcp-service-override/vscode/vs/workbench/contrib/mcp/common/mcpServerRequestHandler";
-import { IMcpIcons, IMcpPrompt, IMcpResource, IMcpResourceTemplate, IMcpServer, IMcpServerConnection, IMcpServerStartOpts, IMcpTool, IMcpToolCallContext, McpCapability, McpCollectionDefinition, McpCollectionReference, McpConnectionState, McpDefinitionReference, McpServerCacheState, McpServerDefinition, McpToolVisibility } from "./mcpTypes.js";
+import { IMcpIcons, IMcpPotentialSandboxBlock, IMcpPrompt, IMcpResource, IMcpResourceTemplate, IMcpServer, IMcpServerConnection, IMcpServerStartOpts, IMcpTool, IMcpToolCallContext, McpCapability, McpCollectionDefinition, McpCollectionReference, McpConnectionState, McpDefinitionReference, McpServerCacheState, McpServerDefinition, McpToolVisibility } from "./mcpTypes.js";
 import { IMcpElicitationService } from "./mcpTypes.service.js";
 import { IMcpSamplingService } from "./mcpTypes.service.js";
 import { MCP } from "./modelContextProtocol.js";
@@ -137,10 +139,12 @@ export declare class McpServer extends Disposable implements IMcpServer {
     private readonly _telemetryService;
     private readonly _commandService;
     private readonly _instantiationService;
+    private readonly _dialogService;
     private readonly _notificationService;
     private readonly _openerService;
     private readonly _samplingService;
     private readonly _elicitationService;
+    private readonly _mcpSandboxService;
     /** Shared task manager that survives reconnections */
     private readonly _taskManager;
     /**
@@ -169,9 +173,13 @@ export declare class McpServer extends Disposable implements IMcpServer {
     private readonly _loggerId;
     private readonly _logger;
     private _lastModeDebugged;
+    private _isQuietStart;
+    private _isSandboxSuggestionDialogVisible;
+    private _potentialSandboxBlocks;
+    private _potentialSandboxBlockListener;
     /** Count of running tool calls, used to detect if sampling is during an LM call */
     runningToolCalls: Set<IMcpToolCallContext>;
-    constructor(initialCollection: McpCollectionDefinition, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _primitiveCache: McpServerMetadataCache, toolPrefix: string, _mcpRegistry: IMcpRegistry, workspacesService: IWorkspaceContextService, _extensionService: IExtensionService, _loggerService: ILoggerService, _outputService: IOutputService, _telemetryService: ITelemetryService, _commandService: ICommandService, _instantiationService: IInstantiationService, _notificationService: INotificationService, _openerService: IOpenerService, _samplingService: IMcpSamplingService, _elicitationService: IMcpElicitationService, environmentService: IWorkbenchEnvironmentService);
+    constructor(initialCollection: McpCollectionDefinition, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _primitiveCache: McpServerMetadataCache, toolPrefix: string, _mcpRegistry: IMcpRegistry, workspacesService: IWorkspaceContextService, _extensionService: IExtensionService, _loggerService: ILoggerService, _outputService: IOutputService, _telemetryService: ITelemetryService, _commandService: ICommandService, _instantiationService: IInstantiationService, _dialogService: IDialogService, _notificationService: INotificationService, _openerService: IOpenerService, _samplingService: IMcpSamplingService, _elicitationService: IMcpElicitationService, _mcpSandboxService: IMcpSandboxService, environmentService: IWorkbenchEnvironmentService);
     readDefinitions(): IObservable<{
         server: McpServerDefinition | undefined;
         collection: McpCollectionDefinition | undefined;
@@ -181,6 +189,10 @@ export declare class McpServer extends Disposable implements IMcpServer {
     resourceTemplates(token?: CancellationToken): Promise<IMcpResourceTemplate[]>;
     start({ interaction, autoTrustChanges, promptType, debug, errorOnUserInteraction }?: IMcpServerStartOpts): Promise<McpConnectionState>;
     private showInteractiveError;
+    showSandboxConfigSuggestionFromPotentialBlocks(cnx: IMcpServerConnection, potentialBlocks: readonly IMcpPotentialSandboxBlock[]): boolean;
+    private _confirmAndApplySandboxConfigSuggestion;
+    recordPotentialSandboxBlock(block: IMcpPotentialSandboxBlock): void;
+    private _removePotentialSandboxBlocks;
     stop(): Promise<void>;
     /** Waits for any ongoing tools to be refreshed before resolving. */
     awaitToolRefresh(): Promise<void>;

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

@@ -5,7 +5,7 @@ import { CancellationToken, CancellationTokenSource } from '../../../../base/com
 import { Iterable } from '../../../../base/common/iterator.js';
 import { parseTree, findNodeAtOffset, getNodePath } from '../../../../base/common/json.js';
 import { normalizeDriveLetter } from '../../../../base/common/labels.js';
-import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import { LRUCache } from '../../../../base/common/map.js';
 import { Schemas } from '../../../../base/common/network.js';
 import { mapValues } from '../../../../base/common/objects.js';
@@ -16,6 +16,7 @@ import { createURITransformer } from '../../../../base/common/uriTransformer.js'
 import { generateUuid } from '../../../../base/common/uuid.js';
 import { localize } from '../../../../nls.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILoggerService } from '../../../../platform/log/common/log.service.js';
 import '../../../../platform/notification/common/notification.js';
@@ -34,6 +35,7 @@ import { mcpActivationEvent } from './mcpConfiguration.js';
 import { McpDevModeServerAttache } from './mcpDevMode.js';
 import { McpIcons, parseAndValidateMcpIcon } from './mcpIcons.js';
 import { IMcpRegistry } from './mcpRegistryTypes.service.js';
+import { IMcpSandboxService } from './mcpSandboxService.service.js';
 import { McpTaskManager } from './mcpTaskManager.js';
 import { McpConnectionState, McpConnectionFailedError, McpServerCacheState, McpServerStaticToolAvailability, extensionMcpCollectionPrefix, UserInteractionRequiredError, McpServerTransportType, McpToolVisibility, mcpPromptReplaceSpecialChars, McpCapability, McpToolName, MpcResponseError, ElicitationKind, McpResourceURI } from './mcpTypes.js';
 import { IMcpSamplingService, IMcpElicitationService } from './mcpTypes.service.js';
@@ -216,10 +218,12 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         _telemetryService,
         _commandService,
         _instantiationService,
+        _dialogService,
         _notificationService,
         _openerService,
         _samplingService,
         _elicitationService,
+        _mcpSandboxService,
         environmentService
     ) {
         super();
@@ -233,10 +237,12 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         this._telemetryService = _telemetryService;
         this._commandService = _commandService;
         this._instantiationService = _instantiationService;
+        this._dialogService = _dialogService;
         this._notificationService = _notificationService;
         this._openerService = _openerService;
         this._samplingService = _samplingService;
         this._elicitationService = _elicitationService;
+        this._mcpSandboxService = _mcpSandboxService;
         this._taskManager = this._register(( new McpTaskManager()));
         this._connectionSequencer = ( new Sequencer());
         this._connection = this._register(disposableObservableValue(this, undefined));
@@ -271,6 +277,10 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
             return fromServerResult.data?.nonce === currentNonce() ? McpServerCacheState.Live : McpServerCacheState.Outdated;
         });
         this._lastModeDebugged = false;
+        this._isQuietStart = false;
+        this._isSandboxSuggestionDialogVisible = false;
+        this._potentialSandboxBlocks = [];
+        this._potentialSandboxBlockListener = this._register(( new MutableDisposable()));
         this.runningToolCalls = ( new Set());
         this.collection = initialCollection;
         this._fullDefinitions = this._mcpRegistry.getServerDefinition(this.collection, this.definition);
@@ -320,6 +330,10 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 this.resetLiveData();
             }
         }));
+        this._register(autorun(reader => {
+            const cnx = this._connection.read(reader);
+            this._potentialSandboxBlockListener.value = cnx?.onPotentialSandboxBlock(block => this.recordPotentialSandboxBlock(block));
+        }));
         const staticMetadata = derived(reader => {
             const def = this._fullDefinitions.read(reader).server;
             return def && def.cacheNonce !== this._tools.fromCache?.nonce ? def.staticMetadata : undefined;
@@ -403,6 +417,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 }
             }
             let connection = this._connection.get();
+            this._isQuietStart = !!errorOnUserInteraction;
             if (connection && McpConnectionState.canBeStarted(connection.state.get().state)) {
                 connection.dispose();
                 connection = undefined;
@@ -446,6 +461,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                     this.showOutput();
                 }
             }
+            this._potentialSandboxBlocks.length = 0;
             const start = Date.now();
             let state = await connection.start({
                 createMessageRequestHandler: (params, token) => this._samplingService.sample({
@@ -475,9 +491,6 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 state: McpConnectionState.toKindString(state.state),
                 time: Date.now() - start
             });
-            if (state.state === McpConnectionState.Kind.Error) {
-                this.showInteractiveError(connection, state, debug);
-            }
             if (errorOnUserInteraction && state.state === McpConnectionState.Kind.Running) {
                 let disposable;
                 state = await ( new Promise((resolve, reject) => {
@@ -496,6 +509,22 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                     });
                 })).finally(() => disposable.dispose());
             }
+            if (state.state === McpConnectionState.Kind.Error) {
+                let disposable;
+                state = await ( new Promise((resolve, reject) => {
+                    disposable = autorun(reader => {
+                        const cnx = this._connection.read(reader);
+                        const state = cnx?.state.read(reader);
+                        if (cnx && state?.state === McpConnectionState.Kind.Error) {
+                            if (!this._isQuietStart) {
+                                this.showInteractiveError(cnx, state, this._lastModeDebugged);
+                            } else {
+                                reject(( new UserInteractionRequiredError("start")));
+                            }
+                        }
+                    });
+                })).finally(() => disposable.dispose());
+            }
             return state;
         }).finally(() => {
             interaction?.participants.set(this.definition.id, {
@@ -504,6 +533,17 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         });
     }
     showInteractiveError(cnx, error, debug) {
+        if (cnx.definition.sandboxEnabled) {
+            if (!this.showSandboxConfigSuggestionFromPotentialBlocks(cnx, this._potentialSandboxBlocks)) {
+                this._notificationService.warn(( localize(
+                    10455,
+                    "The MCP server {0} could not be started: {1}",
+                    cnx.definition.label,
+                    error.message
+                )));
+            }
+            return;
+        }
         if (error.code === "ENOENT" && cnx.launchDefinition.type === McpServerTransportType.Stdio) {
             let docsLink;
             switch (cnx.launchDefinition.command) {
@@ -521,42 +561,129 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 break;
             }
             const options = [{
-                label: ( localize(10265, "Show Output")),
+                label: ( localize(10456, "Show Output")),
                 run: () => this.showOutput()
             }];
             if (cnx.definition.devMode?.debug?.type === "debugpy" && debug) {
                 this._notificationService.prompt(Severity$1.Error, ( localize(
-                    10266,
+                    10457,
                     "The command \"{0}\" was not found. You can specify the path to debugpy in the `dev.debug.debugpyPath` option.",
                     cnx.launchDefinition.command,
                     cnx.definition.label
                 )), [...options, {
-                    label: ( localize(10267, "View Docs")),
+                    label: ( localize(10458, "View Docs")),
                     run: () => this._openerService.open(( URI.parse("https://aka.ms/vscode-mcp-install/debugpy")))
                 }]);
                 return;
             }
             if (docsLink) {
                 options.push({
-                    label: ( localize(10268, "Install {0}", cnx.launchDefinition.command)),
+                    label: ( localize(10459, "Install {0}", cnx.launchDefinition.command)),
                     run: () => this._openerService.open(( URI.parse(docsLink)))
                 });
             }
             this._notificationService.prompt(Severity$1.Error, ( localize(
-                10269,
+                10460,
                 "The command \"{0}\" needed to run {1} was not found.",
                 cnx.launchDefinition.command,
                 cnx.definition.label
             )), options);
         } else {
             this._notificationService.warn(( localize(
-                10270,
+                10455,
                 "The MCP server {0} could not be started: {1}",
                 cnx.definition.label,
                 error.message
             )));
         }
     }
+    showSandboxConfigSuggestionFromPotentialBlocks(cnx, potentialBlocks) {
+        if (!cnx.definition.sandboxEnabled || !potentialBlocks.length || this._isSandboxSuggestionDialogVisible) {
+            return false;
+        }
+        if (this._isQuietStart) {
+            throw ( new UserInteractionRequiredError("sandbox-suggestion"));
+        }
+        const existingSandboxConfig = this._fullDefinitions.get().collection?.sandbox;
+        const suggestion = this._mcpSandboxService.getSandboxConfigSuggestionMessage(cnx.definition.label, potentialBlocks, existingSandboxConfig);
+        if (!suggestion) {
+            this._removePotentialSandboxBlocks(potentialBlocks);
+            return false;
+        }
+        this._confirmAndApplySandboxConfigSuggestion(cnx, potentialBlocks, suggestion);
+        return true;
+    }
+    _confirmAndApplySandboxConfigSuggestion(cnx, potentialBlocks, suggestion) {
+        const mcpResource = cnx.definition.presentation?.origin?.uri ?? this.collection.presentation?.origin;
+        const configTarget = this._fullDefinitions.get().collection?.configTarget;
+        this._isSandboxSuggestionDialogVisible = true;
+        void this._dialogService.confirm({
+            type: "warning",
+            message: ( localize(
+                10461,
+                "Update sandbox configuration in mcp.json for {0}?",
+                cnx.definition.label
+            )),
+            detail: suggestion.message,
+            primaryButton: ( localize(10462, "Yes")),
+            cancelButton: ( localize(10463, "No"))
+        }).then(async result => {
+            if (!result.confirmed) {
+                return;
+            }
+            if (!mcpResource || configTarget === undefined) {
+                this._notificationService.warn(( localize(
+                    10464,
+                    "Couldn't determine where to update sandbox configuration for {0}.",
+                    cnx.definition.label
+                )));
+                return;
+            }
+            try {
+                const updated = await this._mcpSandboxService.applySandboxConfigSuggestion(
+                    cnx.definition,
+                    mcpResource,
+                    configTarget,
+                    potentialBlocks,
+                    suggestion.sandboxConfig
+                );
+                if (updated) {
+                    this._removePotentialSandboxBlocks(potentialBlocks);
+                    this._notificationService.info(( localize(
+                        10465,
+                        "Updated sandbox configuration for {0} in mcp.json. Restart server.",
+                        cnx.definition.label
+                    )));
+                }
+            } catch (e) {
+                this._notificationService.error(( localize(
+                    10466,
+                    "Failed to update sandbox configuration for {0}: {1}",
+                    cnx.definition.label,
+                    e instanceof Error ? e.message : String(e)
+                )));
+            }
+        }).finally(() => {
+            this._isSandboxSuggestionDialogVisible = false;
+        });
+    }
+    recordPotentialSandboxBlock(block) {
+        this._potentialSandboxBlocks.push(block);
+        if (this._potentialSandboxBlocks.length > 200) {
+            this._potentialSandboxBlocks.splice(0, this._potentialSandboxBlocks.length - 200);
+        }
+        const connection = this._connection.get();
+        if (connection?.state.get().state === McpConnectionState.Kind.Running) {
+            this.showSandboxConfigSuggestionFromPotentialBlocks(connection, this._potentialSandboxBlocks);
+        }
+    }
+    _removePotentialSandboxBlocks(blocks) {
+        if (!blocks.length || !this._potentialSandboxBlocks.length) {
+            return;
+        }
+        const toRemove = ( new Set(blocks));
+        this._potentialSandboxBlocks = this._potentialSandboxBlocks.filter(block => !( toRemove.has(block)));
+    }
     stop() {
         return this._connection.get()?.stop() || Promise.resolve();
     }
@@ -608,6 +735,12 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
             );
             tool.name = tool.name.replace(toolInvalidCharRe, "_");
         }
+        if (tool.inputSchema && !tool.inputSchema.properties) {
+            tool.inputSchema = {
+                ...tool.inputSchema,
+                properties: {}
+            };
+        }
         let diagnostics = [];
         const toolJson = JSON.stringify(tool.inputSchema);
         try {
@@ -633,7 +766,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         const validated = [];
         for (const [i, result] of validations.entries()) {
             if ("error" in result) {
-                error += ( localize(10271, "Tool `{0}` has invalid JSON parameters:", tools[i].name)) + "\n";
+                error += ( localize(10467, "Tool `{0}` has invalid JSON parameters:", tools[i].name)) + "\n";
                 for (const message of result.error) {
                     error += `\t- ${message}\n`;
                 }
@@ -763,7 +896,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         });
     }
 };
-McpServer = McpServer_1 = ( __decorate([( __param(6, IMcpRegistry)), ( __param(7, IWorkspaceContextService)), ( __param(8, IExtensionService)), ( __param(9, ILoggerService)), ( __param(10, IOutputService)), ( __param(11, ITelemetryService)), ( __param(12, ICommandService)), ( __param(13, IInstantiationService)), ( __param(14, INotificationService)), ( __param(15, IOpenerService)), ( __param(16, IMcpSamplingService)), ( __param(17, IMcpElicitationService)), ( __param(18, IWorkbenchEnvironmentService))], McpServer));
+McpServer = McpServer_1 = ( __decorate([( __param(6, IMcpRegistry)), ( __param(7, IWorkspaceContextService)), ( __param(8, IExtensionService)), ( __param(9, ILoggerService)), ( __param(10, IOutputService)), ( __param(11, ITelemetryService)), ( __param(12, ICommandService)), ( __param(13, IInstantiationService)), ( __param(14, IDialogService)), ( __param(15, INotificationService)), ( __param(16, IOpenerService)), ( __param(17, IMcpSamplingService)), ( __param(18, IMcpElicitationService)), ( __param(19, IMcpSandboxService)), ( __param(20, IWorkbenchEnvironmentService))], McpServer));
 class McpPrompt {
     constructor(_server, _definition) {
         this._server = _server;
@@ -909,7 +1042,9 @@ let McpTool = class McpTool {
                     arguments: params,
                     task: shouldUseTask ? {} : undefined,
                     _meta: meta
-                }, token);
+                }, token, progress ? message => progress.report({
+                    message
+                }) : undefined);
                 await this._server.awaitToolRefresh();
                 return result;
             } catch (err) {
@@ -958,7 +1093,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
         notificationService.notify({
             severity: Severity$1.Warning,
             message: ( localize(
-                10272,
+                10468,
                 "MCP server `{0}` has tools with invalid parameters which will be omitted.",
                 serverName
             )),
@@ -968,7 +1103,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
                     enabled: true,
                     id: "mcpBadSchema.show",
                     tooltip: "",
-                    label: ( localize(10273, "Show")),
+                    label: ( localize(10469, "Show")),
                     run: () => {
                         editorService.openEditor({
                             resource: undefined,

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

@@ -1,4 +1,5 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { Event } from "../../../../base/common/event.js";
 import { IMarkdownString } from "../../../../base/common/htmlContent.js";
 import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable, ObservableMap } from "../../../../base/common/observable.js";
@@ -43,6 +44,8 @@ export interface McpCollectionDefinition {
     readonly scope: StorageScope;
     /** Configuration target where configuration related to this server should be stored. */
     readonly configTarget: ConfigurationTarget;
+    /** Root-level sandbox settings from the mcp config file. */
+    readonly sandbox?: IMcpSandboxConfiguration;
     /** Resolves a server definition. If present, always called before a server starts. */
     resolveServerLanch?(definition: McpServerDefinition): Promise<McpServerLaunch | undefined>;
     /** For lazy-loaded collections only: */
@@ -102,8 +105,6 @@ export interface McpServerDefinition {
     readonly staticMetadata?: McpServerStaticMetadata;
     /** Indicates if the sandbox is enabled for this server. */
     readonly sandboxEnabled?: boolean;
-    /** Sandbox configuration to apply for this server. */
-    readonly sandbox?: IMcpSandboxConfiguration;
     readonly presentation?: {
         /** Sort order of the definition. */
         readonly order?: number;
@@ -135,7 +136,6 @@ export declare namespace McpServerDefinition {
         readonly variableReplacement?: McpServerDefinitionVariableReplacement.Serialized;
         readonly staticMetadata?: McpServerStaticMetadata;
         readonly sandboxEnabled?: boolean;
-        readonly sandbox?: IMcpSandboxConfiguration;
     }
     function toSerialized(def: McpServerDefinition): McpServerDefinition.Serialized;
     function fromSerialized(def: McpServerDefinition.Serialized): McpServerDefinition;
@@ -392,6 +392,7 @@ export interface McpServerTransportStdio {
     readonly args: readonly string[];
     readonly env: Record<string, string | number | null>;
     readonly envFile: string | undefined;
+    readonly sandbox: IMcpSandboxConfiguration | undefined;
 }
 export interface McpServerTransportHTTPAuthentication {
     /**
@@ -434,6 +435,7 @@ export declare namespace McpServerLaunch {
         args: readonly string[];
         env: Record<string, string | number | null>;
         envFile: string | undefined;
+        sandbox: IMcpSandboxConfiguration | undefined;
     };
     function toSerialized(launch: McpServerLaunch): McpServerLaunch.Serialized;
     function fromSerialized(launch: McpServerLaunch.Serialized): McpServerLaunch;
@@ -444,10 +446,17 @@ export declare namespace McpServerLaunch {
  * stopped, and restarted. Once started and in a running state, it will
  * eventually build a {@link IMcpServerConnection.handler}.
  */
+export interface IMcpPotentialSandboxBlock {
+    readonly kind: "network" | "filesystem";
+    readonly message: string;
+    readonly host?: string;
+    readonly path?: string;
+}
 export interface IMcpServerConnection extends IDisposable {
     readonly definition: McpServerDefinition;
     readonly state: IObservable<McpConnectionState>;
     readonly handler: IObservable<McpServerRequestHandler | undefined>;
+    readonly onPotentialSandboxBlock: Event<IMcpPotentialSandboxBlock>;
     /**
      * Resolved launch definition. Might not match the `definition.launch` due to
      * resolution logic in extension-provided MCPs.

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

@@ -1,10 +1,10 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { equals } from '../../../../base/common/arrays.js';
+import { equals as equals$1 } from '../../../../base/common/arrays.js';
 import { assertNever } from '../../../../base/common/assert.js';
 import { encodeHex, VSBuffer, decodeHex } from '../../../../base/common/buffer.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { equals as equals$1 } from '../../../../base/common/objects.js';
+import { equals } from '../../../../base/common/objects.js';
 import '../../../../base/common/observableInternal/index.js';
 import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
@@ -31,10 +31,10 @@ var McpCollectionSortOrder;
 })(McpCollectionSortOrder || (McpCollectionSortOrder = {}));
 var McpCollectionDefinition;
 (function(McpCollectionDefinition) {
-    function equals(a, b) {
-        return a.id === b.id && a.remoteAuthority === b.remoteAuthority && a.label === b.label && a.trustBehavior === b.trustBehavior;
+    function equals$1(a, b) {
+        return a.id === b.id && a.remoteAuthority === b.remoteAuthority && a.label === b.label && a.trustBehavior === b.trustBehavior && equals(a.sandbox, b.sandbox);
     }
-    McpCollectionDefinition.equals = equals;
+    McpCollectionDefinition.equals = equals$1;
 })(McpCollectionDefinition || (McpCollectionDefinition = {}));
 var McpServerStaticToolAvailability;
 (function(McpServerStaticToolAvailability) {
@@ -55,13 +55,12 @@ var McpServerDefinition;
             staticMetadata: def.staticMetadata,
             launch: McpServerLaunch.fromSerialized(def.launch),
             sandboxEnabled: def.sandboxEnabled,
-            sandbox: def.sandboxEnabled ? def.sandbox : undefined,
             variableReplacement: def.variableReplacement ? McpServerDefinitionVariableReplacement.fromSerialized(def.variableReplacement) : undefined
         };
     }
     McpServerDefinition.fromSerialized = fromSerialized;
     function equals$2(a, b) {
-        return a.id === b.id && a.label === b.label && a.cacheNonce === b.cacheNonce && equals(a.roots, b.roots, (a, b) => ( a.toString()) === ( b.toString())) && equals$1(a.launch, b.launch) && equals$1(a.presentation, b.presentation) && equals$1(a.variableReplacement, b.variableReplacement) && equals$1(a.devMode, b.devMode) && a.sandboxEnabled === b.sandboxEnabled && equals$1(a.sandbox, b.sandbox);
+        return a.id === b.id && a.label === b.label && a.cacheNonce === b.cacheNonce && equals$1(a.roots, b.roots, (a, b) => ( a.toString()) === ( b.toString())) && equals(a.launch, b.launch) && equals(a.presentation, b.presentation) && equals(a.variableReplacement, b.variableReplacement) && equals(a.devMode, b.devMode) && a.sandboxEnabled === b.sandboxEnabled;
     }
     McpServerDefinition.equals = equals$2;
 })(McpServerDefinition || (McpServerDefinition = {}));
@@ -159,7 +158,8 @@ var McpServerLaunch;
                 command: launch.command,
                 args: launch.args,
                 env: launch.env,
-                envFile: launch.envFile
+                envFile: launch.envFile,
+                sandbox: launch.sandbox
             };
         }
     }
@@ -182,13 +182,13 @@ var McpConnectionState;
     McpConnectionState.toString = s => {
         switch (s.state) {
         case Kind.Stopped:
-            return localize(10277, "Stopped");
+            return localize(10473, "Stopped");
         case Kind.Starting:
-            return localize(10278, "Starting");
+            return localize(10474, "Starting");
         case Kind.Running:
-            return localize(10279, "Running");
+            return localize(10475, "Running");
         case Kind.Error:
-            return localize(10280, "Error {0}", s.message);
+            return localize(10476, "Error {0}", s.message);
         default:
             assertNever();
         }

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput.js

@@ -106,7 +106,7 @@ let MergeEditorInput = class MergeEditorInput extends AbstractTextResourceEditor
         return capabilities;
     }
     getName() {
-        return localize(10326, "Merging: {0}", super.getName());
+        return localize(10522, "Merging: {0}", super.getName());
     }
     async resolve() {
         if (!this._inputModel) {
@@ -190,13 +190,13 @@ MergeEditorInput = MergeEditorInput_1 = ( __decorate([( __param(4, IInstantiatio
 function alertFocusedEditor(editor) {
     switch (editor) {
     case "input1":
-        alert(( localize(10327, "Incoming, Left Input")));
+        alert(( localize(10523, "Incoming, Left Input")));
         break;
     case "input2":
-        alert(( localize(10328, "Current, Right Input")));
+        alert(( localize(10524, "Current, Right Input")));
         break;
     case "result":
-        alert(( localize(10329, "Merge Result")));
+        alert(( localize(10525, "Merge Result")));
         break;
     }
 }