@codingame/monaco-vscode-mcp-service-override 16.0.0

package/index.d.ts

@@ -0,0 +1,2 @@
+import { type IEditorOverrideServices } from "@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices";
+export default function getServiceOverride(): IEditorOverrideServices;

package/index.js

@@ -0,0 +1,20 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/editor/standalone/browser/standaloneServices';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { IMcpConfigPathsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service';
+import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpConfigPathsService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpConfigPathsService.js';
+import { McpService } from './vscode/src/vs/workbench/contrib/mcp/common/mcpService.js';
+import { McpRegistry } from './vscode/src/vs/workbench/contrib/mcp/common/mcpRegistry.js';
+import './vscode/src/vs/workbench/contrib/mcp/browser/mcp.contribution.js';
+
+function getServiceOverride() {
+    return {
+        [IMcpConfigPathsService.toString()]: new SyncDescriptor(McpConfigPathsService, [], true),
+        [IMcpService.toString()]: new SyncDescriptor(McpService, [], true),
+        [IMcpRegistry.toString()]: new SyncDescriptor(McpRegistry, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@codingame/monaco-vscode-mcp-service-override",
+  "version": "16.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - mcp service-override",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-2b1a9082-790f-527f-b013-d1b29d6265a3-common": "16.0.0",
+    "@codingame/monaco-vscode-4a3ac544-9a61-534c-88df-756262793ef7-common": "16.0.0",
+    "@codingame/monaco-vscode-ae8a8ca1-f243-508b-9c37-c88ebbd295fa-common": "16.0.0",
+    "@codingame/monaco-vscode-api": "16.0.0",
+    "@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common": "16.0.0"
+  },
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/platform/mcp/common/nativeMcpDiscoveryHelper.d.ts

@@ -0,0 +1,9 @@
+import { Platform } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export declare const NativeMcpDiscoveryHelperChannelName = "NativeMcpDiscoveryHelper";
+export interface INativeMcpDiscoveryData {
+    platform: Platform;
+    homedir: URI;
+    winAppData?: URI;
+    xdgHome?: URI;
+}

package/vscode/src/vs/platform/mcp/common/nativeMcpDiscoveryHelper.js

@@ -0,0 +1,5 @@
+
+
+const NativeMcpDiscoveryHelperChannelName = 'NativeMcpDiscoveryHelper';
+
+export { NativeMcpDiscoveryHelperChannelName };

package/vscode/src/vs/workbench/contrib/mcp/browser/mcp.contribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/workbench/contrib/mcp/browser/mcp.contribution.js

@@ -0,0 +1,47 @@
+
+import { registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { mcpSchemaId } from '@codingame/monaco-vscode-2b1a9082-790f-527f-b013-d1b29d6265a3-common/vscode/vs/workbench/services/configuration/common/configuration';
+import { ConfigMcpDiscovery } from '../common/discovery/configMcpDiscovery.js';
+import { ExtensionMcpDiscovery } from '../common/discovery/extensionMcpDiscovery.js';
+import { mcpDiscoveryRegistry } from '../common/discovery/mcpDiscovery.js';
+import { RemoteNativeMpcDiscovery } from '../common/discovery/nativeMcpRemoteDiscovery.js';
+import { CursorWorkspaceMcpDiscoveryAdapter } from '../common/discovery/workspaceMcpDiscoveryAdapter.js';
+import '../common/mcpConfigPathsService.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { mcpServerSchema } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { McpContextKeysController } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpContextKeys';
+import '../common/mcpRegistry.js';
+import '../common/mcpService.js';
+import { ListMcpServerCommand, McpServerOptionsCommand, ResetMcpTrustCommand, ResetMcpCachedTools, AddConfigurationAction, RemoveStoredInput, EditStoredInput, StartServer, StopServer, ShowOutput, InstallFromActivation, RestartServer, MCPServerActionRendering } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/browser/mcpCommands';
+import { McpDiscovery } from './mcpDiscovery.js';
+import { McpLanguageFeatures } from './mcpLanguageFeatures.js';
+import { McpUrlHandler } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/browser/mcpUrlHandler';
+
+mcpDiscoveryRegistry.register(( new SyncDescriptor(RemoteNativeMpcDiscovery)));
+mcpDiscoveryRegistry.register(( new SyncDescriptor(ConfigMcpDiscovery)));
+mcpDiscoveryRegistry.register(( new SyncDescriptor(ExtensionMcpDiscovery)));
+mcpDiscoveryRegistry.register(( new SyncDescriptor(CursorWorkspaceMcpDiscoveryAdapter)));
+registerWorkbenchContribution2('mcpDiscovery', McpDiscovery, WorkbenchPhase.AfterRestored);
+registerWorkbenchContribution2('mcpContextKeys', McpContextKeysController, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2('mcpLanguageFeatures', McpLanguageFeatures, WorkbenchPhase.Eventually);
+registerWorkbenchContribution2('mcpUrlHandler', McpUrlHandler, WorkbenchPhase.BlockRestore);
+registerAction2(ListMcpServerCommand);
+registerAction2(McpServerOptionsCommand);
+registerAction2(ResetMcpTrustCommand);
+registerAction2(ResetMcpCachedTools);
+registerAction2(AddConfigurationAction);
+registerAction2(RemoveStoredInput);
+registerAction2(EditStoredInput);
+registerAction2(StartServer);
+registerAction2(StopServer);
+registerAction2(ShowOutput);
+registerAction2(InstallFromActivation);
+registerAction2(RestartServer);
+registerWorkbenchContribution2('mcpActionRendering', MCPServerActionRendering, WorkbenchPhase.BlockRestore);
+const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
+jsonRegistry.registerSchema(mcpSchemaId, mcpServerSchema);

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpDiscovery.d.ts

@@ -0,0 +1,8 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+export declare class McpDiscovery extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "workbench.contrib.mcp.discovery";
+    constructor(instantiationService: IInstantiationService, configurationService: IConfigurationService);
+}

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpDiscovery.js

@@ -0,0 +1,36 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { mcpDiscoveryRegistry } from '../common/discovery/mcpDiscovery.js';
+import { mcpEnabledSection } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+let McpDiscovery = class McpDiscovery extends Disposable {
+    static { this.ID = 'workbench.contrib.mcp.discovery'; }
+    constructor(instantiationService, configurationService) {
+        super();
+        const enabled = observableConfigValue(mcpEnabledSection, true, configurationService);
+        const store = this._register(( new DisposableStore()));
+        this._register(autorun(reader => {
+            if (enabled.read(reader)) {
+                for (const discovery of mcpDiscoveryRegistry.getAll()) {
+                    const inst = store.add(instantiationService.createInstance(discovery));
+                    inst.start();
+                }
+            }
+            else {
+                store.clear();
+            }
+        }));
+    }
+};
+McpDiscovery = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IConfigurationService))
+], McpDiscovery));
+
+export { McpDiscovery };

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpLanguageFeatures.d.ts

@@ -0,0 +1,21 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { IMarkerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
+import { IMcpConfigPathsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
+export declare class McpLanguageFeatures extends Disposable implements IWorkbenchContribution {
+    private readonly _mcpRegistry;
+    private readonly _mcpConfigPathsService;
+    private readonly _mcpService;
+    private readonly _markerService;
+    private readonly _configurationResolverService;
+    private readonly _cachedMcpSection;
+    constructor(languageFeaturesService: ILanguageFeaturesService, _mcpRegistry: IMcpRegistry, _mcpConfigPathsService: IMcpConfigPathsService, _mcpService: IMcpService, _markerService: IMarkerService, _configurationResolverService: IConfigurationResolverService);
+    private _parseModel;
+    private _addDiagnostics;
+    private _provideCodeLenses;
+    private _provideInlayHints;
+}

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpLanguageFeatures.js

@@ -0,0 +1,340 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { computeLevenshteinDistance } from '@codingame/monaco-vscode-api/vscode/vs/base/common/diff/diff';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString, markdownCommandLink } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { parseTree, findNodeAtLocation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { Disposable, MutableDisposable, dispose, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
+import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
+import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
+import { IMcpConfigPathsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service';
+import { mcpConfigurationSection } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
+import { McpConnectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { StartServer, ShowOutput, StopServer, RestartServer, EditStoredInput, RemoveStoredInput } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/browser/mcpCommands';
+
+const diagnosticOwner = 'vscode.mcp';
+let McpLanguageFeatures = class McpLanguageFeatures extends Disposable {
+    constructor(languageFeaturesService, _mcpRegistry, _mcpConfigPathsService, _mcpService, _markerService, _configurationResolverService) {
+        super();
+        this._mcpRegistry = _mcpRegistry;
+        this._mcpConfigPathsService = _mcpConfigPathsService;
+        this._mcpService = _mcpService;
+        this._markerService = _markerService;
+        this._configurationResolverService = _configurationResolverService;
+        this._cachedMcpSection = this._register(( new MutableDisposable()));
+        const patterns = [
+            { pattern: '**/.vscode/mcp.json' },
+            { pattern: '**/settings.json' },
+            { pattern: '**/workspace.json' },
+        ];
+        const onDidChangeCodeLens = this._register(( new Emitter()));
+        const codeLensProvider = {
+            onDidChange: onDidChangeCodeLens.event,
+            provideCodeLenses: (model, range) => this._provideCodeLenses(model, () => onDidChangeCodeLens.fire(codeLensProvider)),
+        };
+        this._register(languageFeaturesService.codeLensProvider.register(patterns, codeLensProvider));
+        this._register(languageFeaturesService.inlayHintsProvider.register(patterns, {
+            onDidChangeInlayHints: _mcpRegistry.onDidChangeInputs,
+            provideInlayHints: (model, range) => this._provideInlayHints(model, range),
+        }));
+    }
+    _parseModel(model) {
+        if (this._cachedMcpSection.value?.model === model) {
+            return this._cachedMcpSection.value;
+        }
+        const uri = model.uri;
+        const inConfig = this._mcpConfigPathsService.paths.get().find(u => isEqual(u.uri, uri));
+        if (!inConfig) {
+            return undefined;
+        }
+        const value = model.getValue();
+        const tree = parseTree(value);
+        const listeners = [
+            model.onDidChangeContent(() => this._cachedMcpSection.clear()),
+            model.onWillDispose(() => this._cachedMcpSection.clear()),
+        ];
+        this._addDiagnostics(model, value, tree, inConfig);
+        return this._cachedMcpSection.value = {
+            model,
+            tree,
+            inConfig,
+            dispose: () => {
+                this._markerService.remove(diagnosticOwner, [uri]);
+                dispose(listeners);
+            }
+        };
+    }
+    _addDiagnostics(tm, value, tree, inConfig) {
+        const serversNode = findNodeAtLocation(tree, inConfig.section ? [...inConfig.section, 'servers'] : ['servers']);
+        if (!serversNode) {
+            return;
+        }
+        const getClosestMatchingVariable = (name) => {
+            let bestValue = '';
+            let bestDistance = Infinity;
+            for (const variable of this._configurationResolverService.resolvableVariables) {
+                const distance = computeLevenshteinDistance(name, variable);
+                if (distance < bestDistance) {
+                    bestDistance = distance;
+                    bestValue = variable;
+                }
+            }
+            return bestValue;
+        };
+        const diagnostics = [];
+        forEachPropertyWithReplacement(serversNode, node => {
+            const expr = ConfigurationResolverExpression.parse(node.value);
+            for (const { id, name, arg } of expr.unresolved()) {
+                if (!( this._configurationResolverService.resolvableVariables.has(name))) {
+                    const position = value.indexOf(id, node.offset);
+                    if (position === -1) {
+                        continue;
+                    }
+                    const start = tm.getPositionAt(position);
+                    const end = tm.getPositionAt(position + id.length);
+                    diagnostics.push({
+                        severity: MarkerSeverity.Warning,
+                        message: ( localize(
+                            7618,
+                            'Variable `{0}` not found, did you mean ${{1}}?',
+                            name,
+                            getClosestMatchingVariable(name) + (arg ? `:${arg}` : '')
+                        )),
+                        startLineNumber: start.lineNumber,
+                        startColumn: start.column,
+                        endLineNumber: end.lineNumber,
+                        endColumn: end.column,
+                        modelVersionId: tm.getVersionId(),
+                    });
+                }
+            }
+        });
+        if (diagnostics.length) {
+            this._markerService.changeOne(diagnosticOwner, tm.uri, diagnostics);
+        }
+        else {
+            this._markerService.remove(diagnosticOwner, [tm.uri]);
+        }
+    }
+    _provideCodeLenses(model, onDidChangeCodeLens) {
+        const parsed = this._parseModel(model);
+        if (!parsed) {
+            return undefined;
+        }
+        const { tree, inConfig } = parsed;
+        const serversNode = findNodeAtLocation(tree, inConfig.section ? [...inConfig.section, 'servers'] : ['servers']);
+        if (!serversNode) {
+            return undefined;
+        }
+        const store = ( new DisposableStore());
+        const lenses = { lenses: [], dispose: () => store.dispose() };
+        const read = (observable) => {
+            store.add(Event.fromObservableLight(observable)(onDidChangeCodeLens));
+            return observable.get();
+        };
+        const collection = read(this._mcpRegistry.collections).find(c => isEqual(c.presentation?.origin, model.uri));
+        if (!collection) {
+            return lenses;
+        }
+        const mcpServers = read(this._mcpService.servers).filter(s => s.collection.id === collection.id);
+        for (const node of serversNode.children || []) {
+            if (node.type !== 'property' || node.children?.[0]?.type !== 'string') {
+                continue;
+            }
+            const name = node.children[0].value;
+            const server = mcpServers.find(s => s.definition.label === name);
+            if (!server) {
+                continue;
+            }
+            const range = Range.fromPositions(model.getPositionAt(node.children[0].offset));
+            switch (read(server.connectionState).state) {
+                case McpConnectionState.Kind.Error:
+                    lenses.lenses.push({
+                        range,
+                        command: {
+                            id: ShowOutput.ID,
+                            title: '$(error) ' + ( localize(7619, 'Error')),
+                            arguments: [server.definition.id],
+                        },
+                    }, {
+                        range,
+                        command: {
+                            id: RestartServer.ID,
+                            title: ( localize(7620, "Restart")),
+                            arguments: [server.definition.id],
+                        },
+                    });
+                    break;
+                case McpConnectionState.Kind.Starting:
+                    lenses.lenses.push({
+                        range,
+                        command: {
+                            id: ShowOutput.ID,
+                            title: '$(loading~spin) ' + ( localize(7621, 'Starting')),
+                            arguments: [server.definition.id],
+                        },
+                    }, {
+                        range,
+                        command: {
+                            id: StopServer.ID,
+                            title: ( localize(7622, "Cancel")),
+                            arguments: [server.definition.id],
+                        },
+                    });
+                    break;
+                case McpConnectionState.Kind.Running:
+                    lenses.lenses.push({
+                        range,
+                        command: {
+                            id: ShowOutput.ID,
+                            title: '$(check) ' + ( localize(7623, 'Running')),
+                            arguments: [server.definition.id],
+                        },
+                    }, {
+                        range,
+                        command: {
+                            id: StopServer.ID,
+                            title: ( localize(7624, "Stop")),
+                            arguments: [server.definition.id],
+                        },
+                    }, {
+                        range,
+                        command: {
+                            id: RestartServer.ID,
+                            title: ( localize(7620, "Restart")),
+                            arguments: [server.definition.id],
+                        },
+                    }, {
+                        range,
+                        command: {
+                            id: '',
+                            title: ( localize(7625, '{0} tools', read(server.tools).length)),
+                        },
+                    });
+                    break;
+                case McpConnectionState.Kind.Stopped: {
+                    lenses.lenses.push({
+                        range,
+                        command: {
+                            id: StartServer.ID,
+                            title: '$(debug-start) ' + ( localize(7626, "Start")),
+                            arguments: [server.definition.id],
+                        },
+                    });
+                    const toolCount = read(server.tools).length;
+                    if (toolCount) {
+                        lenses.lenses.push({
+                            range,
+                            command: {
+                                id: '',
+                                title: ( localize(7627, '{0} cached tools', toolCount)),
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        return lenses;
+    }
+    async _provideInlayHints(model, range) {
+        const parsed = this._parseModel(model);
+        if (!parsed) {
+            return undefined;
+        }
+        const { tree, inConfig } = parsed;
+        const mcpSection = inConfig.section ? findNodeAtLocation(tree, [...inConfig.section]) : tree;
+        if (!mcpSection) {
+            return undefined;
+        }
+        const inputsNode = findNodeAtLocation(mcpSection, ['inputs']);
+        if (!inputsNode) {
+            return undefined;
+        }
+        const inputs = await this._mcpRegistry.getSavedInputs(inConfig.scope);
+        const hints = [];
+        const serversNode = findNodeAtLocation(mcpSection, ['servers']);
+        if (serversNode) {
+            annotateServers(serversNode);
+        }
+        annotateInputs(inputsNode);
+        return { hints, dispose: () => { } };
+        function annotateServers(servers) {
+            forEachPropertyWithReplacement(servers, node => {
+                const expr = ConfigurationResolverExpression.parse(node.value);
+                for (const { id } of expr.unresolved()) {
+                    const saved = inputs[id];
+                    if (saved) {
+                        pushAnnotation(id, node.offset + node.value.indexOf(id) + id.length, saved);
+                    }
+                }
+            });
+        }
+        function annotateInputs(node) {
+            if (node.type !== 'array' || !node.children) {
+                return;
+            }
+            for (const input of node.children) {
+                if (input.type !== 'object' || !input.children) {
+                    continue;
+                }
+                const idProp = input.children.find(c => c.type === 'property' && c.children?.[0].value === 'id');
+                if (!idProp) {
+                    continue;
+                }
+                const id = idProp.children[1];
+                if (!id || id.type !== 'string' || !id.value) {
+                    continue;
+                }
+                const savedId = '${input:' + id.value + '}';
+                const saved = inputs[savedId];
+                if (saved) {
+                    pushAnnotation(savedId, id.offset + 1 + id.length, saved);
+                }
+            }
+        }
+        function pushAnnotation(savedId, offset, saved) {
+            const tooltip = ( new MarkdownString([
+                markdownCommandLink({ id: EditStoredInput.ID, title: ( localize(7628, 'Edit')), arguments: [savedId, model.uri, mcpConfigurationSection, inConfig.target] }),
+                markdownCommandLink({ id: RemoveStoredInput.ID, title: ( localize(7629, 'Clear')), arguments: [inConfig.scope, savedId] }),
+                markdownCommandLink({ id: RemoveStoredInput.ID, title: ( localize(7630, 'Clear All')), arguments: [inConfig.scope] }),
+            ].join(' | '), { isTrusted: true }));
+            const hint = {
+                label: '= ' + (saved.input?.type === 'promptString' && saved.input.password ? '*'.repeat(10) : (saved.value || '')),
+                position: model.getPositionAt(offset),
+                tooltip,
+                paddingLeft: true,
+            };
+            hints.push(hint);
+            return hint;
+        }
+    }
+};
+McpLanguageFeatures = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IMcpRegistry)),
+    ( __param(2, IMcpConfigPathsService)),
+    ( __param(3, IMcpService)),
+    ( __param(4, IMarkerService)),
+    ( __param(5, IConfigurationResolverService))
+], McpLanguageFeatures));
+function forEachPropertyWithReplacement(node, callback) {
+    if (node.type === 'string' && typeof node.value === 'string' && node.value.includes(ConfigurationResolverExpression.VARIABLE_LHS)) {
+        callback(node);
+    }
+    else if (node.type === 'property') {
+        node.children?.slice(1).forEach(n => forEachPropertyWithReplacement(n, callback));
+    }
+    else {
+        node.children?.forEach(n => forEachPropertyWithReplacement(n, callback));
+    }
+}
+
+export { McpLanguageFeatures };

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

@@ -0,0 +1,17 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IMcpConfigPathsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpDiscovery } from "./mcpDiscovery.js";
+export declare class ConfigMcpDiscovery extends Disposable implements IMcpDiscovery {
+    private readonly _configurationService;
+    private readonly _mcpRegistry;
+    private readonly _textModelService;
+    private readonly _mcpConfigPathsService;
+    private configSources;
+    constructor(_configurationService: IConfigurationService, _mcpRegistry: IMcpRegistry, _textModelService: ITextModelService, _mcpConfigPathsService: IMcpConfigPathsService);
+    start(): void;
+    private _getServerIdMapping;
+    private sync;
+}