@codingame/monaco-vscode-mcp-service-override 31.0.0 → 32.0.0

package/vscode/src/vs/workbench/contrib/mcp/browser/media/mcpServerEditor.css

@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.mcp-server-editor {
+	.configuration-content {
+		padding: 20px;
+		box-sizing: border-box;
+	}
+
+	.config-section {
+		margin-bottom: 15px;
+		display: flex;
+		align-items: flex-start;
+	}
+
+	.config-label {
+		font-weight: 600;
+		min-width: 80px;
+		margin-right: 15px;
+	}
+
+	.config-value {
+		word-break: break-all;
+	}
+
+	.config-value .env-entry {
+		display: block;
+	}
+
+	.no-config {
+		color: var(--vscode-descriptionForeground);
+		font-style: italic;
+		padding: 20px;
+	}
+
+	.manifest-content {
+		padding: 20px;
+		box-sizing: border-box;
+
+		.manifest-section {
+			margin-bottom: 20px;
+
+			.manifest-section-title {
+				font-size: 26px;
+				display: inline-block;
+				margin: 0px;
+				font-weight: 600;
+				height: 100%;
+				box-sizing: border-box;
+				padding: 10px;
+				padding-left: 0px;
+				flex: 1;
+				position: relative;
+				overflow: hidden;
+				text-overflow: ellipsis;
+			}
+		}
+
+		.package-section {
+
+			margin-top: 10px;
+
+			.package-section-title {
+				margin-bottom: 5px;
+				font-size: 1.4em;
+				font-weight: 600;
+				border-bottom: 1px solid var(--vscode-panelSection-border);
+				padding: 5px;
+			}
+
+			.package-details {
+				padding-left: 10px;
+				.package-detail {
+					display: grid;
+					grid-template-columns: 200px 1fr;
+					gap: 12px;
+					align-items: start;
+					padding: 8px 0px;
+				}
+
+				.package-separator {
+					margin-top: 10px;
+					border-bottom: 1px solid var(--vscode-panelSection-border);
+				}
+			}
+		}
+
+
+		.no-manifest {
+			font-style: italic;
+			padding: 20px;
+		}
+	}
+
+
+}

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/extensionMcpDiscovery.js

@@ -13,7 +13,7 @@ import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbe
 import { ExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { mcpContributionPoint, mcpActivationEvent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { McpServerDefinition, extensionPrefixedIdentifier, McpServerTrust } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { McpServerDefinition, extensionPrefixedIdentifier, McpCollectionSortOrder, McpServerTrust } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
 var ExtensionMcpDiscovery_1;
@@ -102,6 +102,7 @@ let ExtensionMcpDiscovery = ExtensionMcpDiscovery_1 = class ExtensionMcpDiscover
             trustBehavior: McpServerTrust.Kind.Trusted,
             scope: StorageScope.WORKSPACE,
             configTarget: ConfigurationTarget.USER,
+            order: McpCollectionSortOrder.Extension,
             serverDefinitions: observableValue(this, serverDefs?.map(McpServerDefinition.fromSerialized) || []),
             lazy: {
                 isCached: !!serverDefs,
@@ -141,20 +142,20 @@ let ExtensionMcpDiscovery = ExtensionMcpDiscovery_1 = class ExtensionMcpDiscover
     }
     static _validate(user) {
         if (!Array.isArray(user.value)) {
-            user.collector.error(( localize(10819, "Expected an array of MCP collections")));
+            user.collector.error(( localize(11121, "Expected an array of MCP collections")));
             return false;
         }
         for (const contribution of user.value) {
             if (typeof contribution.id !== "string" || isFalsyOrWhitespace(contribution.id)) {
-                user.collector.error(( localize(10820, "Expected 'id' to be a non-empty string.")));
+                user.collector.error(( localize(11122, "Expected 'id' to be a non-empty string.")));
                 return false;
             }
             if (typeof contribution.label !== "string" || isFalsyOrWhitespace(contribution.label)) {
-                user.collector.error(( localize(10821, "Expected 'label' to be a non-empty string.")));
+                user.collector.error(( localize(11123, "Expected 'label' to be a non-empty string.")));
                 return false;
             }
             if (contribution.when !== undefined && (typeof contribution.when !== "string" || isFalsyOrWhitespace(contribution.when))) {
-                user.collector.error(( localize(10822, "Expected 'when' to be a non-empty string.")));
+                user.collector.error(( localize(11124, "Expected 'when' to be a non-empty string.")));
                 return false;
             }
         }

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/installedMcpServersDiscovery.js

@@ -13,7 +13,7 @@ import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/st
 import { getMcpServerMapping } from '../mcpConfigFileUtils.js';
 import { mcpConfigurationSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { McpServerTransportType, McpServerLaunch, McpServerTrust, McpCollectionDefinition, McpServerDefinition } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { McpServerTransportType, McpServerLaunch, McpServerTrust, McpCollectionSortOrder, McpCollectionDefinition, McpServerDefinition } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
@@ -121,8 +121,8 @@ let InstalledMcpServersDiscovery = class InstalledMcpServersDiscovery extends Di
                 const newCollection = {
                     id,
                     label: mcpConfigPath?.label ?? "",
+                    order: mcpConfigPath?.order ?? McpCollectionSortOrder.User,
                     presentation: {
-                        order: serverDefinitions[0]?.presentation?.order,
                         origin: mcpConfigPath?.uri
                     },
                     remoteAuthority: mcpConfigPath?.remoteAuthority ?? null,

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/nativeMcpDiscoveryAbstract.js

@@ -86,7 +86,7 @@ let NativeFilesystemMcpDiscovery = class NativeFilesystemMcpDiscovery extends Fi
         this.suffix = "";
         if (remoteAuthority) {
             this.suffix = " " + ( localize(
-                10823,
+                11125,
                 " on {0}",
                 labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority)
             ));
@@ -120,9 +120,9 @@ let NativeFilesystemMcpDiscovery = class NativeFilesystemMcpDiscovery extends Fi
                 scope: StorageScope.PROFILE,
                 trustBehavior: McpServerTrust.Kind.TrustedOnNonce,
                 serverDefinitions: observableValue(this, []),
+                order: adapter.order + (adapter.remoteAuthority ? McpCollectionSortOrder.RemoteBoost : 0),
                 presentation: {
-                    origin: file,
-                    order: adapter.order + (adapter.remoteAuthority ? McpCollectionSortOrder.RemoteBoost : 0)
+                    origin: file
                 }
             };
             this._register(this.watchFile(

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/pluginMcpDiscovery.js

@@ -60,9 +60,9 @@ let PluginMcpDiscovery = class PluginMcpDiscovery extends Disposable {
             scope: StorageScope.PROFILE,
             trustBehavior: McpServerTrust.Kind.Trusted,
             serverDefinitions: ( plugin.mcpServerDefinitions.map(defs => ( defs.map(d => this._toServerDefinition(collectionId, d))).filter(isDefined))),
+            order: McpCollectionSortOrder.Plugin,
             presentation: {
-                origin: manifestURI,
-                order: McpCollectionSortOrder.Plugin
+                origin: manifestURI
             }
         });
     }

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

@@ -0,0 +1,21 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpDiscovery } from "./mcpDiscovery.js";
+/**
+ * Discovers MCP servers defined in `.mcp.json` files at workspace folder roots.
+ * Uses the Claude-style format: `{ "mcpServers": { ... } }`.
+ */
+export declare class WorkspaceDotMcpDiscovery extends Disposable implements IMcpDiscovery {
+    private readonly _fileService;
+    private readonly _workspaceContextService;
+    private readonly _mcpRegistry;
+    private readonly _remoteAgentService;
+    readonly fromGallery = false;
+    private readonly _collections;
+    constructor(_fileService: IFileService, _workspaceContextService: IWorkspaceContextService, _mcpRegistry: IMcpRegistry, _remoteAgentService: IRemoteAgentService);
+    start(): void;
+    private _watchFolder;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/workspaceDotMcpDiscovery.js

@@ -0,0 +1,92 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, DisposableMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpCollectionSortOrder, McpServerTrust } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { claudeConfigToServerDefinition } from './nativeMcpDiscoveryAdapters.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+let WorkspaceDotMcpDiscovery = class WorkspaceDotMcpDiscovery extends Disposable {
+    constructor(_fileService, _workspaceContextService, _mcpRegistry, _remoteAgentService) {
+        super();
+        this._fileService = _fileService;
+        this._workspaceContextService = _workspaceContextService;
+        this._mcpRegistry = _mcpRegistry;
+        this._remoteAgentService = _remoteAgentService;
+        this.fromGallery = false;
+        this._collections = this._register(( new DisposableMap()));
+    }
+    start() {
+        this._register(this._workspaceContextService.onDidChangeWorkspaceFolders(e => {
+            for (const removed of e.removed) {
+                this._collections.deleteAndDispose(( removed.uri.toString()));
+            }
+            for (const added of e.added) {
+                this._watchFolder(added);
+            }
+        }));
+        for (const folder of this._workspaceContextService.getWorkspace().folders) {
+            this._watchFolder(folder);
+        }
+    }
+    _watchFolder(folder) {
+        const configFile = joinPath(folder.uri, ".mcp.json");
+        const collectionId = `workspace-dot-mcp.${folder.index}`;
+        const serverDefinitions = observableValue(this, []);
+        const collection = {
+            id: collectionId,
+            label: `${folder.name}/.mcp.json`,
+            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority || null,
+            scope: StorageScope.WORKSPACE,
+            trustBehavior: McpServerTrust.Kind.TrustedOnNonce,
+            serverDefinitions,
+            configTarget: ConfigurationTarget.WORKSPACE_FOLDER,
+            order: McpCollectionSortOrder.WorkspaceFolder + 1,
+            presentation: {
+                origin: configFile
+            }
+        };
+        const store = ( new DisposableStore());
+        const collectionRegistration = store.add(( new MutableDisposable()));
+        const updateFile = async () => {
+            let definitions = [];
+            try {
+                const contents = await this._fileService.readFile(configFile);
+                const defs = await claudeConfigToServerDefinition(collectionId, contents.value, folder.uri);
+                if (defs) {
+                    for (const d of defs) {
+                        d.roots = [folder.uri];
+                    }
+                    definitions = defs;
+                }
+            } catch {}
+            if (!definitions.length) {
+                collectionRegistration.clear();
+            } else {
+                serverDefinitions.set(definitions, undefined);
+                if (!collectionRegistration.value) {
+                    collectionRegistration.value = this._mcpRegistry.registerCollection(collection);
+                }
+            }
+        };
+        const throttler = store.add(( new RunOnceScheduler(updateFile, 500)));
+        const watcher = store.add(this._fileService.createWatcher(configFile, {
+            recursive: false,
+            excludes: []
+        }));
+        store.add(watcher.onDidChange(() => throttler.schedule()));
+        updateFile();
+        this._collections.set(( folder.uri.toString()), store);
+    }
+};
+WorkspaceDotMcpDiscovery = ( __decorate([( __param(0, IFileService)), ( __param(1, IWorkspaceContextService)), ( __param(2, IMcpRegistry)), ( __param(3, IRemoteAgentService))], WorkspaceDotMcpDiscovery));
+
+export { WorkspaceDotMcpDiscovery };

package/vscode/src/vs/workbench/contrib/mcp/common/discovery/workspaceMcpDiscoveryAdapter.js

@@ -53,9 +53,9 @@ let CursorWorkspaceMcpDiscoveryAdapter = class CursorWorkspaceMcpDiscoveryAdapte
             trustBehavior: McpServerTrust.Kind.TrustedOnNonce,
             serverDefinitions: observableValue(this, []),
             configTarget: ConfigurationTarget.WORKSPACE_FOLDER,
+            order: McpCollectionSortOrder.WorkspaceFolder + 1,
             presentation: {
-                origin: configFile,
-                order: McpCollectionSortOrder.WorkspaceFolder + 1
+                origin: configFile
             }
         };
         this._collections.set(( folder.uri.toString()), this.watchFile(

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

@@ -14,19 +14,19 @@ var McpContextKeys;
 (function(McpContextKeys) {
     McpContextKeys.serverCount = ( new RawContextKey("mcp.serverCount", undefined, {
         type: "number",
-        description: ( localize(10866, "Context key that has the number of registered MCP servers"))
+        description: ( localize(11168, "Context key that has the number of registered MCP servers"))
     }));
     McpContextKeys.hasUnknownTools = ( new RawContextKey("mcp.hasUnknownTools", undefined, {
         type: "boolean",
-        description: ( localize(10867, "Indicates whether there are MCP servers with unknown tools."))
+        description: ( localize(11169, "Indicates whether there are MCP servers with unknown tools."))
     }));
     McpContextKeys.hasServersWithErrors = ( new RawContextKey("mcp.hasServersWithErrors", undefined, {
         type: "boolean",
-        description: ( localize(10868, "Indicates whether there are any MCP servers with errors."))
+        description: ( localize(11170, "Indicates whether there are any MCP servers with errors."))
     }));
     McpContextKeys.toolsCount = ( new RawContextKey("mcp.toolsCount", undefined, {
         type: "number",
-        description: ( localize(10869, "Context key that has the number of registered MCP tools"))
+        description: ( localize(11171, "Context key that has the number of registered MCP tools"))
     }));
 })(McpContextKeys || (McpContextKeys = {}));
 let McpContextKeysController = class McpContextKeysController extends Disposable {

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

@@ -71,7 +71,7 @@ let McpLanguageModelToolContribution = class McpLanguageModelToolContribution ex
                     const toolSet = store.add(
                         this._toolsService.createToolSet(source, server.definition.id, referenceName, {
                             icon: Codicon.mcp,
-                            description: ( localize(10870, "{0}: All Tools", server.definition.label))
+                            description: ( localize(11172, "{0}: All Tools", server.definition.label))
                         })
                     );
                     return {
@@ -191,7 +191,7 @@ let McpToolImplementation = class McpToolImplementation {
         });
         const isSandboxedServer = sandboxEnabled === true;
         const mcpToolWarning = ( localize(
-            10871,
+            11173,
             "Note that MCP servers or malicious conversation content may attempt to misuse '{0}' through tools.",
             this._productService.nameShort
         ));
@@ -200,7 +200,7 @@ let McpToolImplementation = class McpToolImplementation {
         if (!isSandboxedServer) {
             confirm = {};
             if (!tool.definition.annotations?.readOnlyHint) {
-                confirm.title = ( new MarkdownString(( localize(10872, "Run {0}", title))));
+                confirm.title = ( new MarkdownString(( localize(11174, "Run {0}", title))));
                 confirm.message = ( new MarkdownString(tool.definition.description, {
                     supportThemeIcons: true
                 }));
@@ -214,9 +214,9 @@ let McpToolImplementation = class McpToolImplementation {
         const mcpUiEnabled = this._configurationService.getValue(mcpAppsEnabledConfig);
         return {
             confirmationMessages: confirm,
-            invocationMessage: ( new MarkdownString(( localize(10873, "Running {0}", title)))),
-            pastTenseMessage: ( new MarkdownString(( localize(10874, "Ran {0} ", title)))),
-            originMessage: ( localize(10875, "{0} (MCP Server)", server.definition.label)),
+            invocationMessage: ( new MarkdownString(( localize(11175, "Running {0}", title)))),
+            pastTenseMessage: ( new MarkdownString(( localize(11176, "Ran {0} ", title)))),
+            originMessage: ( localize(11177, "{0} (MCP Server)", server.definition.label)),
             toolSpecificData: {
                 kind: "input",
                 rawInput: context.parameters,
@@ -234,7 +234,9 @@ let McpToolImplementation = class McpToolImplementation {
         };
         const callResult = await this._tool.callWithProgress(invocation.parameters, progress, {
             chatRequestId: invocation.chatRequestId,
-            chatSessionResource: invocation.context?.sessionResource
+            chatSessionResource: invocation.context?.sessionResource,
+            traceparent: invocation.traceparent,
+            tracestate: invocation.tracestate
         }, token);
         const details = {
             input: JSON.stringify(invocation.parameters, undefined, 2),
@@ -353,7 +355,7 @@ let McpToolImplementation = class McpToolImplementation {
                     if (isForModel) {
                         const permalink = invocation.context && ChatResponseResource.createUri(
                             invocation.context.sessionResource,
-                            invocation.callId,
+                            invocation.chatStreamToolCallId || invocation.callId,
                             result.content.length,
                             basename(uri)
                         );

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

@@ -133,7 +133,7 @@ let McpRegistry = class McpRegistry extends Disposable {
             this._collections.set(( currentCollections.map(c => c === toReplace ? collection : c)), undefined);
         } else {
             this._collections.set(
-                [...currentCollections, collection].sort((a, b) => (a.presentation?.order || 0) - (b.presentation?.order || 0)),
+                [...currentCollections, collection].sort((a, b) => a.order - b.order),
                 undefined
             );
         }
@@ -227,7 +227,7 @@ let McpRegistry = class McpRegistry extends Disposable {
             if (errorOnUserInteraction) {
                 throw ( new UserInteractionRequiredError("workspaceTrust"));
             } else if (!(await this._workspaceTrustRequestService.requestWorkspaceTrust({
-                message: ( localize(10876, "This MCP server definition is defined in your workspace files."))
+                message: ( localize(11178, "This MCP server definition is defined in your workspace files."))
             }))) {
                 return false;
             }
@@ -305,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(10877, "from {0}", r.collection.source.value))})`;
+                labelWithOrigin += ` (${( localize(11179, "from {0}", r.collection.source.value))})`;
             }
             return labelWithOrigin;
         }
@@ -315,12 +315,12 @@ let McpRegistry = class McpRegistry extends Disposable {
             const {
                 result
             } = await this._dialogService.prompt({
-                message: ( localize(10878, "Trust and run MCP server {0}?", def.definition.label)),
+                message: ( localize(11180, "Trust and run MCP server {0}?", def.definition.label)),
                 custom: {
                     icon: Codicon.shield,
                     markdownDetails: [{
                         markdown: ( new MarkdownString(( localize(
-                            10879,
+                            11181,
                             "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)
                         )))),
@@ -333,10 +333,10 @@ let McpRegistry = class McpRegistry extends Disposable {
                     }]
                 },
                 buttons: [{
-                    label: ( localize(10880, "Trust")),
+                    label: ( localize(11182, "Trust")),
                     run: () => true
                 }, {
-                    label: ( localize(10881, "Do not trust")),
+                    label: ( localize(11183, "Do not trust")),
                     run: () => false
                 }]
             });
@@ -346,12 +346,12 @@ let McpRegistry = class McpRegistry extends Disposable {
         const {
             result
         } = await this._dialogService.prompt({
-            message: ( localize(10882, "Trust and run {0} MCP servers?", definitions.length)),
+            message: ( localize(11184, "Trust and run {0} MCP servers?", definitions.length)),
             custom: {
                 icon: Codicon.shield,
                 markdownDetails: [{
                     markdown: ( new MarkdownString(( localize(
-                        10883,
+                        11185,
                         "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
                     )))),
@@ -364,13 +364,13 @@ let McpRegistry = class McpRegistry extends Disposable {
                 }]
             },
             buttons: [{
-                label: ( localize(10880, "Trust")),
+                label: ( localize(11182, "Trust")),
                 run: () => "all"
             }, {
-                label: ( localize(10884, "Pick Trusted")),
+                label: ( localize(11186, "Pick Trusted")),
                 run: () => "pick"
             }, {
-                label: ( localize(10881, "Do not trust")),
+                label: ( localize(11183, "Do not trust")),
                 run: () => "none"
             }]
         });
@@ -533,14 +533,14 @@ let McpRegistry = class McpRegistry extends Disposable {
             }
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( localize(10885, "Error starting {0}: {1}", definition.label, String(e))),
+                message: ( localize(11187, "Error starting {0}: {1}", definition.label, String(e))),
                 actions: {
                     primary: collection.presentation?.origin && [{
                         id: "mcp.launchError.openConfig",
                         class: undefined,
                         enabled: true,
                         tooltip: "",
-                        label: ( localize(10886, "Open Configuration")),
+                        label: ( localize(11188, "Open Configuration")),
                         run: () => this._editorService.openEditor({
                             resource: collection.presentation.origin,
                             options: {

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(10887, "{0} total requests in the last 7 days.", total)));
+        parts.push(( localize(11189, "{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.js

@@ -131,11 +131,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                10888,
+                11190,
                 "Allow MCP tools from \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                10889,
+                11191,
                 "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"));
@@ -149,11 +149,11 @@ let McpSamplingService = class McpSamplingService extends Disposable {
                 return this._getMatchingModel(opts);
             }
             const retry = await this._showContextual(opts.isDuringToolCall, ( localize(
-                10890,
+                11192,
                 "Allow MCP server \"{0}\" to make LLM requests?",
                 opts.server.definition.label
             )), ( localize(
-                10891,
+                11193,
                 "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"));
@@ -165,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(
-                10892,
+                11194,
                 "MCP server \"{0}\" triggered a language model request, but it has no allowlisted models.",
                 opts.server.definition.label
             )), {
-                [( localize(10893, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
-                [( localize(10894, "Cancel"))]: () => Promise.resolve(undefined)
+                [( localize(11195, "Configure"))]: () => this._commandService.executeCommand(McpCommandIds.ConfigureSamplingModels, opts.server),
+                [( localize(11196, "Cancel"))]: () => Promise.resolve(undefined)
             });
             if (newlyPickedModels) {
                 return this._getMatchingModel(opts);
@@ -181,19 +181,19 @@ let McpSamplingService = class McpSamplingService extends Disposable {
     }
     allowButtons(server, key) {
         return {
-            [( localize(10895, "Allow in this Session"))]: async () => {
+            [( localize(11197, "Allow in this Session"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, true);
                 return true;
             },
-            [( localize(10896, "Always"))]: async () => {
+            [( localize(11198, "Always"))]: async () => {
                 await this.updateConfig(server, c => c[key] = true);
                 return true;
             },
-            [( localize(10897, "Not Now"))]: async () => {
+            [( localize(11199, "Not Now"))]: async () => {
                 this._sessionSets[key].set(server.definition.id, false);
                 return false;
             },
-            [( localize(10898, "Never"))]: async () => {
+            [( localize(11200, "Never"))]: async () => {
                 await this.updateConfig(server, c => c[key] = false);
                 return false;
             }

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

@@ -102,11 +102,11 @@ let McpSandboxService = class McpSandboxService extends Disposable {
         const suggestionLines = [];
         if (allowedDomainsList.length) {
             const shown = ( allowedDomainsList.map(domain => `"${domain}"`)).join(", ");
-            suggestionLines.push(( localize(10899, "Add to `sandbox.network.allowedDomains`: {0}", shown)));
+            suggestionLines.push(( localize(11201, "Add to `sandbox.network.allowedDomains`: {0}", shown)));
         }
         if (allowWriteList.length) {
             const shown = ( allowWriteList.map(path => `"${path}"`)).join(", ");
-            suggestionLines.push(( localize(10900, "Add to `sandbox.filesystem.allowWrite`: {0}", shown)));
+            suggestionLines.push(( localize(11202, "Add to `sandbox.filesystem.allowWrite`: {0}", shown)));
         }
         const sandboxConfig = {};
         if (allowedDomainsList.length) {
@@ -121,7 +121,7 @@ let McpSandboxService = class McpSandboxService extends Disposable {
         }
         return {
             message: ( localize(
-                10901,
+                11203,
                 "The MCP server {0} reported potential sandbox blocks. VS Code found possible sandbox configuration updates:\n{1}",
                 serverLabel,
                 suggestionLines.join("\n")
@@ -234,7 +234,7 @@ let McpSandboxService = class McpSandboxService extends Disposable {
             os,
             appRoot,
             "node_modules",
-            "@anthropic-ai",
+            "@vscode",
             "sandbox-runtime",
             "dist",
             "cli.js"

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

@@ -52,7 +52,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         this._state.set({
             state: McpConnectionState.Kind.Starting
         }, undefined);
-        this._logger.info(( localize(10917, "Starting server {0}", this.definition.label)));
+        this._logger.info(( localize(11219, "Starting server {0}", this.definition.label)));
         try {
             const launch = this._delegate.start(this._collection, this.definition, this.launchDefinition, {
                 errorOnUserInteraction: this._errorOnUserInteraction
@@ -89,7 +89,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         store.add(autorun(reader => {
             const state = launch.state.read(reader);
             this._state.set(state, undefined);
-            this._logger.info(( localize(10918, "Connection state: {0}", (McpConnectionState.toString(state)))));
+            this._logger.info(( localize(11220, "Connection state: {0}", (McpConnectionState.toString(state)))));
             if (state.state === McpConnectionState.Kind.Running && !didStart) {
                 didStart = true;
                 McpServerRequestHandler.create(this._instantiationService, {
@@ -128,7 +128,7 @@ let McpServerConnection = class McpServerConnection extends Disposable {
         };
     }
     async stop() {
-        this._logger.info(( localize(10919, "Stopping server {0}", this.definition.label)));
+        this._logger.info(( localize(11221, "Stopping server {0}", this.definition.label)));
         this._launch.value?.object.stop();
         await this._waitForState(McpConnectionState.Kind.Stopped, McpConnectionState.Kind.Error);
     }