@codingame/monaco-vscode-api 33.0.8 → 34.0.0

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

@@ -21,6 +21,7 @@ export declare enum McpCommandIds {
     RestartServer = "workbench.mcp.restartServer",
     ServerOptions = "workbench.mcp.serverOptions",
     ServerOptionsInConfirmation = "workbench.mcp.serverOptionsInConfirmation",
+    SetOAuthClientSecret = "workbench.mcp.setOAuthClientSecret",
     ShowConfiguration = "workbench.mcp.showConfiguration",
     ShowInstalled = "workbench.mcp.showInstalledServers",
     ShowOutput = "workbench.mcp.showOutput",

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

@@ -21,6 +21,7 @@ var McpCommandIds;
     McpCommandIds["RestartServer"] = "workbench.mcp.restartServer";
     McpCommandIds["ServerOptions"] = "workbench.mcp.serverOptions";
     McpCommandIds["ServerOptionsInConfirmation"] = "workbench.mcp.serverOptionsInConfirmation";
+    McpCommandIds["SetOAuthClientSecret"] = "workbench.mcp.setOAuthClientSecret";
     McpCommandIds["ShowConfiguration"] = "workbench.mcp.showConfiguration";
     McpCommandIds["ShowInstalled"] = "workbench.mcp.showInstalledServers";
     McpCommandIds["ShowOutput"] = "workbench.mcp.showOutput";

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

@@ -19,6 +19,24 @@ export declare const mcpConfigurationSection = "mcp";
 export declare const mcpDiscoverySection = "chat.mcp.discovery.enabled";
 export declare const mcpServerSamplingSection = "chat.mcp.serverSampling";
 export declare const mcpServerCollisionBehaviorSection = "chat.mcp.collisionBehavior";
+/**
+ * Configuration key for the enterprise-managed MCP IdP bag. The setting is
+ * registered with `included: false` so it is hidden from the Settings UI and
+ * settings.json IntelliSense; it is intended to be delivered through enterprise
+ * policy (Windows Group Policy / macOS managed preferences / Linux
+ * `/etc/vscode/policy.json`), with hand-editing of `settings.json` as a
+ * developer escape hatch.
+ */
+export declare const mcpEnterpriseManagedAuthIdpSection = "mcp.enterpriseManagedAuth.idp";
+/**
+ * Shape of the {@link mcpEnterpriseManagedAuthIdpSection} setting. All fields
+ * are optional so partial configurations (e.g. just the issuer) remain valid.
+ */
+export interface IMcpEnterpriseManagedAuthIdpConfig {
+    readonly issuer?: string;
+    readonly clientId?: string;
+    readonly clientSecret?: string;
+}
 export declare enum McpCollisionBehavior {
     Disable = "disable",
     Suffix = "suffix"

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

@@ -24,21 +24,22 @@ const allDiscoverySources = ( Object.keys({
     [DiscoverySource.CursorWorkspace]: true
 }));
 const discoverySourceLabel = {
-    [DiscoverySource.ClaudeDesktop]: ( localize(11278, "Claude Desktop")),
-    [DiscoverySource.Windsurf]: ( localize(11279, "Windsurf")),
-    [DiscoverySource.CursorGlobal]: ( localize(11280, "Cursor (Global)")),
-    [DiscoverySource.CursorWorkspace]: ( localize(11281, "Cursor (Workspace)"))
+    [DiscoverySource.ClaudeDesktop]: ( localize(11458, "Claude Desktop")),
+    [DiscoverySource.Windsurf]: ( localize(11459, "Windsurf")),
+    [DiscoverySource.CursorGlobal]: ( localize(11460, "Cursor (Global)")),
+    [DiscoverySource.CursorWorkspace]: ( localize(11461, "Cursor (Workspace)"))
 };
 const discoverySourceSettingsLabel = {
-    [DiscoverySource.ClaudeDesktop]: ( localize(11282, "Claude Desktop configuration (`claude_desktop_config.json`)")),
-    [DiscoverySource.Windsurf]: ( localize(11283, "Windsurf configurations (`~/.codeium/windsurf/mcp_config.json`)")),
-    [DiscoverySource.CursorGlobal]: ( localize(11284, "Cursor global configuration (`~/.cursor/mcp.json`)")),
-    [DiscoverySource.CursorWorkspace]: ( localize(11285, "Cursor workspace configuration (`.cursor/mcp.json`)"))
+    [DiscoverySource.ClaudeDesktop]: ( localize(11462, "Claude Desktop configuration (`claude_desktop_config.json`)")),
+    [DiscoverySource.Windsurf]: ( localize(11463, "Windsurf configurations (`~/.codeium/windsurf/mcp_config.json`)")),
+    [DiscoverySource.CursorGlobal]: ( localize(11464, "Cursor global configuration (`~/.cursor/mcp.json`)")),
+    [DiscoverySource.CursorWorkspace]: ( localize(11465, "Cursor workspace configuration (`.cursor/mcp.json`)"))
 };
 const mcpConfigurationSection = "mcp";
 const mcpDiscoverySection = "chat.mcp.discovery.enabled";
 const mcpServerSamplingSection = "chat.mcp.serverSampling";
 const mcpServerCollisionBehaviorSection = "chat.mcp.collisionBehavior";
+const mcpEnterpriseManagedAuthIdpSection = "mcp.enterpriseManagedAuth.idp";
 var McpCollisionBehavior;
 (function(McpCollisionBehavior) {
     McpCollisionBehavior["Disable"] = "disable";
@@ -61,7 +62,7 @@ const mcpDevModeProps = stdio => ({
     dev: {
         type: "object",
         markdownDescription: ( localize(
-            11286,
+            11466,
             "Enabled development mode for the server. When present, the server will be started eagerly and output will be included in its output. Properties inside the `dev` object can configure additional behavior."
         )),
         examples: [{
@@ -73,7 +74,7 @@ const mcpDevModeProps = stdio => ({
         properties: {
             watch: {
                 description: ( localize(
-                    11287,
+                    11467,
                     "A glob pattern or list of glob patterns relative to the workspace folder to watch. The MCP server will be restarted when these files change."
                 )),
                 examples: ["src/**/*.ts"],
@@ -89,7 +90,7 @@ const mcpDevModeProps = stdio => ({
             ...(stdio && {
                 debug: {
                     markdownDescription: ( localize(
-                        11288,
+                        11468,
                         "If set, debugs the MCP server using the given runtime as it's started."
                     )),
                     oneOf: [{
@@ -99,7 +100,7 @@ const mcpDevModeProps = stdio => ({
                             type: {
                                 type: "string",
                                 enum: ["node"],
-                                description: ( localize(11289, "Debug the MCP server using Node.js."))
+                                description: ( localize(11469, "Debug the MCP server using Node.js."))
                             }
                         },
                         additionalProperties: false
@@ -110,11 +111,11 @@ const mcpDevModeProps = stdio => ({
                             type: {
                                 type: "string",
                                 enum: ["debugpy"],
-                                description: ( localize(11290, "Debug the MCP server using Python and debugpy."))
+                                description: ( localize(11470, "Debug the MCP server using Python and debugpy."))
                             },
                             debugpyPath: {
                                 type: "string",
-                                description: ( localize(11291, "Path to the debugpy executable."))
+                                description: ( localize(11471, "Path to the debugpy executable."))
                             }
                         },
                         additionalProperties: false
@@ -132,39 +133,39 @@ const mcpStdioServerSchema = {
         type: {
             type: "string",
             enum: ["stdio"],
-            description: ( localize(11292, "The type of the server."))
+            description: ( localize(11472, "The type of the server."))
         },
         sandboxEnabled: {
             type: "boolean",
             default: false,
-            description: ( localize(11293, "Whether to run the server in a sandboxed environment."))
+            description: ( localize(11473, "Whether to run the server in a sandboxed environment."))
         },
         command: {
             type: "string",
-            description: ( localize(11294, "The command to run the server."))
+            description: ( localize(11474, "The command to run the server."))
         },
         cwd: {
             type: "string",
             description: ( localize(
-                11295,
+                11475,
                 "The working directory for the server command. Defaults to the workspace folder when run in a workspace."
             )),
             examples: ["${workspaceFolder}"]
         },
         args: {
             type: "array",
-            description: ( localize(11296, "Arguments passed to the server.")),
+            description: ( localize(11476, "Arguments passed to the server.")),
             items: {
                 type: "string"
             }
         },
         envFile: {
             type: "string",
-            description: ( localize(11297, "Path to a file containing environment variables for the server.")),
+            description: ( localize(11477, "Path to a file containing environment variables for the server.")),
             examples: ["${workspaceFolder}/.env"]
         },
         env: {
-            description: ( localize(11298, "Environment variables passed to the server.")),
+            description: ( localize(11478, "Environment variables passed to the server.")),
             additionalProperties: {
                 anyOf: [{
                     type: "null"
@@ -181,27 +182,27 @@ const mcpStdioServerSchema = {
 const mcpServerSchema = {
     id: mcpSchemaId,
     type: "object",
-    title: ( localize(11299, "Model Context Protocol Servers")),
+    title: ( localize(11479, "Model Context Protocol Servers")),
     allowTrailingCommas: true,
     allowComments: true,
     additionalProperties: false,
     properties: {
         sandbox: {
             description: ( localize(
-                11300,
+                11480,
                 "Sandbox config that determines file system and network access. Sandboxing is enabled when sandboxEnabled property is set at the server level on Mac OS and Linux only."
             )),
             type: "object",
             additionalProperties: false,
             properties: {
                 network: {
-                    description: ( localize(11301, "Network access settings for the sandboxed server.")),
+                    description: ( localize(11481, "Network access settings for the sandboxed server.")),
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         allowedDomains: {
                             description: ( localize(
-                                11302,
+                                11482,
                                 "List of domains that the server is allowed to access. Wildcards are supported, e.g. `*.example.com`."
                             )),
                             type: "array",
@@ -212,7 +213,7 @@ const mcpServerSchema = {
                         },
                         deniedDomains: {
                             description: ( localize(
-                                11303,
+                                11483,
                                 "List of domains that the server is not allowed to access. e.g. `invalid.example.com`."
                             )),
                             type: "array",
@@ -225,7 +226,7 @@ const mcpServerSchema = {
                 },
                 filesystem: {
                     description: ( localize(
-                        11304,
+                        11484,
                         "Filesystem access settings for the sandboxed server. Glob patterns are supported for Mac OS only."
                     )),
                     type: "object",
@@ -233,7 +234,7 @@ const mcpServerSchema = {
                     properties: {
                         denyRead: {
                             description: ( localize(
-                                11305,
+                                11485,
                                 "List of file paths that the server is not allowed to read. By default, all files are allowed to be read. e.g. `~/src/secrets`."
                             )),
                             type: "array",
@@ -244,7 +245,7 @@ const mcpServerSchema = {
                         },
                         allowWrite: {
                             description: ( localize(
-                                11306,
+                                11486,
                                 "List of file paths that the server is allowed to write to. e.g. `~/src/`."
                             )),
                             type: "array",
@@ -255,7 +256,7 @@ const mcpServerSchema = {
                         },
                         denyWrite: {
                             description: ( localize(
-                                11307,
+                                11487,
                                 "List of file paths that the server is not allowed to write to. e.g. `~/src/auth/`."
                             )),
                             type: "array",
@@ -280,32 +281,43 @@ const mcpServerSchema = {
                         type: {
                             type: "string",
                             enum: ["http", "sse"],
-                            description: ( localize(11292, "The type of the server."))
+                            description: ( localize(11472, "The type of the server."))
                         },
                         url: {
                             type: "string",
                             format: "uri",
                             pattern: "^https?:\\/\\/.+",
-                            patternErrorMessage: ( localize(11308, "The URL must start with 'http://' or 'https://'.")),
-                            description: ( localize(11309, "The URL of the Streamable HTTP or SSE endpoint."))
+                            patternErrorMessage: ( localize(11488, "The URL must start with 'http://' or 'https://'.")),
+                            description: ( localize(11489, "The URL of the Streamable HTTP or SSE endpoint."))
                         },
                         headers: {
                             type: "object",
-                            description: ( localize(11310, "Additional headers sent to the server.")),
+                            description: ( localize(11490, "Additional headers sent to the server.")),
                             additionalProperties: {
                                 type: "string"
                             }
                         },
                         oauth: {
                             type: "object",
-                            description: ( localize(11311, "OAuth configuration for authenticating with the server.")),
+                            description: ( localize(11491, "OAuth configuration for authenticating with the server.")),
                             additionalProperties: false,
                             minProperties: 1,
                             properties: {
                                 clientId: {
                                     type: "string",
                                     minLength: 1,
-                                    description: ( localize(11312, "The OAuth client ID to use when authenticating with the server."))
+                                    markdownDescription: ( localize(
+                                        11492,
+                                        "The OAuth client ID to use when authenticating with the server. When `enterpriseManaged` is `true`, this is the **resource** authorization server's client ID (the client trusted by the protected resource), not the IdP's. To set the matching client secret, use the *Set Client Secret* code lens above this field — secrets are stored in the OS secret store, not in this file."
+                                    ))
+                                },
+                                enterpriseManaged: {
+                                    type: "boolean",
+                                    default: false,
+                                    markdownDescription: ( localize(
+                                        11493,
+                                        "(Preview) When set to `true`, this MCP server authenticates through the SSO issuer configured by `#mcp.enterpriseManagedAuth.idp#` using OAuth Identity Assertion Authorization Grant (ID-JAG). After a one-time sign-in, subsequent enterprise-managed servers connect silently. The IdP issuer and client credentials are read from the `#mcp.enterpriseManagedAuth.idp#` setting; the `clientId` on this server entry is passed to the resource authorization server."
+                                    ))
                                 }
                             }
                         },
@@ -328,7 +340,7 @@ const mcpContributionPoint = {
     },
     jsonSchema: {
         description: ( localize(
-            11313,
+            11494,
             "Contributes Model Context Protocol servers. Users of this should also use `vscode.lm.registerMcpServerDefinitionProvider`."
         )),
         type: "array",
@@ -349,15 +361,15 @@ const mcpContributionPoint = {
             }],
             properties: {
                 id: {
-                    description: ( localize(11314, "Unique ID for the collection.")),
+                    description: ( localize(11495, "Unique ID for the collection.")),
                     type: "string"
                 },
                 label: {
-                    description: ( localize(11315, "Display name for the collection.")),
+                    description: ( localize(11496, "Display name for the collection.")),
                     type: "string"
                 },
                 when: {
-                    description: ( localize(11316, "Condition which must be true to enable this collection.")),
+                    description: ( localize(11497, "Condition which must be true to enable this collection.")),
                     type: "string"
                 }
             }
@@ -374,7 +386,7 @@ class McpServerDefinitionsProviderRenderer extends Disposable {
     }
     render(manifest) {
         const mcpServerDefinitionProviders = manifest.contributes?.mcpServerDefinitionProviders ?? [];
-        const headers = [( localize(11317, "ID")), ( localize(11318, "Name"))];
+        const headers = [( localize(11498, "ID")), ( localize(11499, "Name"))];
         const rows = ( mcpServerDefinitionProviders.map(mcpServerDefinitionProvider => {
             return [( new MarkdownString()).appendMarkdown(`\`${mcpServerDefinitionProvider.id}\``), mcpServerDefinitionProvider.label];
         }));
@@ -389,11 +401,11 @@ class McpServerDefinitionsProviderRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: mcpConfigurationSection,
-    label: ( localize(11319, "MCP Servers")),
+    label: ( localize(11500, "MCP Servers")),
     access: {
         canToggle: false
     },
     renderer: ( new SyncDescriptor(McpServerDefinitionsProviderRenderer))
 });
 
-export { DiscoverySource, McpCollisionBehavior, allDiscoverySources, discoverySourceLabel, discoverySourceSettingsLabel, mcpActivationEvent, mcpConfigurationSection, mcpContributionPoint, mcpDiscoverySection, mcpSchemaExampleServers, mcpServerCollisionBehaviorSection, mcpServerSamplingSection, mcpServerSchema, mcpStdioServerSchema };
+export { DiscoverySource, McpCollisionBehavior, allDiscoverySources, discoverySourceLabel, discoverySourceSettingsLabel, mcpActivationEvent, mcpConfigurationSection, mcpContributionPoint, mcpDiscoverySection, mcpEnterpriseManagedAuthIdpSection, mcpSchemaExampleServers, mcpServerCollisionBehaviorSection, mcpServerSamplingSection, mcpServerSchema, mcpStdioServerSchema };

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

@@ -1,5 +1,5 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
-import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
+import { Disposable, IDisposable, IReference } 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";
@@ -105,6 +105,19 @@ export declare class McpServerMetadataCache extends Disposable {
     /** Sets cached servers for a collection */
     storeServers(collectionId: string, entry: IServerCacheEntry | undefined): void;
 }
+/**
+ * Shared across all {@link McpServer}s. Each server `take`s the name it wants
+ * to base its tool prefix on (announced `serverInfo.title`/`name` when known,
+ * otherwise the mcp.json key) and gets back a stable, collision-resolved prefix
+ * observable. When a server's preferred name changes (e.g. after the live
+ * `serverInfo` arrives), it simply takes again and disposes the previous
+ * reference; other servers that share the name keep the suffix they were
+ * already assigned. See #299749.
+ */
+export declare class McpPrefixGenerator {
+    private readonly _buckets;
+    take(name: string): IReference<string>;
+}
 type ValidatedMcpTool = MCP.Tool & {
     _icons: StoredMcpIcons;
     /**
@@ -181,7 +194,7 @@ export declare class McpServer extends Disposable implements IMcpServer {
     /** Count of running tool calls, used to detect if sampling is during an LM call */
     runningToolCalls: Set<IMcpToolCallContext>;
     readonly enablement: IObservable<ContributionEnablementState>;
-    constructor(initialCollection: McpCollectionDefinition, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _primitiveCache: McpServerMetadataCache, toolPrefix: string, enablementModel: IEnablementModel, _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);
+    constructor(initialCollection: McpCollectionDefinition, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _primitiveCache: McpServerMetadataCache, prefixGenerator: McpPrefixGenerator, enablementModel: IEnablementModel, _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;

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

@@ -37,12 +37,12 @@ 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 { McpToolName, McpConnectionState, McpConnectionFailedError, McpServerCacheState, McpServerStaticToolAvailability, extensionMcpCollectionPrefix, UserInteractionRequiredError, McpServerTransportType, McpToolVisibility, mcpPromptReplaceSpecialChars, McpCapability, MpcResponseError, ElicitationKind, McpResourceURI } from './mcpTypes.js';
 import { IMcpSamplingService, IMcpElicitationService } from './mcpTypes.service.js';
 import { MCP } from '../../../../platform/mcp/common/modelContextProtocol.js';
-import { UriTemplate } from './uriTemplate.js';
+import { UriTemplate } from '../../../../base/common/uriTemplate.js';
 import { observableValue, disposableObservableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
-import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
+import { derived, derivedDisposable } from '../../../../base/common/observableInternal/observables/derived.js';
 import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
 import { autorun, autorunSelfDisposable } from '../../../../base/common/observableInternal/reactions/autorun.js';
 import { ObservablePromise } from '../../../../base/common/observableInternal/utils/promise.js';
@@ -112,6 +112,41 @@ let McpServerMetadataCache = class McpServerMetadataCache extends Disposable {
     }
 };
 McpServerMetadataCache = ( __decorate([( __param(1, IStorageService))], McpServerMetadataCache));
+class McpPrefixGenerator {
+    constructor() {
+        this._buckets = ( new Map());
+    }
+    take(name) {
+        const safeName = name.toLowerCase().replace(/[^a-z0-9_.-]+/g, "_").slice(0, McpToolName.MaxPrefixLen - McpToolName.Prefix.length - 1);
+        let bucket = this._buckets.get(safeName);
+        if (!bucket) {
+            bucket = {
+                usedIndexes: ( new Set()),
+                size: 0
+            };
+            this._buckets.set(safeName, bucket);
+        }
+        let index = 1;
+        while (( bucket.usedIndexes.has(index))) {
+            index++;
+        }
+        bucket.usedIndexes.add(index);
+        bucket.size++;
+        const suffix = (index === 1 ? "" : String(index)) + "_";
+        const maxNameLen = McpToolName.MaxPrefixLen - McpToolName.Prefix.length - suffix.length;
+        const prefix = McpToolName.Prefix + safeName.slice(0, maxNameLen) + suffix;
+        return {
+            object: prefix,
+            dispose: () => {
+                bucket.usedIndexes.delete(index);
+                bucket.size--;
+                if (bucket.size === 0) {
+                    this._buckets.delete(safeName);
+                }
+            }
+        };
+    }
+}
 class CachedPrimitive {
     constructor(
         _definitionId,
@@ -209,7 +244,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         explicitRoots,
         _requiresExtensionActivation,
         _primitiveCache,
-        toolPrefix,
+        prefixGenerator,
         enablementModel,
         _mcpRegistry,
         workspacesService,
@@ -340,11 +375,27 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
             const def = this._fullDefinitions.read(reader).server;
             return def && def.cacheNonce !== this._tools.fromCache?.nonce ? def.staticMetadata : undefined;
         });
+        this._serverMetadata = ( new CachedPrimitive(this.definition.id, this._primitiveCache, ( staticMetadata.map(
+            m => m ? this._toStoredMetadata(m?.serverInfo, m?.instructions) : undefined
+        )), entry => ({
+            serverName: entry.serverName,
+            serverInstructions: entry.serverInstructions,
+            serverIcons: entry.serverIcons
+        }), entry => ({
+            serverName: entry?.serverName,
+            serverInstructions: entry?.serverInstructions,
+            icons: McpIcons.fromStored(entry?.serverIcons)
+        }), undefined));
+        const preferredName = derived(
+            reader => this._serverMetadata.value.read(reader)?.serverName || this.definition.label
+        );
+        const prefixRef = derivedDisposable(reader => prefixGenerator.take(preferredName.read(reader)));
+        const toolPrefix = ( prefixRef.map(ref => ref.object));
         this._tools = ( new CachedPrimitive(this.definition.id, this._primitiveCache, ( ( staticMetadata.map(m => {
             const tools = m?.tools?.filter(t => t.availability === McpServerStaticToolAvailability.Initial).map(t => t.definition);
             return tools?.length ? ( new ObservablePromise(this._getValidatedTools(tools))) : undefined;
-        })).map((o, reader) => o?.promiseResult.read(reader)?.data)), entry => entry.tools, entry => ( entry.map(
-            def => this._instantiationService.createInstance(McpTool, this, toolPrefix, def)
+        })).map((o, reader) => o?.promiseResult.read(reader)?.data)), entry => entry.tools, (entry, reader) => ( entry.map(
+            def => this._instantiationService.createInstance(McpTool, this, toolPrefix.read(reader), def)
         )).sort((a, b) => a.compare(b)), []));
         this._prompts = ( new CachedPrimitive(
             this.definition.id,
@@ -354,20 +405,10 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
             entry => ( entry.map(e => ( new McpPrompt(this, e)))),
             []
         ));
-        this._serverMetadata = ( new CachedPrimitive(this.definition.id, this._primitiveCache, ( staticMetadata.map(
-            m => m ? this._toStoredMetadata(m?.serverInfo, m?.instructions) : undefined
-        )), entry => ({
-            serverName: entry.serverName,
-            serverInstructions: entry.serverInstructions,
-            serverIcons: entry.serverIcons
-        }), entry => ({
-            serverName: entry?.serverName,
-            serverInstructions: entry?.serverInstructions,
-            icons: McpIcons.fromStored(entry?.serverIcons)
-        }), undefined));
         this._capabilities = ( new CachedPrimitive(this.definition.id, this._primitiveCache, ( staticMetadata.map(
             m => m?.capabilities !== undefined ? encodeCapabilities(m.capabilities) : undefined
         )), entry => entry.capabilities, entry => entry, undefined));
+        prefixRef.recomputeInitiallyAndOnChange(this._store);
     }
     readDefinitions() {
         return this._fullDefinitions;
@@ -538,7 +579,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         if (cnx.definition.sandboxEnabled) {
             if (!this.showSandboxConfigSuggestionFromPotentialBlocks(cnx, this._potentialSandboxBlocks)) {
                 this._notificationService.warn(( localize(
-                    11356,
+                    11537,
                     "The MCP server {0} could not be started: {1}",
                     cnx.definition.label,
                     error.message
@@ -563,36 +604,36 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 break;
             }
             const options = [{
-                label: ( localize(11357, "Show Output")),
+                label: ( localize(11538, "Show Output")),
                 run: () => this.showOutput()
             }];
             if (cnx.definition.devMode?.debug?.type === "debugpy" && debug) {
                 this._notificationService.prompt(Severity$1.Error, ( localize(
-                    11358,
+                    11539,
                     "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(11359, "View Docs")),
+                    label: ( localize(11540, "View Docs")),
                     run: () => this._openerService.open(( URI.parse("https://aka.ms/vscode-mcp-install/debugpy")))
                 }]);
                 return;
             }
             if (docsLink) {
                 options.push({
-                    label: ( localize(11360, "Install {0}", cnx.launchDefinition.command)),
+                    label: ( localize(11541, "Install {0}", cnx.launchDefinition.command)),
                     run: () => this._openerService.open(( URI.parse(docsLink)))
                 });
             }
             this._notificationService.prompt(Severity$1.Error, ( localize(
-                11361,
+                11542,
                 "The command \"{0}\" needed to run {1} was not found.",
                 cnx.launchDefinition.command,
                 cnx.definition.label
             )), options);
         } else {
             this._notificationService.warn(( localize(
-                11356,
+                11537,
                 "The MCP server {0} could not be started: {1}",
                 cnx.definition.label,
                 error.message
@@ -622,20 +663,20 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         void this._dialogService.confirm({
             type: "warning",
             message: ( localize(
-                11362,
+                11543,
                 "Update sandbox configuration in mcp.json for {0}?",
                 cnx.definition.label
             )),
             detail: suggestion.message,
-            primaryButton: ( localize(11363, "Yes")),
-            cancelButton: ( localize(11364, "No"))
+            primaryButton: ( localize(11544, "Yes")),
+            cancelButton: ( localize(11545, "No"))
         }).then(async result => {
             if (!result.confirmed) {
                 return;
             }
             if (!mcpResource || configTarget === undefined) {
                 this._notificationService.warn(( localize(
-                    11365,
+                    11546,
                     "Couldn't determine where to update sandbox configuration for {0}.",
                     cnx.definition.label
                 )));
@@ -652,14 +693,14 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 if (updated) {
                     this._removePotentialSandboxBlocks(potentialBlocks);
                     this._notificationService.info(( localize(
-                        11366,
+                        11547,
                         "Updated sandbox configuration for {0} in mcp.json. Restart server.",
                         cnx.definition.label
                     )));
                 }
             } catch (e) {
                 this._notificationService.error(( localize(
-                    11367,
+                    11548,
                     "Failed to update sandbox configuration for {0}: {1}",
                     cnx.definition.label,
                     e instanceof Error ? e.message : String(e)
@@ -768,7 +809,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         const validated = [];
         for (const [i, result] of validations.entries()) {
             if ("error" in result) {
-                error += ( localize(11368, "Tool `{0}` has invalid JSON parameters:", tools[i].name)) + "\n";
+                error += ( localize(11549, "Tool `{0}` has invalid JSON parameters:", tools[i].name)) + "\n";
                 for (const message of result.error) {
                     error += `\t- ${message}\n`;
                 }
@@ -1101,7 +1142,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
         notificationService.notify({
             severity: Severity$1.Warning,
             message: ( localize(
-                11369,
+                11550,
                 "MCP server `{0}` has tools with invalid parameters which will be omitted.",
                 serverName
             )),
@@ -1111,7 +1152,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
                     enabled: true,
                     id: "mcpBadSchema.show",
                     tooltip: "",
-                    label: ( localize(11370, "Show")),
+                    label: ( localize(11551, "Show")),
                     run: () => {
                         editorService.openEditor({
                             resource: undefined,
@@ -1168,4 +1209,4 @@ class McpResourceTemplate {
     }
 }
 
-export { McpServer, McpServerMetadataCache, McpTool };
+export { McpPrefixGenerator, McpServer, McpServerMetadataCache, McpTool };