@codingame/monaco-vscode-mcp-service-override 17.2.0 → 18.0.0

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

@@ -14,7 +14,7 @@ import { IResolvedValue } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 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";
+import { IMcpServerConnection, LazyCollectionState, McpCollectionDefinition, McpCollectionReference, McpDefinitionReference, McpServerDefinition } 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;
@@ -29,19 +29,21 @@ export declare class McpRegistry extends Disposable implements IMcpRegistry {
     private readonly _delegates;
     private readonly _enabled;
     readonly collections: IObservable<readonly McpCollectionDefinition[]>;
-    private readonly _collectionToPrefixes;
     private readonly _workspaceStorage;
     private readonly _profileStorage;
     private readonly _trustMemento;
     private readonly _ongoingLazyActivations;
-    readonly lazyCollectionState: IObservable<LazyCollectionState>;
-    get delegates(): readonly IMcpHostDelegate[];
+    readonly lazyCollectionState: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<LazyCollectionState, void>;
+    get delegates(): IObservable<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, configurationService: IConfigurationService);
     registerDelegate(delegate: IMcpHostDelegate): IDisposable;
     registerCollection(collection: McpCollectionDefinition): IDisposable;
-    collectionToolPrefix(collection: McpCollectionReference): IObservable<string>;
+    getServerDefinition(collectionRef: McpDefinitionReference, definitionRef: McpDefinitionReference): IObservable<{
+        server: McpServerDefinition | undefined;
+        collection: McpCollectionDefinition | undefined;
+    }>;
     discoverCollections(): Promise<McpCollectionDefinition[]>;
     private _getInputStorage;
     private _getInputStorageInConfigTarget;
@@ -57,5 +59,5 @@ export declare class McpRegistry extends Disposable implements IMcpRegistry {
     private _promptForTrustOpenDialog;
     private _updateStorageWithExpressionInputs;
     private _replaceVariablesInLaunch;
-    resolveConnection({ collectionRef, definitionRef, forceTrust, logger }: IMcpResolveConnectionOptions): Promise<IMcpServerConnection | undefined>;
+    resolveConnection({ collectionRef, definitionRef, forceTrust, logger, debug }: IMcpResolveConnectionOptions): Promise<IMcpServerConnection | undefined>;
 }

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

@@ -2,13 +2,11 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 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 { indexOfPattern } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
@@ -25,19 +23,19 @@ import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vsco
 import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
 import { AUX_WINDOW_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { mcpEnabledSection } from '@codingame/monaco-vscode-1cb11a73-359e-5a2f-9e95-6989cc9858ee-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { mcpEnabledSection } from '@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
+import { IMcpDevModeDebugging } from './mcpDevMode.service.js';
 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';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
 const createTrustMemento = observableMemento({
     defaultValue: {},
     key: 'mcp.trustedCollections'
 });
-const collectionPrefixLen = 3;
 let McpRegistry = class McpRegistry extends Disposable {
     get delegates() {
         return this._delegates;
@@ -53,36 +51,13 @@ let McpRegistry = class McpRegistry extends Disposable {
         this._editorService = _editorService;
         this._trustPrompts = ( new Map());
         this._collections = observableValue('collections', []);
-        this._delegates = [];
+        this._delegates = observableValue('delegates', []);
         this.collections = derived(reader => {
             if (!this._enabled.read(reader)) {
                 return [];
             }
             return this._collections.read(reader);
         });
-        this._collectionToPrefixes = ( this._collections.map(c => {
-            const hashes = ( c.map((collection) => {
-                const sha = ( new StringSHA1());
-                sha.update(collection.id);
-                const hash = sha.digest();
-                return { view: indexOfPattern(hash, /[a-z]/i), hash, 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))
         ));
@@ -108,14 +83,14 @@ let McpRegistry = class McpRegistry extends Disposable {
         this._enabled = observableConfigValue(mcpEnabledSection, true, configurationService);
     }
     registerDelegate(delegate) {
-        this._delegates.push(delegate);
-        this._delegates.sort((a, b) => b.priority - a.priority);
+        const delegates = this._delegates.get().slice();
+        delegates.push(delegate);
+        delegates.sort((a, b) => b.priority - a.priority);
+        this._delegates.set(delegates, undefined);
         return {
             dispose: () => {
-                const index = this._delegates.indexOf(delegate);
-                if (index !== -1) {
-                    this._delegates.splice(index, 1);
-                }
+                const delegates = this._delegates.get().filter(d => d !== delegate);
+                this._delegates.set(delegates, undefined);
             }
         };
     }
@@ -126,7 +101,8 @@ let McpRegistry = class McpRegistry extends Disposable {
             this._collections.set(( currentCollections.map(c => c === toReplace ? collection : c)), undefined);
         }
         else {
-            this._collections.set([...currentCollections, collection], undefined);
+            this._collections.set([...currentCollections, collection]
+                .sort((a, b) => (a.presentation?.order || 0) - (b.presentation?.order || 0)), undefined);
         }
         return {
             dispose: () => {
@@ -135,8 +111,12 @@ let McpRegistry = class McpRegistry extends Disposable {
             }
         };
     }
-    collectionToolPrefix(collection) {
-        return ( this._collectionToPrefixes.map(p => p[collection.id] ?? ''));
+    getServerDefinition(collectionRef, definitionRef) {
+        const collectionObs = ( this._collections.map(cols => cols.find(c => c.id === collectionRef.id)));
+        return ( collectionObs.map((collection, reader) => {
+            const server = collection?.serverDefinitions.read(reader).find(s => s.id === definitionRef.id);
+            return { collection, server };
+        }));
     }
     async discoverCollections() {
         const toDiscover = this._collections.get().filter(c => c.lazy && !c.lazy.isCached);
@@ -221,12 +201,12 @@ let McpRegistry = class McpRegistry extends Disposable {
         const originURI = collection.presentation?.origin;
         const labelWithOrigin = originURI ? `[\`${basename(originURI)}\`](${originURI})` : collection.label;
         const result = await this._dialogService.prompt({
-            message: ( localize(7737, 'Trust MCP servers from {0}?', collection.label)),
+            message: ( localize(7950, 'Trust MCP servers from {0}?', collection.label)),
             custom: {
                 icon: Codicon.shield,
                 markdownDetails: [{
                         markdown: ( new MarkdownString(( localize(
-                            7738,
+                            7951,
                             '{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,
@@ -240,8 +220,8 @@ let McpRegistry = class McpRegistry extends Disposable {
                     }]
             },
             buttons: [
-                { label: ( localize(7739, 'Trust')), run: () => true },
-                { label: ( localize(7740, 'Do not trust')), run: () => false }
+                { label: ( localize(7952, 'Trust')), run: () => true },
+                { label: ( localize(7953, 'Do not trust')), run: () => false }
             ],
         });
         return result.result;
@@ -278,7 +258,7 @@ let McpRegistry = class McpRegistry extends Disposable {
         await this._updateStorageWithExpressionInputs(inputStorage, expr);
         return await this._configurationResolverService.resolveAsync(folder, expr);
     }
-    async resolveConnection({ collectionRef, definitionRef, forceTrust, logger }) {
+    async resolveConnection({ collectionRef, definitionRef, forceTrust, logger, debug }) {
         let collection = this._collections.get().find(c => c.id === collectionRef.id);
         if (collection?.lazy) {
             await collection.lazy.load();
@@ -290,7 +270,7 @@ let McpRegistry = class McpRegistry extends Disposable {
                 `Collection or definition not found for ${collectionRef.id} and ${definitionRef.id}`
             ));
         }
-        const delegate = this._delegates.find(d => d.canStart(collection, definition));
+        const delegate = this._delegates.get().find(d => d.canStart(collection, definition));
         if (!delegate) {
             throw ( new Error('No delegate found that can handle the connection'));
         }
@@ -320,11 +300,14 @@ let McpRegistry = class McpRegistry extends Disposable {
         }
         try {
             launch = await this._replaceVariablesInLaunch(definition, launch);
+            if (definition.devMode && debug) {
+                launch = await this._instantiationService.invokeFunction(accessor => accessor.get(IMcpDevModeDebugging).transform(definition, launch));
+            }
         }
         catch (e) {
             this._notificationService.notify({
                 severity: Severity.Error,
-                message: ( localize(7741, 'Error starting {0}: {1}', definition.label, String(e))),
+                message: ( localize(7954, 'Error starting {0}: {1}', definition.label, String(e))),
                 actions: {
                     primary: collection.presentation?.origin && [
                         {
@@ -332,7 +315,7 @@ let McpRegistry = class McpRegistry extends Disposable {
                             class: undefined,
                             enabled: true,
                             tooltip: '',
-                            label: ( localize(7742, 'Open Configuration')),
+                            label: ( localize(7955, 'Open Configuration')),
                             run: () => this._editorService.openEditor({
                                 resource: collection.presentation.origin,
                                 options: { selection: definition.presentation?.origin?.range }

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

@@ -0,0 +1,35 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ReadableStreamEvents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { FileSystemProviderCapabilities, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileReadStreamOptions, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.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 McpResourceFilesystem extends Disposable implements IWorkbenchContribution, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability {
+    private readonly _instantiationService;
+    private readonly _fileService;
+    private readonly _mcpServiceLazy;
+    private get _mcpService();
+    readonly onDidChangeCapabilities: Event<any>;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    readonly capabilities: FileSystemProviderCapabilities;
+    constructor(_instantiationService: IInstantiationService, _fileService: IFileService);
+    readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
+    watch(uri: URI, _opts: IWatchOptions): IDisposable;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    mkdir(resource: URI): Promise<void>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    delete(resource: URI, opts: IFileDeleteOptions): Promise<void>;
+    rename(from: URI, to: URI, opts: IFileOverwriteOptions): Promise<void>;
+    private _readFile;
+    private _decodeURI;
+    private _readURI;
+}

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

@@ -0,0 +1,206 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { sumBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { VSBuffer, decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { newWriteableStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stream';
+import { equalsIgnoreCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { FileSystemProviderCapabilities, FileChangeType, createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { McpServer } from './mcpServer.js';
+import { McpResourceURI, McpCapability } 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 { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let McpResourceFilesystem = class McpResourceFilesystem extends Disposable {
+    get _mcpService() {
+        return this._mcpServiceLazy.value;
+    }
+    constructor(_instantiationService, _fileService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._fileService = _fileService;
+        this._mcpServiceLazy = ( new Lazy(() => this._instantiationService.invokeFunction(a => a.get(IMcpService))));
+        this.onDidChangeCapabilities = Event.None;
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this.capabilities = FileSystemProviderCapabilities.None
+            | FileSystemProviderCapabilities.Readonly
+            | FileSystemProviderCapabilities.PathCaseSensitive
+            | FileSystemProviderCapabilities.FileReadStream
+            | FileSystemProviderCapabilities.FileAtomicRead
+            | FileSystemProviderCapabilities.FileReadWrite;
+        this._register(this._fileService.registerProvider(McpResourceURI.scheme, this));
+    }
+    async readFile(resource) {
+        return this._readFile(resource);
+    }
+    readFileStream(resource, opts, token) {
+        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
+        this._readFile(resource, token).then(data => {
+            if (opts.position) {
+                data = data.slice(opts.position);
+            }
+            if (opts.length) {
+                data = data.slice(0, opts.length);
+            }
+            stream.end(data);
+        }, err => stream.error(err));
+        return stream;
+    }
+    watch(uri, _opts) {
+        const { resourceURI, server } = this._decodeURI(uri);
+        const cap = server.capabilities.get();
+        if (cap !== undefined && !(cap & McpCapability.ResourcesSubscribe)) {
+            return Disposable.None;
+        }
+        server.start();
+        const store = ( new DisposableStore());
+        let watchedOnHandler;
+        const watchListener = store.add(( new MutableDisposable()));
+        const callCts = store.add(( new MutableDisposable()));
+        store.add(autorun(reader => {
+            const connection = server.connection.read(reader);
+            if (!connection) {
+                return;
+            }
+            const handler = connection.handler.read(reader);
+            if (!handler || watchedOnHandler === handler) {
+                return;
+            }
+            callCts.value?.dispose(true);
+            callCts.value = ( new CancellationTokenSource());
+            watchedOnHandler = handler;
+            const token = callCts.value.token;
+            handler.subscribe({ uri: ( resourceURI.toString(true)) }, token).then(() => {
+                if (!token.isCancellationRequested) {
+                    watchListener.value = handler.onDidUpdateResource(e => {
+                        if (equalsUriPath(e.params.uri, resourceURI)) {
+                            this._onDidChangeFile.fire([{ resource: uri, type: FileChangeType.UPDATED }]);
+                        }
+                    });
+                }
+            }, err => {
+                handler.logger.warn(`Failed to subscribe to resource changes for ${resourceURI}: ${err}`);
+                watchedOnHandler = undefined;
+            });
+        }));
+        return store;
+    }
+    async stat(resource) {
+        const { forSameURI, contents } = await this._readURI(resource);
+        if (!contents.length) {
+            throw createFileSystemProviderError(`File not found`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        return {
+            ctime: 0,
+            mtime: 0,
+            size: sumBy(contents, c => contentToBuffer(c).byteLength),
+            type: forSameURI.length ? FileType.File : FileType.Directory,
+        };
+    }
+    async readdir(resource) {
+        const { forSameURI, contents, resourceURI } = await this._readURI(resource);
+        if (forSameURI.length > 0) {
+            throw createFileSystemProviderError(`File is not a directory`, FileSystemProviderErrorCode.FileNotADirectory);
+        }
+        const resourcePathParts = resourceURI.path.split('/');
+        const output = ( new Map());
+        for (const content of contents) {
+            const contentURI = ( URI.parse(content.uri));
+            const contentPathParts = contentURI.path.split('/');
+            if (contentPathParts.length <= resourcePathParts.length || !resourcePathParts.every((part, index) => equalsIgnoreCase(part, contentPathParts[index]))) {
+                continue;
+            }
+            else if (contentPathParts.length > resourcePathParts.length + 1) {
+                output.set(contentPathParts[resourcePathParts.length], FileType.Directory);
+            }
+            else {
+                const name = contentPathParts[contentPathParts.length - 1];
+                output.set(name, contentToBuffer(content).byteLength > 0 ? FileType.File : FileType.Directory);
+            }
+        }
+        return [...output];
+    }
+    mkdir(resource) {
+        throw createFileSystemProviderError('write is not supported', FileSystemProviderErrorCode.NoPermissions);
+    }
+    writeFile(resource, content, opts) {
+        throw createFileSystemProviderError('write is not supported', FileSystemProviderErrorCode.NoPermissions);
+    }
+    delete(resource, opts) {
+        throw createFileSystemProviderError('delete is not supported', FileSystemProviderErrorCode.NoPermissions);
+    }
+    rename(from, to, opts) {
+        throw createFileSystemProviderError('rename is not supported', FileSystemProviderErrorCode.NoPermissions);
+    }
+    async _readFile(resource, token) {
+        const { forSameURI, contents } = await this._readURI(resource);
+        if (!forSameURI.length) {
+            if (!contents.length) {
+                throw createFileSystemProviderError(`File not found`, FileSystemProviderErrorCode.FileNotFound);
+            }
+            else {
+                throw createFileSystemProviderError(`File is a directory`, FileSystemProviderErrorCode.FileIsADirectory);
+            }
+        }
+        return contentToBuffer(forSameURI[0]);
+    }
+    _decodeURI(uri) {
+        let definitionId;
+        let resourceURI;
+        try {
+            ({ definitionId, resourceURI } = McpResourceURI.toServer(uri));
+        }
+        catch (e) {
+            throw createFileSystemProviderError(String(e), FileSystemProviderErrorCode.FileNotFound);
+        }
+        if (resourceURI.path.endsWith('/')) {
+            resourceURI = resourceURI.with({ path: resourceURI.path.slice(0, -1) });
+        }
+        const server = this._mcpService.servers.get().find(s => s.definition.id === definitionId);
+        if (!server) {
+            throw createFileSystemProviderError(`MCP server ${definitionId} not found`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        const cap = server.capabilities.get();
+        if (cap !== undefined && !(cap & McpCapability.Resources)) {
+            throw createFileSystemProviderError(`MCP server ${definitionId} does not support resources`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        return { definitionId, resourceURI, server };
+    }
+    async _readURI(uri, token) {
+        const { resourceURI, server } = this._decodeURI(uri);
+        const res = await McpServer.callOn(server, r => r.readResource({ uri: ( resourceURI.toString(true)) }, token), token);
+        return {
+            contents: res.contents,
+            resourceURI,
+            forSameURI: res.contents.filter(c => equalsUriPath(c.uri, resourceURI)),
+        };
+    }
+};
+McpResourceFilesystem = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IFileService))
+], McpResourceFilesystem));
+function equalsUriPath(a, b) {
+    return equalsIgnoreCase(( URI.parse(a)).path, b.path);
+}
+function contentToBuffer(content) {
+    if ('text' in content) {
+        return VSBuffer.fromString(content.text).buffer;
+    }
+    else if ('blob' in content) {
+        return decodeBase64(content.blob).buffer;
+    }
+    else {
+        throw createFileSystemProviderError('Unknown content type', FileSystemProviderErrorCode.Unknown);
+    }
+}
+
+export { McpResourceFilesystem };

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

@@ -0,0 +1,26 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IMcpServer } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { MCP } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/modelContextProtocol";
+interface ISamplingStoredData {
+    head: number;
+    bins: number[];
+    lastReqs: {
+        request: MCP.SamplingMessage[];
+        response: string;
+        at: number;
+        model: string;
+    }[];
+}
+export declare class McpSamplingLog extends Disposable {
+    private readonly _storageService;
+    private readonly _logs;
+    constructor(_storageService: IStorageService);
+    has(server: IMcpServer): boolean;
+    get(server: IMcpServer): Readonly<ISamplingStoredData | undefined>;
+    getAsText(server: IMcpServer): string;
+    private _formatRecentRequests;
+    add(server: IMcpServer, request: MCP.SamplingMessage[], response: string, model: string): Promise<void>;
+    private _getLogStorageForServer;
+}
+export {};

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

@@ -0,0 +1,110 @@
+
+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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { observableMemento } from '@codingame/monaco-vscode-1cb11a73-359e-5a2f-9e95-6989cc9858ee-common/vscode/vs/platform/observable/common/observableMemento';
+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';
+
+var Constants;
+(function (Constants) {
+    Constants[Constants["SamplingRetentionDays"] = 7] = "SamplingRetentionDays";
+    Constants[Constants["MsPerDay"] = 86400000] = "MsPerDay";
+    Constants[Constants["SamplingRetentionMs"] = 604800000] = "SamplingRetentionMs";
+    Constants[Constants["SamplingLastNMessage"] = 30] = "SamplingLastNMessage";
+})(Constants || (Constants = {}));
+const samplingMemento = observableMemento({
+    defaultValue: ( new Map()),
+    key: 'mcp.sampling.logs',
+    toStorage: v => JSON.stringify(Array.from(v.entries())),
+    fromStorage: v => ( new Map(JSON.parse(v))),
+});
+let McpSamplingLog = class McpSamplingLog extends Disposable {
+    constructor(_storageService) {
+        super();
+        this._storageService = _storageService;
+        this._logs = {};
+    }
+    has(server) {
+        const storage = this._getLogStorageForServer(server);
+        return ( storage.get().has(server.definition.id));
+    }
+    get(server) {
+        const storage = this._getLogStorageForServer(server);
+        return storage.get().get(server.definition.id);
+    }
+    getAsText(server) {
+        const storage = this._getLogStorageForServer(server);
+        const record = storage.get().get(server.definition.id);
+        if (!record) {
+            return '';
+        }
+        const parts = [];
+        const total = record.bins.reduce((sum, value) => sum + value, 0);
+        parts.push(( localize(7956, '{0} total requests in the last 7 days.', total)));
+        parts.push(this._formatRecentRequests(record));
+        return parts.join('\n');
+    }
+    _formatRecentRequests(data) {
+        if (!data.lastReqs.length) {
+            return '\nNo recent requests.';
+        }
+        const result = [];
+        for (let i = 0; i < data.lastReqs.length; i++) {
+            const { request, response, at, model } = data.lastReqs[i];
+            result.push(`\n[${i + 1}] ${( new Date(at)).toISOString()} ${model}`);
+            result.push('  Request:');
+            for (const msg of request) {
+                const role = msg.role.padEnd(9);
+                let content = '';
+                if ('text' in msg.content && msg.content.type === 'text') {
+                    content = msg.content.text;
+                }
+                else if ('data' in msg.content) {
+                    content = `[${msg.content.type} data: ${msg.content.mimeType}]`;
+                }
+                result.push(`    ${role}: ${content}`);
+            }
+            result.push('  Response:');
+            result.push(`    ${response}`);
+        }
+        return result.join('\n');
+    }
+    async add(server, request, response, model) {
+        const now = Date.now();
+        const utcOrdinal = Math.floor(now / Constants.MsPerDay);
+        const storage = this._getLogStorageForServer(server);
+        const next = ( new Map(storage.get()));
+        let record = next.get(server.definition.id);
+        if (!record) {
+            record = {
+                head: utcOrdinal,
+                bins: Array.from({ length: Constants.SamplingRetentionDays }, () => 0),
+                lastReqs: [],
+            };
+        }
+        else {
+            for (let i = 0; i < (utcOrdinal - record.head) && i < Constants.SamplingRetentionDays; i++) {
+                record.bins.pop();
+                record.bins.unshift(0);
+            }
+            record.head = utcOrdinal;
+        }
+        record.bins[0]++;
+        record.lastReqs.unshift({ request, response, at: now, model });
+        while (record.lastReqs.length > Constants.SamplingLastNMessage) {
+            record.lastReqs.pop();
+        }
+        next.set(server.definition.id, record);
+        storage.set(next, undefined);
+    }
+    _getLogStorageForServer(server) {
+        const scope = server.readDefinitions().get().collection?.scope ?? StorageScope.WORKSPACE;
+        return this._logs[scope] ??= this._register(samplingMemento(scope, StorageTarget.MACHINE, this._storageService));
+    }
+};
+McpSamplingLog = ( __decorate([
+    ( __param(0, IStorageService))
+], McpSamplingLog));
+
+export { McpSamplingLog };

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

@@ -0,0 +1,38 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IMcpServerSamplingConfiguration } from "@codingame/monaco-vscode-aa9ead53-dfd3-59da-b9e7-f163d201de8d-common/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration";
+import { IMcpServer, ISamplingOptions, ISamplingResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+import { IMcpSamplingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
+export declare class McpSamplingService extends Disposable implements IMcpSamplingService {
+    private readonly _languageModelsService;
+    private readonly _configurationService;
+    private readonly _dialogService;
+    private readonly _notificationService;
+    private readonly _commandService;
+    readonly _serviceBrand: undefined;
+    private readonly _sessionSets;
+    private readonly _logs;
+    constructor(_languageModelsService: ILanguageModelsService, _configurationService: IConfigurationService, _dialogService: IDialogService, _notificationService: INotificationService, _commandService: ICommandService, instaService: IInstantiationService);
+    sample(opts: ISamplingOptions, token?: Readonly<CancellationToken>): Promise<ISamplingResult>;
+    hasLogs(server: IMcpServer): boolean;
+    getLogText(server: IMcpServer): string;
+    private _getMatchingModel;
+    private allowButtons;
+    private _showContextual;
+    private _notify;
+    private _getMatchingModelInner;
+    private _configKey;
+    getConfig(server: IMcpServer): IMcpServerSamplingConfiguration;
+    private _getConfig;
+    updateConfig(server: IMcpServer, mutate: (r: IMcpServerSamplingConfiguration) => unknown): Promise<{
+        allowedDuringChat?: boolean;
+        allowedOutsideChat?: boolean;
+        allowedModels?: string[];
+    }>;
+}