@codingame/monaco-vscode-mcp-service-override 20.1.1 → 20.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-mcp-service-override",
-  "version": "20.1.1",
+  "version": "20.2.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - mcp service-override",
   "keywords": [],
@@ -15,20 +15,20 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-2673c6e2-17c1-5710-b169-46f3d4a28696-common": "20.1.1",
-    "@codingame/monaco-vscode-4a3ac544-9a61-534c-88df-756262793ef7-common": "20.1.1",
-    "@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common": "20.1.1",
-    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.1.1",
-    "@codingame/monaco-vscode-62190c26-af1c-5f7a-a364-e05a59cfb7c7-common": "20.1.1",
-    "@codingame/monaco-vscode-a654b07e-8806-5425-b124-18f03ba8e11a-common": "20.1.1",
-    "@codingame/monaco-vscode-api": "20.1.1",
-    "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common": "20.1.1",
-    "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common": "20.1.1",
-    "@codingame/monaco-vscode-ce7c734f-7712-563c-9335-d7acb43306af-common": "20.1.1",
-    "@codingame/monaco-vscode-cf77987b-b1b7-5359-aaf8-a259c63d9f03-common": "20.1.1",
-    "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common": "20.1.1",
-    "@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common": "20.1.1",
-    "@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common": "20.1.1"
+    "@codingame/monaco-vscode-2673c6e2-17c1-5710-b169-46f3d4a28696-common": "20.2.0",
+    "@codingame/monaco-vscode-4a3ac544-9a61-534c-88df-756262793ef7-common": "20.2.0",
+    "@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common": "20.2.0",
+    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.2.0",
+    "@codingame/monaco-vscode-62190c26-af1c-5f7a-a364-e05a59cfb7c7-common": "20.2.0",
+    "@codingame/monaco-vscode-a654b07e-8806-5425-b124-18f03ba8e11a-common": "20.2.0",
+    "@codingame/monaco-vscode-api": "20.2.0",
+    "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common": "20.2.0",
+    "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common": "20.2.0",
+    "@codingame/monaco-vscode-ce7c734f-7712-563c-9335-d7acb43306af-common": "20.2.0",
+    "@codingame/monaco-vscode-cf77987b-b1b7-5359-aaf8-a259c63d9f03-common": "20.2.0",
+    "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common": "20.2.0",
+    "@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common": "20.2.0",
+    "@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common": "20.2.0"
   },
   "main": "index.js",
   "module": "index.js",

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

@@ -14,6 +14,7 @@ export declare class McpLanguageFeatures extends Disposable implements IWorkbenc
     private readonly _configurationResolverService;
     private readonly _cachedMcpSection;
     constructor(languageFeaturesService: ILanguageFeaturesService, _mcpRegistry: IMcpRegistry, _mcpWorkbenchService: IMcpWorkbenchService, _mcpService: IMcpService, _markerService: IMarkerService, _configurationResolverService: IConfigurationResolverService);
+    /** Simple mechanism to avoid extra json parsing for hints+lenses */
     private _parseModel;
     private _addDiagnostics;
     private _provideCodeLenses;

package/vscode/src/vs/workbench/contrib/mcp/browser/media/mcpServerAction.css

@@ -1,21 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .mcp-hover-contents {
 	margin-top: 4px;
 	margin-bottom: 4px;
 	max-width: 250px;
 	min-width: 200px;
 }
+
 .mcp-hover-contents .mcp-hover-divider {
 	margin-top: 8px;
 	margin-bottom: 8px;
 }
+
 .mcp-hover-contents .mcp-hover-setting {
 	display: flex;
 	align-items: center;
 	margin-top: 6px;
 }
+
 .mcp-hover-contents .mcp-hover-setting .monaco-checkbox {
 	flex-shrink: 0;
 }
+
 .mcp-hover-contents .mcp-hover-setting .mcp-hover-setting-label {
 	cursor: pointer;
 	color: var(--vscode-foreground);

package/vscode/src/vs/workbench/contrib/mcp/browser/media/mcpServerEditor.css

@@ -1,31 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .mcp-server-editor {
 	.configuration-content {
 		padding: 20px;
 		box-sizing: border-box;
 	}
+
 	.config-section {
 		margin-bottom: 15px;
 		display: flex;
 		align-items: flex-start;
 	}
+
 	.config-label {
 		font-weight: 600;
 		min-width: 80px;
 		margin-right: 15px;
 	}
+
 	.config-value {
 		word-break: break-all;
 	}
+
 	.no-config {
 		color: var(--vscode-descriptionForeground);
 		font-style: italic;
 		padding: 20px;
 	}
+
 	.manifest-content {
 		padding: 20px;
 		box-sizing: border-box;
+
 		.manifest-section {
 			margin-bottom: 20px;
+
 			.manifest-section-title {
 				font-size: 26px;
 				display: inline-block;
@@ -41,8 +53,11 @@
 				text-overflow: ellipsis;
 			}
 		}
+
 		.package-section {
+
 			margin-top: 10px;
+
 			.package-section-title {
 				margin-bottom: 5px;
 				font-size: 1.4em;
@@ -50,6 +65,7 @@
 				border-bottom: 1px solid var(--vscode-panelSection-border);
 				padding: 5px;
 			}
+
 			.package-details {
 				padding-left: 10px;
 				.package-detail {
@@ -59,15 +75,20 @@
 					align-items: start;
 					padding: 8px 0px;
 				}
+
 				.package-separator {
 					margin-top: 10px;
 					border-bottom: 1px solid var(--vscode-panelSection-border);
 				}
 			}
 		}
+
+
 		.no-manifest {
 			font-style: italic;
 			padding: 20px;
 		}
 	}
+
+
 }

package/vscode/src/vs/workbench/contrib/mcp/browser/media/mcpServersView.css

@@ -1,9 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .mcp-welcome-container {
 	height: 100%;
 	width: 100%;
+
 	&.hide {
 		display: none;
 	}
+
 	.mcp-welcome-content {
 		display: flex;
 		flex-direction: column;
@@ -12,29 +19,35 @@
 		padding: 0px 40px;
 		text-align: center;
 		margin: 20px auto;
+
 		.mcp-welcome-icon {
 			.codicon {
 				font-size: 48px;
 			}
 		}
+
 		.mcp-welcome-title {
 			font-size: 24px;
 			margin-top: 5px;
 			font-weight: 500;
 			line-height: normal;
 		}
+
 		.mcp-welcome-description {
 			max-width: 350px;
 			padding: 0 20px;
 			margin-top: 16px;
+
 			a {
 				color: var(--vscode-textLink-foreground);
 			}
 		}
+
 		.mcp-welcome-button-container {
 			margin-top: 16px;
 			max-width: 320px;
 			width: 100%;
 		}
+
 	}
 }

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

@@ -25,6 +25,10 @@ export declare abstract class FilesystemMcpDiscovery extends Disposable {
     protected _isDiscoveryEnabled(reader: IReader, discoverySource: DiscoverySource | undefined): boolean;
     protected watchFile(file: URI, collection: WritableMcpCollectionDefinition, discoverySource: DiscoverySource | undefined, adaptFile: (contents: VSBuffer) => Promise<McpServerDefinition[] | undefined>): IDisposable;
 }
+/**
+ * Base class that discovers MCP servers on a filesystem, outside of the ones
+ * defined in VS Code settings.
+ */
 export declare abstract class NativeFilesystemMcpDiscovery extends FilesystemMcpDiscovery implements IMcpDiscovery {
     private readonly adapters;
     private suffix;

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

@@ -6,6 +6,9 @@ import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log
 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 { NativeFilesystemMcpDiscovery } from "./nativeMcpDiscoveryAbstract.js";
+/**
+ * Discovers MCP servers on the remote filesystem, if any.
+ */
 export declare class RemoteNativeMpcDiscovery extends NativeFilesystemMcpDiscovery {
     private readonly remoteAgent;
     private readonly logService;

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

@@ -6,6 +6,13 @@ import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/co
 export declare namespace McpContextKeys {
     const serverCount: RawContextKey<number>;
     const hasUnknownTools: RawContextKey<boolean>;
+    /**
+     * A context key that indicates whether there are any servers with errors.
+     *
+     * @type {boolean}
+     * @default undefined
+     * @description This key is used to track the presence of servers with errors in the MCP context.
+     */
     const hasServersWithErrors: RawContextKey<boolean>;
     const toolsCount: RawContextKey<number>;
 }

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

@@ -58,6 +58,11 @@ export declare class McpRegistry extends Disposable implements IMcpRegistry {
     }>;
     private _checkTrust;
     private _promptForTrust;
+    /**
+     * Confirms with the user which of the provided definitions should be trusted.
+     * Returns undefined if the user cancelled the flow, or the list of trusted
+     * definition IDs otherwise.
+     */
     protected _promptForTrustOpenDialog(definitions: {
         definition: McpServerDefinition;
         collection: McpCollectionDefinition;

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

@@ -15,12 +15,17 @@ export declare class McpRegistryInputStorage extends Disposable {
     private _didChange;
     private _record;
     constructor(_scope: StorageScope, _target: StorageTarget, _storageService: IStorageService, _secretStorageService: ISecretStorageService, _logService: ILogService);
+    /** Deletes all collection data from storage. */
     clearAll(): void;
+    /** Delete a single collection data from the storage. */
     clear(inputKey: string): Promise<void>;
+    /** Gets a mapping of saved input data. */
     getMap(): Promise<{
         [x: string]: IResolvedValue;
     }>;
+    /** Updates the input data mapping. */
     setPlainText(values: Record<string, IResolvedValue>): Promise<void>;
+    /** Updates the input secrets mapping. */
     setSecrets(values: Record<string, IResolvedValue>): Promise<void>;
     private _sealSecrets;
     private _unsealSecrets;

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

@@ -10,6 +10,7 @@ import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/w
 export declare class McpResourceFilesystem extends Disposable implements IWorkbenchContribution, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileReadStreamCapability {
     private readonly _instantiationService;
     private readonly _fileService;
+    /** Defer getting the MCP service since this is a BlockRestore and no need to make it unnecessarily. */
     private readonly _mcpServiceLazy;
     private get _mcpService();
     readonly onDidChangeCapabilities: Event<any>;

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

@@ -26,9 +26,23 @@ export declare class McpSamplingService extends Disposable implements IMcpSampli
     private allowButtons;
     private _showContextual;
     private _notify;
+    /**
+     * Gets the matching model for the MCP server in this context, or
+     * a reason why no model could be selected.
+     */
     private _getMatchingModelInner;
     private _configKey;
     getConfig(server: IMcpServer): IMcpServerSamplingConfiguration;
+    /**
+     * _getConfig reads the sampling config reads the `{ server: data }` mapping
+     * from the appropriate config. We read from the most specific possible
+     * config up to the default configuration location that the MCP server itself
+     * is defined in. We don't go further because then workspace-specific servers
+     * would get in the user settings which is not meaningful and could lead
+     * to confusion.
+     *
+     * todo@connor4312: generalize this for other esttings when we have them
+     */
     private _getConfig;
     updateConfig(server: IMcpServer, mutate: (r: IMcpServerSamplingConfiguration) => unknown): Promise<{
         allowedDuringChat?: boolean;

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

@@ -26,8 +26,11 @@ interface IToolCacheEntry {
     readonly serverInstructions: string | undefined;
     readonly trustedAtNonce: string | undefined;
     readonly nonce: string | undefined;
+    /** Cached tools so we can show what's available before it's started */
     readonly tools: readonly IValidatedMcpTool[];
+    /** Cached prompts */
     readonly prompts: readonly MCP.Prompt[] | undefined;
+    /** Cached capabilities */
     readonly capabilities: McpCapability | undefined;
 }
 interface IServerCacheEntry {
@@ -38,13 +41,23 @@ export declare class McpServerMetadataCache extends Disposable {
     private readonly cache;
     private readonly extensionServers;
     constructor(scope: StorageScope, storageService: IStorageService);
+    /** Resets the cache for primitives and extension servers */
     reset(): void;
+    /** Gets cached primitives for a server (used before a server is running) */
     get(definitionId: string): IToolCacheEntry | undefined;
+    /** Sets cached primitives for a server */
     store(definitionId: string, entry: Partial<IToolCacheEntry>): void;
+    /** Gets cached servers for a collection (used for extensions, before the extension activates) */
     getServers(collectionId: string): IServerCacheEntry | undefined;
+    /** Sets cached servers for a collection */
     storeServers(collectionId: string, entry: IServerCacheEntry | undefined): void;
 }
 interface IValidatedMcpTool extends MCP.Tool {
+    /**
+     * Tool name as published by the MCP server. This may
+     * be different than the one in {@link definition} due to name normalization
+     * in {@link McpServer._getValidatedTools}.
+     */
     serverToolName: string;
 }
 interface ServerMetadata {
@@ -68,6 +81,10 @@ export declare class McpServer extends Disposable implements IMcpServer {
     private readonly _samplingService;
     private readonly _elicitationService;
     private readonly _remoteAuthorityResolverService;
+    /**
+     * Helper function to call the function on the handler once it's online. The
+     * connection started if it is not already.
+     */
     static callOn<R>(server: IMcpServer, fn: (handler: McpServerRequestHandler) => Promise<R>, token?: CancellationToken): Promise<R>;
     private readonly _connectionSequencer;
     private readonly _connection;
@@ -88,6 +105,7 @@ export declare class McpServer extends Disposable implements IMcpServer {
     private readonly _loggerId;
     private readonly _logger;
     private _lastModeDebugged;
+    /** Count of running tool calls, used to detect if sampling is during an LM call */
     runningToolCalls: Set<IMcpToolCallContext>;
     constructor(collection: McpCollectionReference, definition: McpDefinitionReference, explicitRoots: URI[] | undefined, _requiresExtensionActivation: boolean | undefined, _primitiveCache: McpServerMetadataCache, toolPrefix: string, _mcpRegistry: IMcpRegistry, workspacesService: IWorkspaceContextService, _extensionService: IExtensionService, _loggerService: ILoggerService, _outputService: IOutputService, _telemetryService: ITelemetryService, _commandService: ICommandService, _instantiationService: IInstantiationService, _notificationService: INotificationService, _openerService: IOpenerService, _samplingService: IMcpSamplingService, _elicitationService: IMcpElicitationService, _remoteAuthorityResolverService: IRemoteAuthorityResolverService);
     readDefinitions(): IObservable<{

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

@@ -18,6 +18,7 @@ export declare class McpServerConnection extends Disposable implements IMcpServe
     readonly state: IObservable<McpConnectionState>;
     readonly handler: IObservable<McpServerRequestHandler | undefined>;
     constructor(_collection: McpCollectionDefinition, definition: McpServerDefinition, _delegate: IMcpHostDelegate, launchDefinition: McpServerLaunch, _logger: ILogger, _instantiationService: IInstantiationService);
+    /** @inheritdoc */
     start(methods: IMcpClientMethods): Promise<McpConnectionState>;
     private adoptLaunch;
     stop(): Promise<void>;

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

@@ -10,10 +10,19 @@ export interface McpRoot {
     name?: string;
 }
 export interface IMcpServerRequestHandlerOptions extends IMcpClientMethods {
+    /** MCP message transport */
     launch: IMcpMessageTransport;
+    /** Logger instance. */
     logger: ILogger;
+    /** Log level MCP messages is logged at */
     requestLogLevel?: LogLevel;
 }
+/**
+ * Request handler for communicating with an MCP server.
+ *
+ * Handles sending requests and receiving responses, with automatic
+ * handling of ping requests and typed client request methods.
+ */
 export declare class McpServerRequestHandler extends Disposable {
     private _nextRequestId;
     private readonly _pendingRequests;
@@ -36,6 +45,10 @@ export declare class McpServerRequestHandler extends Disposable {
     readonly onDidChangeToolList: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
     private readonly _onDidChangePromptList;
     readonly onDidChangePromptList: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    /**
+     * Connects to the MCP server and does the initialization handshake.
+     * @throws MpcResponseError if the server fails to initialize.
+     */
     static create(instaService: IInstantiationService, opts: IMcpServerRequestHandlerOptions, token?: CancellationToken): Promise<McpServerRequestHandler>;
     readonly logger: ILogger;
     private readonly _launch;
@@ -43,34 +56,117 @@ export declare class McpServerRequestHandler extends Disposable {
     private readonly _createMessageRequestHandler;
     private readonly _elicitationRequestHandler;
     protected constructor({ launch, logger, createMessageRequestHandler, elicitationRequestHandler, requestLogLevel, }: IMcpServerRequestHandlerOptions);
+    /**
+     * Send a client request to the server and return the response.
+     *
+     * @param request The request to send
+     * @param token Cancellation token
+     * @param timeoutMs Optional timeout in milliseconds
+     * @returns A promise that resolves with the response
+     */
     private sendRequest;
     private send;
+    /**
+     * Handles paginated requests by making multiple requests until all items are retrieved.
+     *
+     * @param method The method name to call
+     * @param getItems Function to extract the array of items from a result
+     * @param initialParams Initial parameters
+     * @param token Cancellation token
+     * @returns Promise with all items combined
+     */
     private sendRequestPaginated;
     private sendNotification;
+    /**
+     * Handle incoming messages from the server
+     */
     private handleMessage;
+    /**
+     * Handle successful responses
+     */
     private handleResult;
+    /**
+     * Handle error responses
+     */
     private handleError;
+    /**
+     * Handle incoming server requests
+     */
     private handleServerRequest;
+    /**
+     * Handle incoming server notifications
+     */
     private handleServerNotification;
     private handleCancelledNotification;
     private handleLoggingNotification;
+    /**
+     * Send a generic response to a request
+     */
     private respondToRequest;
+    /**
+     * Send a response to a ping request
+     */
     private handlePing;
+    /**
+     * Send a response to a roots/list request
+     */
     private handleRootsList;
     private cancelAllRequests;
     dispose(): void;
+    /**
+     * Forwards log level changes to the MCP server if it supports logging
+     */
     private _sendLogLevelToServer;
+    /**
+     * Send an initialize request
+     */
     initialize(params: MCP.InitializeRequest["params"], token?: CancellationToken): Promise<MCP.InitializeResult>;
+    /**
+     * List available resources
+     */
     listResources(params?: MCP.ListResourcesRequest["params"], token?: CancellationToken): Promise<MCP.Resource[]>;
+    /**
+     * List available resources (iterable)
+     */
     listResourcesIterable(params?: MCP.ListResourcesRequest["params"], token?: CancellationToken): AsyncIterable<MCP.Resource[]>;
+    /**
+     * Read a specific resource
+     */
     readResource(params: MCP.ReadResourceRequest["params"], token?: CancellationToken): Promise<MCP.ReadResourceResult>;
+    /**
+     * List available resource templates
+     */
     listResourceTemplates(params?: MCP.ListResourceTemplatesRequest["params"], token?: CancellationToken): Promise<MCP.ResourceTemplate[]>;
+    /**
+     * Subscribe to resource updates
+     */
     subscribe(params: MCP.SubscribeRequest["params"], token?: CancellationToken): Promise<MCP.EmptyResult>;
+    /**
+     * Unsubscribe from resource updates
+     */
     unsubscribe(params: MCP.UnsubscribeRequest["params"], token?: CancellationToken): Promise<MCP.EmptyResult>;
+    /**
+     * List available prompts
+     */
     listPrompts(params?: MCP.ListPromptsRequest["params"], token?: CancellationToken): Promise<MCP.Prompt[]>;
+    /**
+     * Get a specific prompt
+     */
     getPrompt(params: MCP.GetPromptRequest["params"], token?: CancellationToken): Promise<MCP.GetPromptResult>;
+    /**
+     * List available tools
+     */
     listTools(params?: MCP.ListToolsRequest["params"], token?: CancellationToken): Promise<MCP.Tool[]>;
+    /**
+     * Call a specific tool
+     */
     callTool(params: MCP.CallToolRequest["params"] & MCP.Request["params"], token?: CancellationToken): Promise<MCP.CallToolResult>;
+    /**
+     * Set the logging level
+     */
     setLevel(params: MCP.SetLevelRequest["params"], token?: CancellationToken): Promise<MCP.EmptyResult>;
+    /**
+     * Find completions for an argument
+     */
     complete(params: MCP.CompleteRequest["params"], token?: CancellationToken): Promise<MCP.CompleteResult>;
 }

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

@@ -1,5 +1,13 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { IMcpServer, IMcpServerStartOpts } 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";
+/**
+ * Waits up to `timeout` for a server passing the filter to be discovered,
+ * and then starts it.
+ */
 export declare function startServerByFilter(mcpService: IMcpService, filter: (s: IMcpServer) => boolean, timeout?: number): Promise<void>;
+/**
+ * Starts a server (if needed) and waits for its tools to be live. Returns
+ * true/false whether this happened successfully.
+ */
 export declare function startServerAndWaitForLiveTools(server: IMcpServer, opts?: IMcpServerStartOpts, token?: CancellationToken): Promise<boolean>;

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

@@ -10,13 +10,25 @@ interface IUriTemplateComponent {
     readonly operator: string;
     readonly variables: readonly IUriTemplateVariable[];
 }
+/**
+ * Represents an RFC 6570 URI Template.
+ */
 export declare class UriTemplate {
     readonly template: string;
+    /**
+     * The parsed template components (expressions).
+     */
     readonly components: ReadonlyArray<IUriTemplateComponent | string>;
     private constructor();
+    /**
+     * Parses a URI template string into a UriTemplate instance.
+     */
     static parse(template: string): UriTemplate;
     private static _operators;
     private static _isOperator;
+    /**
+     * Resolves the template with the given variables.
+     */
     resolve(variables: Record<string, unknown>): string;
     private _expand;
     private static _encode;

package/vscode/src/vs/workbench/services/authentication/browser/authenticationMcpAccessService.d.ts

@@ -6,6 +6,11 @@ import { IAuthenticationMcpAccessService } from "@codingame/monaco-vscode-api/vs
 export interface AllowedMcpServer {
     id: string;
     name: string;
+    /**
+     * If true or undefined, the extension is allowed to use the account
+     * If false, the extension is not allowed to use the account
+     * TODO: undefined shouldn't be a valid value, but it is for now
+     */
     allowed?: boolean;
     lastUsed?: number;
     trusted?: boolean;

package/vscode/src/vs/workbench/services/authentication/browser/authenticationMcpService.d.ts

@@ -44,6 +44,9 @@ export declare class AuthenticationMcpService extends Disposable implements IAut
     removeSessionPreference(providerId: string, mcpServerId: string, scopes: string[]): void;
     private _updateAccountAndSessionPreferences;
     private showGetSessionPrompt;
+    /**
+     * This function should be used only when there are sessions to disambiguate.
+     */
     selectSession(providerId: string, mcpServerId: string, mcpServerName: string, scopes: string[], availableSessions: AuthenticationSession[]): Promise<AuthenticationSession>;
     private completeSessionAccessRequest;
     requestSessionAccess(providerId: string, mcpServerId: string, mcpServerName: string, scopes: string[], possibleSessions: AuthenticationSession[]): void;