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

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

@@ -0,0 +1,15 @@
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpDiscovery } from "./mcpDiscovery.js";
+import { FilesystemMcpDiscovery } from "./nativeMcpDiscoveryAbstract.js";
+export declare class CursorWorkspaceMcpDiscoveryAdapter extends FilesystemMcpDiscovery implements IMcpDiscovery {
+    private readonly _workspaceContextService;
+    private readonly _remoteAgentService;
+    private readonly _collections;
+    constructor(fileService: IFileService, _workspaceContextService: IWorkspaceContextService, mcpRegistry: IMcpRegistry, configurationService: IConfigurationService, _remoteAgentService: IRemoteAgentService);
+    start(): void;
+    private watchFolder;
+}

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

@@ -0,0 +1,68 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { DiscoverySource } 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 { McpCollectionSortOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { FilesystemMcpDiscovery } from './nativeMcpDiscoveryAbstract.js';
+import { claudeConfigToServerDefinition } from './nativeMcpDiscoveryAdapters.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+
+let CursorWorkspaceMcpDiscoveryAdapter = class CursorWorkspaceMcpDiscoveryAdapter extends FilesystemMcpDiscovery {
+    constructor(fileService, _workspaceContextService, mcpRegistry, configurationService, _remoteAgentService) {
+        super(configurationService, fileService, mcpRegistry);
+        this._workspaceContextService = _workspaceContextService;
+        this._remoteAgentService = _remoteAgentService;
+        this._collections = this._register(( new DisposableMap()));
+    }
+    start() {
+        this._register(this._workspaceContextService.onDidChangeWorkspaceFolders(e => {
+            for (const removed of e.removed) {
+                this._collections.deleteAndDispose(( removed.uri.toString()));
+            }
+            for (const added of e.added) {
+                this.watchFolder(added);
+            }
+        }));
+        for (const folder of this._workspaceContextService.getWorkspace().folders) {
+            this.watchFolder(folder);
+        }
+    }
+    watchFolder(folder) {
+        const configFile = joinPath(folder.uri, '.cursor', 'mcp.json');
+        const collection = {
+            id: `cursor-workspace.${folder.index}`,
+            label: `${folder.name}/.cursor/mcp.json`,
+            remoteAuthority: this._remoteAgentService.getConnection()?.remoteAuthority || null,
+            scope: StorageScope.WORKSPACE,
+            isTrustedByDefault: false,
+            serverDefinitions: observableValue(this, []),
+            presentation: {
+                origin: configFile,
+                order: McpCollectionSortOrder.WorkspaceFolder + 1,
+            },
+        };
+        this._collections.set(( folder.uri.toString()), this.watchFile(URI.joinPath(folder.uri, '.cursor', 'mcp.json'), collection, DiscoverySource.CursorWorkspace, contents => {
+            const defs = claudeConfigToServerDefinition(collection.id, contents, folder.uri);
+            defs?.forEach(d => d.roots = [folder.uri]);
+            return defs;
+        }));
+    }
+};
+CursorWorkspaceMcpDiscoveryAdapter = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IMcpRegistry)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IRemoteAgentService))
+], CursorWorkspaceMcpDiscoveryAdapter));
+
+export { CursorWorkspaceMcpDiscoveryAdapter };

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

@@ -0,0 +1,6 @@
+import { Location } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+export declare const getMcpServerMapping: (opts: {
+    model: ITextModel;
+    pathToServers: string[];
+}) => Map<string, Location>;

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

@@ -0,0 +1,30 @@
+
+import { parseTree, findNodeAtLocation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+
+const getMcpServerMapping = (opts) => {
+    const tree = parseTree(opts.model.getValue());
+    const servers = findNodeAtLocation(tree, opts.pathToServers);
+    if (!servers || servers.type !== 'object') {
+        return ( new Map());
+    }
+    const result = ( new Map());
+    for (const node of servers.children || []) {
+        if (node.type !== 'property' || node.children?.[0]?.type !== 'string') {
+            continue;
+        }
+        const start = opts.model.getPositionAt(node.offset);
+        const end = opts.model.getPositionAt(node.offset + node.length);
+        result.set(node.children[0].value, {
+            uri: opts.model.uri,
+            range: {
+                startLineNumber: start.lineNumber,
+                startColumn: start.column,
+                endLineNumber: end.lineNumber,
+                endColumn: end.column,
+            }
+        });
+    }
+    return result;
+};
+
+export { getMcpServerMapping };

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

@@ -0,0 +1,33 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { StorageScope } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage";
+import { IWorkspaceFolder } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IMcpConfigPathsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfigPathsService.service";
+export interface IMcpConfigPath {
+    id: string;
+    key: "userLocalValue" | "userRemoteValue" | "workspaceValue" | "workspaceFolderValue";
+    label: string;
+    scope: StorageScope;
+    target: ConfigurationTarget;
+    order: number;
+    remoteAuthority?: string;
+    uri: URI | undefined;
+    section?: string[];
+    workspaceFolder?: IWorkspaceFolder;
+}
+export declare class McpConfigPathsService extends Disposable implements IMcpConfigPathsService {
+    private readonly _environmentService;
+    _serviceBrand: undefined;
+    private readonly _paths;
+    get paths(): IObservable<readonly IMcpConfigPath[]>;
+    constructor(workspaceContextService: IWorkspaceContextService, productService: IProductService, labelService: ILabelService, _environmentService: IWorkbenchEnvironmentService, remoteAgentService: IRemoteAgentService, preferencesService: IPreferencesService);
+    private _fromWorkspaceFolder;
+}

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

@@ -0,0 +1,112 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { FOLDER_SETTINGS_PATH } from '@codingame/monaco-vscode-2b1a9082-790f-527f-b013-d1b29d6265a3-common/vscode/vs/workbench/services/preferences/common/preferences';
+import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { IRemoteAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
+import { mcpConfigurationSection } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { McpCollectionSortOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+
+let McpConfigPathsService = class McpConfigPathsService extends Disposable {
+    get paths() {
+        return this._paths;
+    }
+    constructor(workspaceContextService, productService, labelService, _environmentService, remoteAgentService, preferencesService) {
+        super();
+        this._environmentService = _environmentService;
+        const workspaceConfig = workspaceContextService.getWorkspace().configuration;
+        const initialPaths = [
+            {
+                id: 'usrlocal',
+                key: 'userLocalValue',
+                target: ConfigurationTarget.USER_LOCAL,
+                label: ( localize(7635, 'Global in {0}', productService.nameShort)),
+                scope: StorageScope.PROFILE,
+                order: McpCollectionSortOrder.User,
+                uri: preferencesService.userSettingsResource,
+                section: [mcpConfigurationSection],
+            },
+            workspaceConfig && {
+                id: 'workspace',
+                key: 'workspaceValue',
+                target: ConfigurationTarget.WORKSPACE,
+                label: basename(workspaceConfig),
+                scope: StorageScope.WORKSPACE,
+                order: McpCollectionSortOrder.Workspace,
+                remoteAuthority: _environmentService.remoteAuthority,
+                uri: workspaceConfig,
+                section: ['settings', mcpConfigurationSection],
+            },
+            ...( workspaceContextService.getWorkspace()
+                .folders
+                .map(wf => this._fromWorkspaceFolder(wf)))
+        ];
+        this._paths = observableValue('mcpConfigPaths', initialPaths.filter(isDefined));
+        remoteAgentService.getEnvironment().then((env) => {
+            const label = _environmentService.remoteAuthority ? labelService.getHostLabel(Schemas.vscodeRemote, _environmentService.remoteAuthority) : 'Remote';
+            this._paths.set([
+                ...this.paths.get(),
+                {
+                    id: 'usrremote',
+                    key: 'userRemoteValue',
+                    target: ConfigurationTarget.USER_REMOTE,
+                    label,
+                    scope: StorageScope.PROFILE,
+                    order: McpCollectionSortOrder.User + McpCollectionSortOrder.RemoteBoost,
+                    uri: env?.settingsPath,
+                    remoteAuthority: _environmentService.remoteAuthority,
+                    section: [mcpConfigurationSection],
+                }
+            ], undefined);
+        });
+        this._register(workspaceContextService.onDidChangeWorkspaceFolders(e => {
+            const next = this._paths.get().slice();
+            for (const folder of e.added) {
+                next.push(this._fromWorkspaceFolder(folder));
+            }
+            for (const folder of e.removed) {
+                const idx = next.findIndex(c => c.workspaceFolder === folder);
+                if (idx !== -1) {
+                    next.splice(idx, 1);
+                }
+            }
+            this._paths.set(next, undefined);
+        }));
+    }
+    _fromWorkspaceFolder(workspaceFolder) {
+        return {
+            id: `wf${workspaceFolder.index}`,
+            key: 'workspaceFolderValue',
+            target: ConfigurationTarget.WORKSPACE_FOLDER,
+            label: `${workspaceFolder.name}/.vscode/mcp.json`,
+            scope: StorageScope.WORKSPACE,
+            remoteAuthority: this._environmentService.remoteAuthority,
+            order: McpCollectionSortOrder.WorkspaceFolder,
+            uri: URI.joinPath(workspaceFolder.uri, FOLDER_SETTINGS_PATH, '../mcp.json'),
+            workspaceFolder,
+        };
+    }
+};
+McpConfigPathsService = ( __decorate([
+    ( __param(0, IWorkspaceContextService)),
+    ( __param(1, IProductService)),
+    ( __param(2, ILabelService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
+    ( __param(4, IRemoteAgentService)),
+    ( __param(5, IPreferencesService))
+], McpConfigPathsService));
+
+export { McpConfigPathsService };

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

@@ -0,0 +1,59 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ConfigurationTarget } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { StorageScope } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkspaceFolderData } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace";
+import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
+import { IResolvedValue } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IMcpHostDelegate, IMcpResolveConnectionOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes";
+import { IMcpRegistry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service";
+import { IMcpServerConnection, LazyCollectionState, McpCollectionDefinition, McpCollectionReference } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+export declare class McpRegistry extends Disposable implements IMcpRegistry {
+    private readonly _instantiationService;
+    private readonly _configurationResolverService;
+    private readonly _dialogService;
+    private readonly _storageService;
+    private readonly _productService;
+    private readonly _notificationService;
+    private readonly _editorService;
+    readonly _serviceBrand: undefined;
+    private readonly _trustPrompts;
+    private readonly _collections;
+    private readonly _delegates;
+    readonly collections: IObservable<readonly McpCollectionDefinition[]>;
+    private readonly _collectionToPrefixes;
+    private readonly _workspaceStorage;
+    private readonly _profileStorage;
+    private readonly _trustMemento;
+    private readonly _lazyCollectionsToUpdate;
+    private readonly _ongoingLazyActivations;
+    readonly lazyCollectionState: IObservable<LazyCollectionState>;
+    get delegates(): readonly IMcpHostDelegate[];
+    private readonly _onDidChangeInputs;
+    readonly onDidChangeInputs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    constructor(_instantiationService: IInstantiationService, _configurationResolverService: IConfigurationResolverService, _dialogService: IDialogService, _storageService: IStorageService, _productService: IProductService, _notificationService: INotificationService, _editorService: IEditorService);
+    registerDelegate(delegate: IMcpHostDelegate): IDisposable;
+    registerCollection(collection: McpCollectionDefinition): IDisposable;
+    collectionToolPrefix(collection: McpCollectionReference): IObservable<string>;
+    discoverCollections(): Promise<McpCollectionDefinition[]>;
+    private _getInputStorage;
+    private _getInputStorageInConfigTarget;
+    clearSavedInputs(scope: StorageScope, inputId?: string): Promise<void>;
+    editSavedInput(inputId: string, folderData: IWorkspaceFolderData | undefined, configSection: string, target: ConfigurationTarget): Promise<void>;
+    getSavedInputs(scope: StorageScope): Promise<{
+        [id: string]: IResolvedValue;
+    }>;
+    resetTrust(): void;
+    getTrust(collectionRef: McpCollectionReference): IObservable<boolean | undefined>;
+    private _promptForTrust;
+    private _promptForTrustOpenDialog;
+    private _updateStorageWithExpressionInputs;
+    private _replaceVariablesInLaunch;
+    resolveConnection({ collectionRef, definitionRef, forceTrust, logger }: IMcpResolveConnectionOptions): Promise<IMcpServerConnection | undefined>;
+}

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

@@ -0,0 +1,322 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { observableMemento } from '@codingame/monaco-vscode-ec21d4de-4d65-574c-8715-bb1a6bbad376-common/vscode/vs/platform/observable/common/observableMemento';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.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 { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { McpRegistryInputStorage } from './mcpRegistryInputStorage.js';
+import { McpServerConnection } from './mcpServerConnection.js';
+import { LazyCollectionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+
+const createTrustMemento = observableMemento({
+    defaultValue: {},
+    key: 'mcp.trustedCollections'
+});
+const collectionPrefixLen = 3;
+let McpRegistry = class McpRegistry extends Disposable {
+    get delegates() {
+        return this._delegates;
+    }
+    constructor(_instantiationService, _configurationResolverService, _dialogService, _storageService, _productService, _notificationService, _editorService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._configurationResolverService = _configurationResolverService;
+        this._dialogService = _dialogService;
+        this._storageService = _storageService;
+        this._productService = _productService;
+        this._notificationService = _notificationService;
+        this._editorService = _editorService;
+        this._trustPrompts = ( new Map());
+        this._collections = observableValue('collections', []);
+        this._delegates = [];
+        this.collections = this._collections;
+        this._collectionToPrefixes = ( this._collections.map(c => {
+            const hashes = ( c.map((collection) => {
+                const sha = ( new StringSHA1());
+                sha.update(collection.id);
+                return { view: 0, hash: sha.digest(), collection };
+            }));
+            const view = (h) => h.hash.slice(h.view, h.view + collectionPrefixLen);
+            let collided = false;
+            do {
+                hashes.sort((a, b) => view(a).localeCompare(view(b)) || a.collection.id.localeCompare(b.collection.id));
+                collided = false;
+                for (let i = 1; i < hashes.length; i++) {
+                    const prev = hashes[i - 1];
+                    const curr = hashes[i];
+                    if (view(prev) === view(curr) && curr.view + collectionPrefixLen < curr.hash.length) {
+                        curr.view++;
+                        collided = true;
+                    }
+                }
+            } while (collided);
+            return Object.fromEntries(( hashes.map(h => [h.collection.id, view(h) + '.'])));
+        }));
+        this._workspaceStorage = ( new Lazy(
+            () => this._register(this._instantiationService.createInstance(McpRegistryInputStorage, StorageScope.WORKSPACE, StorageTarget.USER))
+        ));
+        this._profileStorage = ( new Lazy(
+            () => this._register(this._instantiationService.createInstance(McpRegistryInputStorage, StorageScope.PROFILE, StorageTarget.USER))
+        ));
+        this._trustMemento = ( new Lazy(
+            () => this._register(createTrustMemento(StorageScope.APPLICATION, StorageTarget.MACHINE, this._storageService))
+        ));
+        this._lazyCollectionsToUpdate = ( new Set());
+        this._ongoingLazyActivations = observableValue(this, 0);
+        this.lazyCollectionState = derived(reader => {
+            if (this._ongoingLazyActivations.read(reader) > 0) {
+                return LazyCollectionState.LoadingUnknown;
+            }
+            const collections = this._collections.read(reader);
+            return ( collections.some(c => c.lazy && c.lazy.isCached === false)) ? LazyCollectionState.HasUnknown : LazyCollectionState.AllKnown;
+        });
+        this._onDidChangeInputs = this._register(( new Emitter()));
+        this.onDidChangeInputs = this._onDidChangeInputs.event;
+    }
+    registerDelegate(delegate) {
+        this._delegates.push(delegate);
+        this._delegates.sort((a, b) => b.priority - a.priority);
+        return {
+            dispose: () => {
+                const index = this._delegates.indexOf(delegate);
+                if (index !== -1) {
+                    this._delegates.splice(index, 1);
+                }
+            }
+        };
+    }
+    registerCollection(collection) {
+        const currentCollections = this._collections.get();
+        const toReplace = currentCollections.find(c => c.lazy && c.id === collection.id);
+        if (toReplace) {
+            this._lazyCollectionsToUpdate.add(collection.id);
+            this._collections.set(( currentCollections.map(c => c === toReplace ? collection : c)), undefined);
+        }
+        else {
+            this._collections.set([...currentCollections, collection], undefined);
+        }
+        return {
+            dispose: () => {
+                const currentCollections = this._collections.get();
+                this._collections.set(currentCollections.filter(c => c !== collection), undefined);
+            }
+        };
+    }
+    collectionToolPrefix(collection) {
+        return ( this._collectionToPrefixes.map(p => p[collection.id] ?? ''));
+    }
+    async discoverCollections() {
+        const toDiscover = this._collections.get().filter(c => c.lazy && !c.lazy.isCached);
+        this._ongoingLazyActivations.set(this._ongoingLazyActivations.get() + 1, undefined);
+        await Promise.all(( toDiscover.map(c => c.lazy?.load()))).finally(() => {
+            this._ongoingLazyActivations.set(this._ongoingLazyActivations.get() - 1, undefined);
+        });
+        const found = [];
+        const current = this._collections.get();
+        for (const collection of toDiscover) {
+            const rec = current.find(c => c.id === collection.id);
+            if (!rec) ;
+            else if (rec.lazy) {
+                rec.lazy.removed?.();
+            }
+            else {
+                found.push(rec);
+            }
+        }
+        return found;
+    }
+    _getInputStorage(scope) {
+        return scope === StorageScope.WORKSPACE ? this._workspaceStorage.value : this._profileStorage.value;
+    }
+    _getInputStorageInConfigTarget(configTarget) {
+        return this._getInputStorage(configTarget === ConfigurationTarget.WORKSPACE || configTarget === ConfigurationTarget.WORKSPACE_FOLDER
+            ? StorageScope.WORKSPACE
+            : StorageScope.PROFILE);
+    }
+    async clearSavedInputs(scope, inputId) {
+        const storage = this._getInputStorage(scope);
+        if (inputId) {
+            await storage.clear(inputId);
+        }
+        else {
+            storage.clearAll();
+        }
+        this._onDidChangeInputs.fire();
+    }
+    async editSavedInput(inputId, folderData, configSection, target) {
+        const storage = this._getInputStorageInConfigTarget(target);
+        const expr = ConfigurationResolverExpression.parse(inputId);
+        const stored = await storage.getMap();
+        const previous = stored[inputId].value;
+        await this._configurationResolverService.resolveWithInteraction(folderData, expr, configSection, previous ? { [inputId.slice(2, -1)]: previous } : {}, target);
+        await this._updateStorageWithExpressionInputs(storage, expr);
+    }
+    getSavedInputs(scope) {
+        return this._getInputStorage(scope).getMap();
+    }
+    resetTrust() {
+        this._trustMemento.value.set({}, undefined);
+    }
+    getTrust(collectionRef) {
+        return derived(reader => {
+            const collection = this._collections.read(reader).find(c => c.id === collectionRef.id);
+            if (!collection || collection.isTrustedByDefault) {
+                return true;
+            }
+            const memento = this._trustMemento.value.read(reader);
+            return memento.hasOwnProperty(collection.id) ? memento[collection.id] : undefined;
+        });
+    }
+    _promptForTrust(collection) {
+        let resultPromise = this._trustPrompts.get(collection.id);
+        resultPromise ??= this._promptForTrustOpenDialog(collection).finally(() => {
+            this._trustPrompts.delete(collection.id);
+        });
+        this._trustPrompts.set(collection.id, resultPromise);
+        return resultPromise;
+    }
+    async _promptForTrustOpenDialog(collection) {
+        const originURI = collection.presentation?.origin;
+        const labelWithOrigin = originURI ? `[\`${basename(originURI)}\`](${originURI})` : collection.label;
+        const result = await this._dialogService.prompt({
+            message: ( localize(7655, 'Trust MCP servers from {0}?', collection.label)),
+            custom: {
+                markdownDetails: [{
+                        markdown: ( new MarkdownString(( localize(
+                            7656,
+                            '{0} discovered Model Context Protocol servers from {1} (`{2}`). {0} can use their capabilities in Chat.\n\nDo you want to allow running MCP servers from {3}?',
+                            this._productService.nameShort,
+                            collection.label,
+                            ( collection.serverDefinitions.get().map(s => s.label)).join('`, `'),
+                            labelWithOrigin
+                        )))),
+                        dismissOnLinkClick: true,
+                    }]
+            },
+            buttons: [
+                { label: ( localize(7657, 'Trust')), run: () => true },
+                { label: ( localize(7658, 'Do not trust')), run: () => false }
+            ],
+        });
+        return result.result;
+    }
+    async _updateStorageWithExpressionInputs(inputStorage, expr) {
+        const secrets = {};
+        const inputs = {};
+        for (const [replacement, resolved] of expr.resolved()) {
+            if (resolved.input?.type === 'promptString' && resolved.input.password) {
+                secrets[replacement.id] = resolved;
+            }
+            else {
+                inputs[replacement.id] = resolved;
+            }
+        }
+        inputStorage.setPlainText(inputs);
+        await inputStorage.setSecrets(secrets);
+        this._onDidChangeInputs.fire();
+    }
+    async _replaceVariablesInLaunch(definition, launch) {
+        if (!definition.variableReplacement) {
+            return launch;
+        }
+        const { section, target, folder } = definition.variableReplacement;
+        const inputStorage = this._getInputStorageInConfigTarget(target);
+        const previouslyStored = await inputStorage.getMap();
+        const expr = ConfigurationResolverExpression.parse(launch);
+        for (const replacement of expr.unresolved()) {
+            if (previouslyStored.hasOwnProperty(replacement.id)) {
+                expr.resolve(replacement, previouslyStored[replacement.id]);
+            }
+        }
+        await this._configurationResolverService.resolveWithInteraction(folder, expr, section, undefined, target);
+        await this._updateStorageWithExpressionInputs(inputStorage, expr);
+        return await this._configurationResolverService.resolveAsync(folder, expr);
+    }
+    async resolveConnection({ collectionRef, definitionRef, forceTrust, logger }) {
+        const collection = this._collections.get().find(c => c.id === collectionRef.id);
+        const definition = collection?.serverDefinitions.get().find(s => s.id === definitionRef.id);
+        if (!collection || !definition) {
+            throw ( new Error(
+                `Collection or definition not found for ${collectionRef.id} and ${definitionRef.id}`
+            ));
+        }
+        const delegate = this._delegates.find(d => d.canStart(collection, definition));
+        if (!delegate) {
+            throw ( new Error('No delegate found that can handle the connection'));
+        }
+        if (!collection.isTrustedByDefault) {
+            const memento = this._trustMemento.value.get();
+            const trusted = memento.hasOwnProperty(collection.id) ? memento[collection.id] : undefined;
+            if (trusted) ;
+            else if (trusted === undefined || forceTrust) {
+                const trustValue = await this._promptForTrust(collection);
+                if (trustValue !== undefined) {
+                    this._trustMemento.value.set({ ...memento, [collection.id]: trustValue }, undefined);
+                }
+                if (!trustValue) {
+                    return;
+                }
+            }
+            else  {
+                return undefined;
+            }
+        }
+        let launch;
+        try {
+            launch = await this._replaceVariablesInLaunch(definition, definition.launch);
+        }
+        catch (e) {
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(7659, 'Error starting {0}: {1}', definition.label, String(e))),
+                actions: {
+                    primary: collection.presentation?.origin && [
+                        {
+                            id: 'mcp.launchError.openConfig',
+                            class: undefined,
+                            enabled: true,
+                            tooltip: '',
+                            label: ( localize(7660, 'Open Configuration')),
+                            run: () => this._editorService.openEditor({
+                                resource: collection.presentation.origin,
+                                options: { selection: definition.presentation?.origin?.range }
+                            }),
+                        }
+                    ]
+                }
+            });
+            return;
+        }
+        return this._instantiationService.createInstance(McpServerConnection, collection, definition, delegate, launch, logger);
+    }
+};
+McpRegistry = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IConfigurationResolverService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IProductService)),
+    ( __param(5, INotificationService)),
+    ( __param(6, IEditorService))
+], McpRegistry));
+
+export { McpRegistry };