@codingame/monaco-vscode-api 37.6.0 → 38.0.0

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

@@ -0,0 +1,20 @@
+import { IJSONSchema } from "../../../../base/common/jsonSchema.js";
+import { IMcpServerConfiguration, IMcpServerVariable } from "../../../../platform/mcp/common/mcpPlatformTypes.js";
+import { McpResourceFormat } from "../../../../platform/mcp/common/mcpWorkspaceConfiguration.js";
+/** Command contract with the Copilot extension's MCP setup commands. */
+export type McpGeneratedConfiguration = {
+    type: "assisted";
+    format: McpResourceFormat;
+    name: string;
+    server: Record<string, unknown>;
+    inputs?: IMcpServerVariable[];
+    inputValues?: Record<string, string>;
+} | {
+    type: "mapped";
+    name: string;
+    server: IMcpServerConfiguration;
+    inputs?: IMcpServerVariable[];
+    inputValues?: never;
+};
+export declare function getMcpGenerationSchema(format: McpResourceFormat): IJSONSchema;
+export declare function normalizeMcpGeneratedConfiguration(result: McpGeneratedConfiguration, format: McpResourceFormat): IMcpServerConfiguration;

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

@@ -0,0 +1,104 @@
+
+import { localize } from '../../../../nls.js';
+import { normalizeMcpServerConfiguration } from '../../../../platform/agentPlugins/common/pluginParsers.js';
+import { fromCopilotMcpServerConfiguration } from '../../../../platform/mcp/common/mcpCopilotConfiguration.js';
+import { McpResourceFormat } from '../../../../platform/mcp/common/mcpWorkspaceConfiguration.js';
+import { mcpRemoteServerSchema, mcpStdioServerSchema } from './mcpConfiguration.js';
+
+function getMcpGenerationSchema(format) {
+    const remote = mcpRemoteServerSchema;
+    const localProperties = mcpStdioServerSchema.properties;
+    const remoteProperties = remote.properties;
+    const stdio = format !== McpResourceFormat.CopilotGlobal ? mcpStdioServerSchema : {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            type: {
+                enum: ["local"]
+            },
+            command: localProperties.command,
+            args: localProperties.args,
+            env: {
+                type: "object",
+                additionalProperties: {
+                    type: "string"
+                }
+            },
+            cwd: localProperties.cwd,
+            tools: {
+                const: ["*"]
+            }
+        }
+    };
+    const http = format !== McpResourceFormat.CopilotGlobal ? remote : {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            type: {
+                enum: ["http", "sse"]
+            },
+            url: remoteProperties.url,
+            headers: remoteProperties.headers,
+            oauthClientId: {
+                type: "string"
+            },
+            tools: {
+                const: ["*"]
+            }
+        }
+    };
+    return {
+        description: format === McpResourceFormat.WorkspaceRoot ? "Prefer portable command/args/env or HTTP url/headers. Preserve any required VS Code inputs, cwd, envFile, OAuth or SSE transport: these require explicit approval to use .vscode/mcp.json instead of .mcp.json." : undefined,
+        oneOf: [stdio, http].map((schema, index) => ({
+            ...schema,
+            required: ["name", index === 0 ? "command" : "url"],
+            properties: {
+                ...schema.properties,
+                ...(index === 0 ? {
+                    env: {
+                        ...schema.properties.env,
+                        type: "object"
+                    }
+                } : {}),
+                [index === 0 ? "command" : "url"]: {
+                    ...schema.properties[index === 0 ? "command" : "url"],
+                    minLength: 1,
+                    pattern: index === 0 ? "\\S" : "^https?:\\/\\/.+"
+                },
+                name: {
+                    type: "string",
+                    minLength: 1,
+                    pattern: "\\S",
+                    description: "Suggested name of the server"
+                }
+            }
+        }))
+    };
+}
+function normalizeMcpGeneratedConfiguration(result, format) {
+    if (result.type === "mapped") {
+        return result.server;
+    }
+    if (result.format !== format) {
+        throw ( new Error(( localize(
+            18852,
+            "The MCP setup extension returned an unexpected configuration format. Update the Copilot extension and try again."
+        ))));
+    }
+    const normalized = format === McpResourceFormat.CopilotGlobal ? fromCopilotMcpServerConfiguration(result.server) : normalizeMcpServerConfiguration(result.server);
+    if (!normalized) {
+        throw ( new Error(( localize(
+            18853,
+            "The generated MCP server configuration is invalid. Try again or add the server manually."
+        ))));
+    }
+    return format === McpResourceFormat.CopilotGlobal ? normalized : {
+        ...result.server,
+        ...normalized,
+        ...(result.server.oauth ? {
+            oauth: result.server.oauth
+        } : {})
+    };
+}
+
+export { getMcpGenerationSchema, normalizeMcpGeneratedConfiguration };

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

@@ -0,0 +1,7 @@
+import { URI } from "../../../../sessions/sessions.web.main.internal.js";
+export declare const IMcpCopilotGlobalConfigurationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IMcpCopilotGlobalConfigurationService>;
+export interface IMcpCopilotGlobalConfigurationService {
+    readonly _serviceBrand: undefined;
+    /** Resolves the configuration on the window's agent-host machine, or undefined when unavailable. */
+    getConfigurationResource(): Promise<URI | undefined>;
+}

package/vscode/src/vs/workbench/contrib/mcp/common/mcpCopilotGlobalConfigurationService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IMcpCopilotGlobalConfigurationService = ( createDecorator("mcpCopilotGlobalConfigurationService"));
+
+export { IMcpCopilotGlobalConfigurationService };

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

@@ -78,8 +78,7 @@ let McpDevModeServerAttache = class McpDevModeServerAttache extends Disposable {
             const includes = pattern.filter(p => !p.startsWith("!"));
             const excludes = pattern.filter(p => p.startsWith("!")).map(p => p.slice(1));
             reader.store.add(fileService.watch(wf, {
-                includes,
-                excludes,
+                excludes: [],
                 recursive: true
             }));
             const ignoreCase = !fileService.hasCapability(wf, FileSystemProviderCapabilities.PathCaseSensitive);
@@ -134,7 +133,7 @@ let McpDevModeDebugging = class McpDevModeDebugging {
             {
                 if (!/node[0-9]*$/.test(launch.command)) {
                     throw ( new Error(( localize(
-                        16373,
+                        18858,
                         "MCP server must be launched with the \"node\" executable to enable debugging, but was launched with \"{0}\"",
                         launch.command
                     ))));
@@ -158,7 +157,7 @@ let McpDevModeDebugging = class McpDevModeDebugging {
             {
                 if (!/python[0-9.]*$/.test(launch.command)) {
                     throw ( new Error(( localize(
-                        16374,
+                        18859,
                         "MCP server must be launched with the \"python\" executable to enable debugging, but was launched with \"{0}\"",
                         launch.command
                     ))));

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

@@ -22,6 +22,11 @@ export interface IMcpHostDelegate {
     waitForInitialProviderPromises(): Promise<void>;
     canStart(collectionDefinition: McpCollectionDefinition, serverDefinition: McpServerDefinition): boolean;
     substituteVariables(serverDefinition: McpServerDefinition, launch: McpServerLaunch): Promise<McpServerLaunch>;
+    /**
+     * Applies the definition's {@link McpServerDefinition.environmentVariableExpansion} to
+     * the launch, using the environment of the host that will run or connect to the server.
+     */
+    expandEnvironmentVariables(serverDefinition: McpServerDefinition, launch: McpServerLaunch): Promise<McpServerLaunch>;
     start(collectionDefinition: McpCollectionDefinition, serverDefinition: McpServerDefinition, resolvedLaunch: McpServerLaunch, options?: {
         errorOnUserInteraction?: boolean;
     }): IMcpMessageTransport;

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

@@ -38,6 +38,6 @@ export interface IMcpRegistry {
     getSavedInputs(scope: StorageScope): Promise<{
         [id: string]: IResolvedValue;
     }>;
-    /** Creates a connection for the collection and definition. */
+    /** Creates a connection, or returns undefined if startup is cancelled or the collection or definition is no longer registered. */
     resolveConnection(options: IMcpResolveConnectionOptions): Promise<IMcpServerConnection | undefined>;
 }

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

@@ -171,20 +171,10 @@ export declare class McpServer extends Disposable implements IMcpServer {
     readonly collection: McpCollectionReference;
     private readonly _connectionSequencer;
     private readonly _connection;
+    private readonly _resolvedPolicyIdentity;
     readonly connection: import("../../../../base/common/observable.js").ISettableObservable<IMcpServerConnection | undefined, void> & IDisposable;
-    /**
-     * Reactively evaluates the `chat.mcp.allowedServers` / `chat.mcp.deniedServers` policy against
-     * this server's identity. Holds an error state while blocked, `undefined` while allowed.
-     *
-     * Being a derived, it recomputes whenever the policy changes (via {@link _policyEpoch}), the
-     * server definition changes, or a connection resolves — so it always evaluates the *resolved*
-     * launch of a live connection and falls back to the definition otherwise. This also means a
-     * blocked server surfaces the block at rest (before any start), which hides its cached tools
-     * and prompts and lets the UI show the reason.
-     *
-     * Initialized in the constructor because it depends on the injected allowed-servers service.
-     */
     private readonly _policyEpoch;
+    /** Retains policy enforcement for the last resolved launch while its definition is unchanged. */
     private readonly _policyBlock;
     readonly connectionState: IObservable<McpConnectionState>;
     private readonly _capabilities;
@@ -224,12 +214,7 @@ export declare class McpServer extends Disposable implements IMcpServer {
     resourceTemplates(token?: CancellationToken): Promise<IMcpResourceTemplate[]>;
     private _identityFromLaunch;
     private _evaluatePolicy;
-    /**
-     * Whether the URL/command fields matched by the policy still contain unresolved `${...}`
-     * configuration variables. When they do, matching against allow/deny URL or command rules is
-     * unreliable, so the block is deferred until the launch is resolved. The server name is used
-     * verbatim and is not considered here.
-     */
+    /** Whether policy URL/command fields contain unresolved configuration variables; the server name is literal. */
     private static _hasUnresolvedVariables;
     start({ interaction, autoTrustChanges, promptType, debug, errorOnUserInteraction }?: IMcpServerStartOpts): Promise<McpConnectionState>;
     private showInteractiveError;

package/vscode/src/vs/workbench/contrib/mcp/common/mcpServer.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 { hasConfigurationVariable } from '../../../../platform/configuration/common/configurationVariables.js';
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { IAllowedMcpServersService } from '../../../../platform/mcp/common/mcpManagement.service.js';
@@ -27,7 +28,6 @@ import { StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
-import { ConfigurationResolverExpression } from '../../../services/configurationResolver/common/configurationResolverExpression.js';
 import { IEditorService } from '../../../services/editor/common/editorService.service.js';
 import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.service.js';
 import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
@@ -39,17 +39,18 @@ import { McpIcons, parseAndValidateMcpIcon } from './mcpIcons.js';
 import { IMcpRegistry } from './mcpRegistryTypes.service.js';
 import { IMcpSandboxService } from './mcpSandboxService.service.js';
 import { McpTaskManager } from './mcpTaskManager.js';
-import { McpToolName, McpConnectionState, McpConnectionFailedError, McpServerCacheState, McpServerStaticToolAvailability, McpServerTransportType, extensionMcpCollectionPrefix, UserInteractionRequiredError, McpToolVisibility, mcpPromptReplaceSpecialChars, McpCapability, MpcResponseError, ElicitationKind, McpResourceURI } from './mcpTypes.js';
+import { McpToolName, McpConnectionState, McpConnectionFailedError, McpServerCacheState, McpServerDefinition, McpServerStaticToolAvailability, McpServerTransportType, extensionMcpCollectionPrefix, UserInteractionRequiredError, 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 '../../../../base/common/uriTemplate.js';
 import { observableValue, disposableObservableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 import { derived, derivedDisposable } from '../../../../base/common/observableInternal/observables/derived.js';
-import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { observableSignalFromEvent } from '../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
 import { autorun, autorunSelfDisposable } from '../../../../base/common/observableInternal/reactions/autorun.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
 import { ObservablePromise } from '../../../../base/common/observableInternal/utils/promise.js';
-import Severity$1 from '../../../../base/common/severity.js';
 import { transaction } from '../../../../base/common/observableInternal/transaction.js';
+import Severity$1 from '../../../../base/common/severity.js';
 
 var McpServer_1;
 const emptyToolEntry = {
@@ -295,6 +296,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         this._taskManager = this._register(( new McpTaskManager()));
         this._connectionSequencer = ( new Sequencer());
         this._connection = this._register(disposableObservableValue(this, undefined));
+        this._resolvedPolicyIdentity = observableValue(this, undefined);
         this.connection = this._connection;
         this.connectionState = derived(
             reader => this._policyBlock.read(reader) ?? this._connection.read(reader)?.state.read(reader) ?? {
@@ -342,28 +344,30 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         this.collection = initialCollection;
         this._fullDefinitions = this._mcpRegistry.getServerDefinition(this.collection, this.definition);
         this.enablement = derived(r => enablementModel.readEnabled(definition.id, r));
-        this._policyEpoch = observableFromEvent(
-            this,
-            this._allowedMcpServersService.onDidChangeAllowedMcpServers,
-            () => undefined
-        );
+        this._policyEpoch = observableSignalFromEvent(this, this._allowedMcpServersService.onDidChangeAllowedMcpServers);
         this._policyBlock = derived(this, reader => {
             this._policyEpoch.read(reader);
             const connection = this._connection.read(reader);
             if (connection) {
                 return this._evaluatePolicy(this._identityFromLaunch(connection.launchDefinition));
             }
-            const launch = this._fullDefinitions.read(reader).server?.launch;
-            if (!launch) {
-                return undefined;
+            const definition = this._fullDefinitions.read(reader).server;
+            const resolved = this._resolvedPolicyIdentity.read(reader);
+            if (resolved && definition && McpServerDefinition.equals(resolved.definition, definition)) {
+                return this._evaluatePolicy(resolved.identity);
             }
-            const identity = this._identityFromLaunch(launch);
-            if (McpServer_1._hasUnresolvedVariables(identity)) {
+            const launch = definition?.launch;
+            if (!launch) {
                 return undefined;
             }
-            return this._evaluatePolicy(identity);
+            return this._evaluatePolicy(this._identityFromLaunch(launch), "definition");
         });
         this._register(autorun(reader => {
+            const resolved = this._resolvedPolicyIdentity.read(reader);
+            const definition = this._fullDefinitions.read(reader).server;
+            if (resolved && (!definition || !McpServerDefinition.equals(resolved.definition, definition))) {
+                this._resolvedPolicyIdentity.set(undefined, undefined);
+            }
             if (this._policyBlock.read(reader) && this._connection.read(undefined)) {
                 this._connection.set(undefined, undefined);
             }
@@ -505,16 +509,15 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
             name: this.definition.label
         };
     }
-    _evaluatePolicy(identity) {
-        const allowed = this._allowedMcpServersService.isServerAllowed(identity);
+    _evaluatePolicy(identity, phase = "resolved") {
+        const allowed = phase === "definition" ? this._allowedMcpServersService.isServerAllowedBeforeResolution(identity) : this._allowedMcpServersService.isServerAllowed(identity);
         return allowed === true ? undefined : {
             state: McpConnectionState.Kind.Error,
             message: allowed.value
         };
     }
     static _hasUnresolvedVariables(identity) {
-        const variableMarker = ConfigurationResolverExpression.VARIABLE_LHS;
-        return !!identity.url?.includes(variableMarker) || !!identity.command?.some(arg => arg.includes(variableMarker));
+        return (identity.url !== undefined && hasConfigurationVariable(identity.url)) || (identity.command?.some(hasConfigurationVariable) ?? false);
     }
     start(
         {
@@ -531,7 +534,12 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         return this._connectionSequencer.queue(async () => {
             const preStartBlock = this._policyBlock.get();
             if (preStartBlock) {
-                return preStartBlock;
+                const definition = this._fullDefinitions.get().server;
+                const identity = definition && this._identityFromLaunch(definition.launch);
+                const canResolveAgain = !errorOnUserInteraction && this._resolvedPolicyIdentity.get() && identity && McpServer_1._hasUnresolvedVariables(identity) && !this._evaluatePolicy(identity, "definition");
+                if (!canResolveAgain) {
+                    return preStartBlock;
+                }
             }
             const activationEvent = mcpActivationEvent(this.collection.id.slice(extensionMcpCollectionPrefix.length));
             if (this._requiresExtensionActivation && !this._extensionService.activationEventIsDone(activationEvent)) {
@@ -585,12 +593,19 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                         state: McpConnectionState.Kind.Stopped
                     };
                 }
-                this._connection.set(connection, undefined);
+                const resolvedPolicyIdentity = {
+                    definition: connection.definition,
+                    identity: this._identityFromLaunch(connection.launchDefinition)
+                };
+                transaction(tx => {
+                    this._resolvedPolicyIdentity.set(resolvedPolicyIdentity, tx);
+                    this._connection.set(connection, tx);
+                });
                 if (connection.definition.devMode) {
                     this.showOutput();
                 }
             }
-            const resolvedBlock = this._policyBlock.get();
+            const resolvedBlock = this._evaluatePolicy(this._identityFromLaunch(connection.launchDefinition));
             if (resolvedBlock) {
                 this._connection.set(undefined, undefined);
                 return resolvedBlock;
@@ -621,6 +636,10 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                     return r.value;
                 }
             });
+            const policyBlock = this._policyBlock.get();
+            if (policyBlock) {
+                return policyBlock;
+            }
             this._telemetryService.publicLog2("mcp/serverBootState", {
                 state: McpConnectionState.toKindString(state.state),
                 time: Date.now() - start
@@ -670,7 +689,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         if (cnx.definition.sandboxEnabled) {
             if (!this.showSandboxConfigSuggestionFromPotentialBlocks(cnx, this._potentialSandboxBlocks)) {
                 this._notificationService.warn(( localize(
-                    16407,
+                    18893,
                     "The MCP server {0} could not be started: {1}",
                     cnx.definition.label,
                     error.message
@@ -695,36 +714,36 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 break;
             }
             const options = [{
-                label: ( localize(16408, "Show Output")),
+                label: ( localize(18894, "Show Output")),
                 run: () => this.showOutput()
             }];
             if (cnx.definition.devMode?.debug?.type === "debugpy" && debug) {
                 this._notificationService.prompt(Severity$1.Error, ( localize(
-                    16409,
+                    18895,
                     "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(16410, "View Docs")),
+                    label: ( localize(18896, "View Docs")),
                     run: () => this._openerService.open(( URI.parse("https://aka.ms/vscode-mcp-install/debugpy")))
                 }]);
                 return;
             }
             if (docsLink) {
                 options.push({
-                    label: ( localize(16411, "Install {0}", cnx.launchDefinition.command)),
+                    label: ( localize(18897, "Install {0}", cnx.launchDefinition.command)),
                     run: () => this._openerService.open(( URI.parse(docsLink)))
                 });
             }
             this._notificationService.prompt(Severity$1.Error, ( localize(
-                16412,
+                18898,
                 "The command \"{0}\" needed to run {1} was not found.",
                 cnx.launchDefinition.command,
                 cnx.definition.label
             )), options);
         } else {
             this._notificationService.warn(( localize(
-                16407,
+                18893,
                 "The MCP server {0} could not be started: {1}",
                 cnx.definition.label,
                 error.message
@@ -738,7 +757,8 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         if (this._isQuietStart) {
             throw ( new UserInteractionRequiredError("sandbox-suggestion"));
         }
-        const existingSandboxConfig = this._fullDefinitions.get().collection?.sandbox;
+        const launch = this._fullDefinitions.get().server?.launch ?? cnx.definition.launch;
+        const existingSandboxConfig = launch.type === McpServerTransportType.Stdio ? launch.sandbox : undefined;
         const suggestion = this._mcpSandboxService.getSandboxConfigSuggestionMessage(cnx.definition.label, potentialBlocks, existingSandboxConfig);
         if (!suggestion) {
             this._removePotentialSandboxBlocks(potentialBlocks);
@@ -754,20 +774,20 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         void this._dialogService.confirm({
             type: "warning",
             message: ( localize(
-                16413,
+                18899,
                 "Update sandbox configuration in mcp.json for {0}?",
                 cnx.definition.label
             )),
             detail: suggestion.message,
-            primaryButton: ( localize(16414, "Yes")),
-            cancelButton: ( localize(16415, "No"))
+            primaryButton: ( localize(18900, "Yes")),
+            cancelButton: ( localize(18901, "No"))
         }).then(async result => {
             if (!result.confirmed) {
                 return;
             }
             if (!mcpResource || configTarget === undefined) {
                 this._notificationService.warn(( localize(
-                    16416,
+                    18902,
                     "Couldn't determine where to update sandbox configuration for {0}.",
                     cnx.definition.label
                 )));
@@ -784,14 +804,14 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
                 if (updated) {
                     this._removePotentialSandboxBlocks(potentialBlocks);
                     this._notificationService.info(( localize(
-                        16417,
+                        18903,
                         "Updated sandbox configuration for {0} in mcp.json. Restart server.",
                         cnx.definition.label
                     )));
                 }
             } catch (e) {
                 this._notificationService.error(( localize(
-                    16418,
+                    18904,
                     "Failed to update sandbox configuration for {0}: {1}",
                     cnx.definition.label,
                     e instanceof Error ? e.message : String(e)
@@ -900,7 +920,7 @@ let McpServer = McpServer_1 = class McpServer extends Disposable {
         const validated = [];
         for (const [i, result] of validations.entries()) {
             if ("error" in result) {
-                error += ( localize(16419, "Tool `{0}` has invalid JSON parameters:", tools[i].name)) + "\n";
+                error += ( localize(18905, "Tool `{0}` has invalid JSON parameters:", tools[i].name)) + "\n";
                 for (const message of result.error) {
                     error += `\t- ${message}\n`;
                 }
@@ -1233,7 +1253,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
         notificationService.notify({
             severity: Severity$1.Warning,
             message: ( localize(
-                16420,
+                18906,
                 "MCP server `{0}` has tools with invalid parameters which will be omitted.",
                 serverName
             )),
@@ -1243,7 +1263,7 @@ function warnInvalidTools(instaService, serverName, errorText) {
                     enabled: true,
                     id: "mcpBadSchema.show",
                     tooltip: "",
-                    label: ( localize(16421, "Show")),
+                    label: ( localize(18907, "Show")),
                     run: () => {
                         editorService.openEditor({
                             resource: undefined,

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

@@ -0,0 +1,95 @@
+import { IMcpServerConfiguration } from "../../../../platform/mcp/common/mcpPlatformTypes.js";
+import { McpResourceFormat } from "../../../../platform/mcp/common/mcpWorkspaceConfiguration.js";
+/**
+ * The server kinds offered by the configuration form. `Http` and `Sse` both
+ * persist as {@link McpServerType.REMOTE}; `Sse` additionally pins `transport: 'sse'`.
+ */
+export declare enum McpServerFormKind {
+    Stdio = "stdio",
+    Http = "http",
+    Sse = "sse"
+}
+export interface IMcpServerFormKeyValue {
+    name: string;
+    value: string;
+    /**
+     * Name of the entry in the configuration this row was loaded from, used to merge the row with
+     * later changes to the file. Absent for rows the user added.
+     */
+    origin?: string;
+}
+/**
+ * Editable, string-based representation of an MCP server configuration.
+ */
+export interface IMcpServerFormState {
+    kind: McpServerFormKind;
+    command: string;
+    args: string;
+    cwd: string;
+    envFile: string;
+    env: IMcpServerFormKeyValue[];
+    url: string;
+    headers: IMcpServerFormKeyValue[];
+}
+/**
+ * Validation messages keyed by form field. A field without a message is valid.
+ * `format` reports configuration the destination file cannot represent.
+ */
+export interface IMcpServerFormValidation {
+    command?: string;
+    args?: string;
+    url?: string;
+    env?: string;
+    headers?: string;
+    format?: string;
+}
+/**
+ * The parts of a configuration that a file format can store. `.mcp.json` and the
+ * Copilot CLI's `mcp-config.json` are shared with other clients and support less than `mcp.json`.
+ */
+export interface IMcpServerFormCapabilities {
+    readonly kinds: readonly McpServerFormKind[];
+    readonly envFile: boolean;
+    readonly cwd: boolean;
+    /** Whether VS Code `${input:...}` variables are resolved for this file. */
+    readonly inputVariables: boolean;
+}
+export declare function getMcpServerFormCapabilities(format: McpResourceFormat): IMcpServerFormCapabilities;
+/**
+ * Explains why changing {@link previous} to {@link config} cannot be saved to a file of the given
+ * {@link format}, if it cannot. Only the edit is checked, so properties already in the file that
+ * the format does not support never block saving.
+ */
+export declare function getMcpServerFormatError(name: string, previous: IMcpServerConfiguration, config: IMcpServerConfiguration, format: McpResourceFormat): string | undefined;
+export declare function toMcpServerFormState(config: IMcpServerConfiguration): IMcpServerFormState;
+/**
+ * Formats arguments as a space separated list, or as a JSON array when an
+ * argument would not survive a round trip through {@link parseMcpServerArgs}.
+ */
+export declare function formatMcpServerArgs(args: readonly string[] | undefined): string;
+/**
+ * Parses arguments entered as a space separated list or as a JSON array of strings.
+ */
+export declare function parseMcpServerArgs(value: string): {
+    readonly args: string[];
+    readonly error?: string;
+};
+export declare function validateMcpServerFormState(state: IMcpServerFormState): IMcpServerFormValidation;
+/**
+ * Three-way merges name/value rows after the configuration file changed while the form had unsaved
+ * edits. {@link base} is the configuration the edits were made against, {@link local} the rows in
+ * the form and {@link remote} the configuration now in the file. Rows the user added, removed,
+ * renamed or changed keep the user's edit; all other rows take the file's current entry, and entries
+ * the file added are appended. Rows taken from the file are copies, so {@link remote} is not shared.
+ */
+export declare function mergeMcpServerFormKeyValues(base: readonly IMcpServerFormKeyValue[], local: readonly IMcpServerFormKeyValue[], remote: readonly IMcpServerFormKeyValue[]): IMcpServerFormKeyValue[];
+export declare function isMcpServerFormValid(validation: IMcpServerFormValidation): boolean;
+/**
+ * Builds the configuration to persist from the form state. Properties the form
+ * does not edit (for example `gallery`, `dev`, `oauth` or `sandboxEnabled`) are
+ * preserved from {@link original} as long as the server kind does not change, and
+ * env values keep their original `number`/`null` types when left unchanged.
+ *
+ * Callers should validate the state with {@link validateMcpServerFormState} first.
+ */
+export declare function toMcpServerConfiguration(state: IMcpServerFormState, original: IMcpServerConfiguration): IMcpServerConfiguration;