@codingame/monaco-vscode-api 22.1.9 → 23.0.0

package/vscode/src/vs/workbench/api/common/extHostMcp.js

@@ -4,25 +4,40 @@ import { Sequencer, DeferredPromise, timeout, raceCancellationError } from '../.
 import { CancellationToken, CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { CancellationError } from '../../../base/common/errors.js';
 import { Disposable, DisposableMap, DisposableStore, toDisposable } from '../../../base/common/lifecycle.js';
-import { parseWWWAuthenticateHeader, fetchResourceMetadata, getDefaultMetadataForUrl, AUTH_SERVER_METADATA_DISCOVERY_PATH, OPENID_CONNECT_DISCOVERY_PATH, isAuthorizationServerMetadata } from '../../../base/common/oauth.js';
+import { fetchResourceMetadata, fetchAuthorizationServerMetadata, getDefaultMetadataForUrl, parseWWWAuthenticateHeader, AUTH_SCOPE_SEPARATOR, scopesMatch } from '../../../base/common/oauth.js';
 import { SSEParser } from '../../../base/common/sseParser.js';
 import { URI } from '../../../base/common/uri.js';
+import { vObj, vOptionalProp, vArray, vObjAny, vNumber, vString } from '../../../base/common/validation.js';
 import { ConfigurationTarget } from '../../../platform/configuration/common/configuration.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { LogLevel, canLog } from '../../../platform/log/common/log.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { StorageScope } from '../../../platform/storage/common/storage.js';
-import { McpServerLaunch, McpServerTransportType, McpConnectionState, extensionPrefixedIdentifier, UserInteractionRequiredError } from '../../contrib/mcp/common/mcpTypes.js';
+import { McpServerLaunch, McpServerTransportType, extensionPrefixedIdentifier, McpServerStaticToolAvailability, McpConnectionState, UserInteractionRequiredError } from '../../contrib/mcp/common/mcpTypes.js';
 import { MCP } from '../../contrib/mcp/common/modelContextProtocol.js';
+import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
 import { IExtHostInitDataService } from './extHostInitDataService.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { McpServerDefinition } from './extHostTypeConverters.js';
+import { McpToolAvailability } from './extHostTypes.js';
 import { IExtHostVariableResolverProvider } from './extHostVariableResolverService.js';
 import { IExtHostWorkspace } from './extHostWorkspace.js';
 
 const IExtHostMpcService = ( createDecorator('IExtHostMpcService'));
+const serverDataValidation = vObj({
+    label: vString(),
+    version: vOptionalProp(vString()),
+    metadata: vOptionalProp(vObj({
+        capabilities: vOptionalProp(vObjAny()),
+        serverInfo: vOptionalProp(vObjAny()),
+        tools: vOptionalProp(vArray(vObj({
+            availability: vNumber(),
+            definition: vObjAny(),
+        }))),
+    }))
+});
 let ExtHostMcpService = class ExtHostMcpService extends Disposable {
     constructor(extHostRpc, _logService, _extHostInitData, _workspaceService, _variableResolver) {
         super();
@@ -56,10 +71,12 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
         }, value);
     }
     $stopMcp(id) {
-        if (( this._sseEventSources.has(id))) {
-            this._sseEventSources.deleteAndDispose(id);
-            this._proxy.$onDidChangeState(id, { state: McpConnectionState.Kind.Stopped });
-        }
+        this._sseEventSources.get(id)
+            ?.close()
+            .then(() => this._didClose(id));
+    }
+    _didClose(id) {
+        this._sseEventSources.deleteAndDispose(id);
     }
     $sendMessage(id, message) {
         this._sseEventSources.get(id)?.send(message);
@@ -112,10 +129,25 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
                     }
                     id = id + i;
                 }
+                serverDataValidation.validateOrThrow(item);
+                let staticMetadata;
+                const castAs2 = item;
+                if (isProposedApiEnabled(extension, 'mcpToolDefinitions') && castAs2.metadata) {
+                    staticMetadata = {
+                        capabilities: castAs2.metadata.capabilities,
+                        instructions: castAs2.metadata.instructions,
+                        serverInfo: castAs2.metadata.serverInfo,
+                        tools: castAs2.metadata.tools?.map(t => ({
+                            availability: t.availability === McpToolAvailability.Dynamic ? McpServerStaticToolAvailability.Dynamic : McpServerStaticToolAvailability.Initial,
+                            definition: t.definition,
+                        })),
+                    };
+                }
                 servers.push({
                     id,
                     label: item.label,
                     cacheNonce: item.version || '$$NONE',
+                    staticMetadata,
                     launch: McpServerDefinition.from(item),
                 });
             }
@@ -172,6 +204,7 @@ class McpHTTPHandle extends Disposable {
         this._mode = { value: HttpMode.Unknown };
         this._cts = ( new CancellationTokenSource());
         this._abortCtrl = ( new AbortController());
+        this._didSendClose = false;
         this._register(toDisposable(() => {
             this._abortCtrl.abort();
             this._cts.dispose(true);
@@ -192,6 +225,28 @@ class McpHTTPHandle extends Disposable {
             this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: msg });
         }
     }
+    async close() {
+        if (this._mode.value === HttpMode.Http && this._mode.sessionId && !this._didSendClose) {
+            this._didSendClose = true;
+            try {
+                await this._closeSession(this._mode.sessionId);
+            }
+            catch {
+            }
+        }
+        this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Stopped });
+    }
+    async _closeSession(sessionId) {
+        const headers = {
+            ...Object.fromEntries(this._launch.headers),
+            'Mcp-Session-Id': sessionId,
+        };
+        await this._addAuthHeader(headers);
+        await this._fetch(( this._launch.uri.toString(true)), {
+            method: 'DELETE',
+            headers,
+        });
+    }
     _send(message) {
         if (this._mode.value === HttpMode.SSE) {
             return this._sendLegacySSE(this._mode.endpoint, message);
@@ -224,7 +279,7 @@ class McpHTTPHandle extends Disposable {
         }
         if (this._mode.value === HttpMode.Unknown &&
             res.status >= 400 && res.status < 500
-            && res.status !== 401 && res.status !== 403) {
+            && !isAuthStatusCode(res.status)) {
             this._log(LogLevel.Info, `${res.status} status sending message to ${this._launch.uri}, will attempt to fall back to legacy SSE`);
             this._sseFallbackWithMessage(message);
             return;
@@ -254,21 +309,10 @@ class McpHTTPHandle extends Disposable {
         }
     }
     async _populateAuthMetadata(mcpUrl, originalResponse) {
-        let resourceMetadataChallenge;
-        if (( originalResponse.headers.has('WWW-Authenticate'))) {
-            const authHeader = originalResponse.headers.get('WWW-Authenticate');
-            const challenges = parseWWWAuthenticateHeader(authHeader);
-            for (const challenge of challenges) {
-                if (challenge.scheme === 'Bearer' && challenge.params['resource_metadata']) {
-                    this._log(LogLevel.Debug, `Found resource_metadata challenge in WWW-Authenticate header: ${challenge.params['resource_metadata']}`);
-                    resourceMetadataChallenge = challenge.params['resource_metadata'];
-                    break;
-                }
-            }
-        }
+        const { resourceMetadataChallenge, scopesChallenge: scopesChallengeFromHeader } = this._parseWWWAuthenticateHeader(originalResponse);
         let serverMetadataUrl;
-        let scopesSupported;
         let resource;
+        let scopesChallenge = scopesChallengeFromHeader;
         try {
             const resourceMetadata = await fetchResourceMetadata(mcpUrl, resourceMetadataChallenge, {
                 sameOriginHeaders: {
@@ -279,27 +323,33 @@ class McpHTTPHandle extends Disposable {
             });
             serverMetadataUrl = resourceMetadata.authorization_servers?.[0];
             this._log(LogLevel.Debug, `Using auth server metadata url: ${serverMetadataUrl}`);
-            scopesSupported = resourceMetadata.scopes_supported;
+            scopesChallenge ??= resourceMetadata.scopes_supported;
             resource = resourceMetadata;
         }
         catch (e) {
             this._log(LogLevel.Debug, `Could not fetch resource metadata: ${String(e)}`);
         }
         const baseUrl = ( new URL(originalResponse.url)).origin;
-        let addtionalHeaders = {};
+        let additionalHeaders = {};
         if (!serverMetadataUrl) {
             serverMetadataUrl = baseUrl;
-            addtionalHeaders = {
-                ...Object.fromEntries(this._launch.headers)
+            additionalHeaders = {
+                ...Object.fromEntries(this._launch.headers),
+                'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION
             };
         }
         try {
-            const serverMetadataResponse = await this._getAuthorizationServerMetadata(serverMetadataUrl, addtionalHeaders);
+            this._log(LogLevel.Debug, `Fetching auth server metadata for: ${serverMetadataUrl} ...`);
+            const serverMetadataResponse = await fetchAuthorizationServerMetadata(serverMetadataUrl, {
+                additionalHeaders,
+                fetch: (url, init) => this._fetch(url, init)
+            });
             this._log(LogLevel.Info, 'Populated auth metadata');
             this._authMetadata = {
                 authorizationServer: ( URI.parse(serverMetadataUrl)),
                 serverMetadata: serverMetadataResponse,
-                resourceMetadata: resource
+                resourceMetadata: resource,
+                scopes: scopesChallenge
             };
             return;
         }
@@ -307,62 +357,14 @@ class McpHTTPHandle extends Disposable {
             this._log(LogLevel.Warning, `Error populating auth server metadata for ${serverMetadataUrl}: ${String(e)}`);
         }
         const defaultMetadata = getDefaultMetadataForUrl(( new URL(baseUrl)));
-        defaultMetadata.scopes_supported = scopesSupported ?? defaultMetadata.scopes_supported ?? [];
         this._authMetadata = {
             authorizationServer: ( URI.parse(baseUrl)),
             serverMetadata: defaultMetadata,
-            resourceMetadata: resource
+            resourceMetadata: resource,
+            scopes: scopesChallenge
         };
         this._log(LogLevel.Info, 'Using default auth metadata');
     }
-    async _getAuthorizationServerMetadata(authorizationServer, addtionalHeaders) {
-        const authorizationServerUrl = ( new URL(authorizationServer));
-        const extraPath = authorizationServerUrl.pathname === '/' ? '' : authorizationServerUrl.pathname;
-        const pathToFetch = ( ( new URL(AUTH_SERVER_METADATA_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
-        this._log(LogLevel.Debug, `Fetching auth server metadata url with path insertion: ${pathToFetch} ...`);
-        let authServerMetadataResponse = await this._fetch(pathToFetch, {
-            method: 'GET',
-            headers: {
-                ...addtionalHeaders,
-                'Accept': 'application/json',
-                'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION,
-            }
-        });
-        if (authServerMetadataResponse.status !== 200) {
-            const openidPathInsertionUrl = ( ( new URL(OPENID_CONNECT_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
-            this._log(LogLevel.Debug, `Fetching fallback openid connect discovery url with path insertion: ${openidPathInsertionUrl} ...`);
-            authServerMetadataResponse = await this._fetch(openidPathInsertionUrl, {
-                method: 'GET',
-                headers: {
-                    ...addtionalHeaders,
-                    'Accept': 'application/json',
-                    'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION
-                }
-            });
-            if (authServerMetadataResponse.status !== 200) {
-                const openidPathAdditionUrl = ( URI.joinPath(( URI.parse(authorizationServer)), OPENID_CONNECT_DISCOVERY_PATH).toString(true));
-                this._log(LogLevel.Debug, `Fetching fallback openid connect discovery url with path addition: ${openidPathAdditionUrl} ...`);
-                authServerMetadataResponse = await this._fetch(openidPathAdditionUrl, {
-                    method: 'GET',
-                    headers: {
-                        ...addtionalHeaders,
-                        'Accept': 'application/json',
-                        'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION
-                    }
-                });
-                if (authServerMetadataResponse.status !== 200) {
-                    throw ( new Error(
-                        `Failed to fetch authorization server metadata: ${authServerMetadataResponse.status} ${await this._getErrText(authServerMetadataResponse)}`
-                    ));
-                }
-            }
-        }
-        const body = await authServerMetadataResponse.json();
-        if (isAuthorizationServerMetadata(body)) {
-            return body;
-        }
-        throw ( new Error(`Invalid authorization server metadata: ${JSON.stringify(body)}`));
-    }
     async _handleSuccessfulStreamableHttp(res, message) {
         if (res.status === 202) {
             return;
@@ -525,10 +527,19 @@ class McpHTTPHandle extends Disposable {
             }
         } while (!chunk.done);
     }
-    async _addAuthHeader(headers) {
+    async _addAuthHeader(headers, forceNewRegistration) {
         if (this._authMetadata) {
             try {
-                const token = await this._proxy.$getTokenFromServerMetadata(this._id, this._authMetadata.authorizationServer, this._authMetadata.serverMetadata, this._authMetadata.resourceMetadata, this._errorOnUserInteraction);
+                const authDetails = {
+                    authorizationServer: this._authMetadata.authorizationServer.toJSON(),
+                    authorizationServerMetadata: this._authMetadata.serverMetadata,
+                    resourceMetadata: this._authMetadata.resourceMetadata,
+                    scopes: this._authMetadata.scopes
+                };
+                const token = await this._proxy.$getTokenFromServerMetadata(this._id, authDetails, {
+                    errorOnUserInteraction: this._errorOnUserInteraction,
+                    forceNewRegistration
+                });
                 if (token) {
                     headers['Authorization'] = `Bearer ${token}`;
                 }
@@ -548,6 +559,33 @@ class McpHTTPHandle extends Disposable {
             this._proxy.$onDidPublishLog(this._id, level, message);
         }
     }
+    _parseWWWAuthenticateHeader(response) {
+        let resourceMetadataChallenge;
+        let scopesChallenge;
+        if (( response.headers.has('WWW-Authenticate'))) {
+            const authHeader = response.headers.get('WWW-Authenticate');
+            const challenges = parseWWWAuthenticateHeader(authHeader);
+            for (const challenge of challenges) {
+                if (challenge.scheme === 'Bearer') {
+                    if (!resourceMetadataChallenge && challenge.params['resource_metadata']) {
+                        resourceMetadataChallenge = challenge.params['resource_metadata'];
+                        this._log(LogLevel.Debug, `Found resource_metadata challenge in WWW-Authenticate header: ${resourceMetadataChallenge}`);
+                    }
+                    if (!scopesChallenge && challenge.params['scope']) {
+                        const scopes = challenge.params['scope'].split(AUTH_SCOPE_SEPARATOR).filter(s => s.trim().length);
+                        if (scopes.length) {
+                            this._log(LogLevel.Debug, `Found scope challenge in WWW-Authenticate header: ${challenge.params['scope']}`);
+                            scopesChallenge = scopes;
+                        }
+                    }
+                    if (resourceMetadataChallenge && scopesChallenge) {
+                        break;
+                    }
+                }
+            }
+        }
+        return { resourceMetadataChallenge, scopesChallenge };
+    }
     async _getErrText(res) {
         try {
             return await res.text();
@@ -559,7 +597,7 @@ class McpHTTPHandle extends Disposable {
     async _fetchWithAuthRetry(mcpUrl, init, headers) {
         const doFetch = () => this._fetch(mcpUrl, init);
         let res = await doFetch();
-        if (res.status === 401) {
+        if (isAuthStatusCode(res.status)) {
             if (!this._authMetadata) {
                 await this._populateAuthMetadata(mcpUrl, res);
                 await this._addAuthHeader(headers);
@@ -568,6 +606,22 @@ class McpHTTPHandle extends Disposable {
                     res = await doFetch();
                 }
             }
+            else {
+                const { scopesChallenge } = this._parseWWWAuthenticateHeader(res);
+                if (!scopesMatch(scopesChallenge, this._authMetadata.scopes)) {
+                    this._log(LogLevel.Debug, `Scopes changed from ${JSON.stringify(this._authMetadata.scopes)} to ${JSON.stringify(scopesChallenge)}, updating and retrying`);
+                    this._authMetadata.scopes = scopesChallenge;
+                    await this._addAuthHeader(headers);
+                    if (headers['Authorization']) {
+                        init.headers = headers;
+                        res = await doFetch();
+                    }
+                }
+            }
+        }
+        if (headers['Authorization'] && isAuthStatusCode(res.status)) {
+            await this._addAuthHeader(headers, true);
+            res = await doFetch();
         }
         return res;
     }
@@ -628,5 +682,8 @@ function isJSON(str) {
         return false;
     }
 }
+function isAuthStatusCode(status) {
+    return status === 401 || status === 403;
+}
 
 export { ExtHostMcpService, IExtHostMpcService, McpHTTPHandle };

package/vscode/src/vs/workbench/api/common/extHostNotebook.d.ts

@@ -17,7 +17,7 @@ import { IExtHostConsumerFileSystem } from "./extHostFileSystemConsumer.js";
 import { ITextQuery } from "../../services/search/common/search.js";
 import { IExtHostSearch } from "./extHostSearch.js";
 import { IRawClosedNotebookFileMatch } from "../../contrib/search/common/searchNotebookHelpers.js";
-import { NotebookPriorityInfo } from "@codingame/monaco-vscode-5084de40-f866-5cb5-9d9b-33a10f6f235d-common/vscode/vs/workbench/contrib/search/common/search";
+import { NotebookPriorityInfo } from "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/contrib/search/common/search";
 import { ILogService } from "../../../platform/log/common/log.service.js";
 export declare class ExtHostNotebookController implements ExtHostNotebookShape {
     private _textDocumentsAndEditors;
@@ -40,9 +40,9 @@ export declare class ExtHostNotebookController implements ExtHostNotebookShape {
     private _visibleNotebookEditors;
     get visibleNotebookEditors(): vscode.NotebookEditor[];
     private _onDidOpenNotebookDocument;
-    onDidOpenNotebookDocument: Event<vscode.NotebookDocument>;
+    readonly onDidOpenNotebookDocument: Event<vscode.NotebookDocument>;
     private _onDidCloseNotebookDocument;
-    onDidCloseNotebookDocument: Event<vscode.NotebookDocument>;
+    readonly onDidCloseNotebookDocument: Event<vscode.NotebookDocument>;
     private _onDidChangeVisibleNotebookEditors;
     onDidChangeVisibleNotebookEditors: Event<vscode.NotebookEditor[]>;
     private _statusBarCache;

package/vscode/src/vs/workbench/api/common/extHostNotebook.js

@@ -265,7 +265,7 @@ class ExtHostNotebookController {
                 ));
             }
             if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-                throw new FileOperationError(( localize(2642, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+                throw new FileOperationError(( localize(2662, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
             }
             const data = {
                 metadata: filter(document.apiNotebook.metadata, key => !(serializer.options?.transientDocumentMetadata ?? {})[key]),
@@ -444,7 +444,7 @@ class ExtHostNotebookController {
         if (typeof options?.mtime === 'number' && typeof options.etag === 'string' && options.etag !== ETAG_DISABLED &&
             typeof stat.mtime === 'number' && typeof stat.size === 'number' &&
             options.mtime < stat.mtime && options.etag !== etag({ mtime: options.mtime , size: stat.size })) {
-            throw new FileOperationError(( localize(2643, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(2663, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

package/vscode/src/vs/workbench/api/common/extHostNotebookKernels.d.ts

@@ -36,7 +36,7 @@ export declare class ExtHostNotebookKernels implements ExtHostNotebookKernelsSha
     private id;
     private variableStore;
     $provideVariables(handle: number, requestId: string, notebookUri: UriComponents, parentId: number | undefined, kind: "named" | "indexed", start: number, token: CancellationToken): Promise<void>;
-    $acceptKernelMessageFromRenderer(handle: number, editorId: string, message: any): void;
+    $acceptKernelMessageFromRenderer(handle: number, editorId: string, message: unknown): void;
     _createNotebookCellExecution(cell: vscode.NotebookCell, controllerId: string): vscode.NotebookCellExecution;
     _createNotebookExecution(nb: vscode.NotebookDocument, controllerId: string): vscode.NotebookExecution;
 }

package/vscode/src/vs/workbench/api/common/extHostProfileContentHandler.d.ts

@@ -1,7 +1,7 @@
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { UriComponents } from "../../../base/common/uri.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
-import { ISaveProfileResult } from "@codingame/monaco-vscode-e72c94ca-257a-5b75-8b68-5a5fa3c18255-common/vscode/vs/workbench/services/userDataProfile/common/userDataProfile";
+import { ISaveProfileResult } from "@codingame/monaco-vscode-dd5b2d07-86ca-557c-8510-224a400e258d-common/vscode/vs/workbench/services/userDataProfile/common/userDataProfile";
 import type * as vscode from "vscode";
 import { ExtHostProfileContentHandlersShape, IMainContext } from "./extHost.protocol.js";
 export declare class ExtHostProfileContentHandlers implements ExtHostProfileContentHandlersShape {

package/vscode/src/vs/workbench/api/common/extHostQuickOpen.js

@@ -3,14 +3,12 @@ import { CancellationToken } from '../../../base/common/cancellation.js';
 import { Emitter } from '../../../base/common/event.js';
 import { dispose } from '../../../base/common/lifecycle.js';
 import { MainContext } from './extHost.protocol.js';
-import { URI } from '../../../base/common/uri.js';
-import { QuickPickItemKind, InputBoxValidationSeverity, QuickInputButtons, ThemeIcon } from './extHostTypes.js';
+import { QuickPickItemKind, InputBoxValidationSeverity, QuickInputButtonLocation, QuickInputButtons } from './extHostTypes.js';
 import { isCancellationError } from '../../../base/common/errors.js';
 import { coalesce } from '../../../base/common/arrays.js';
 import Severity$1 from '../../../base/common/severity.js';
-import { ThemeIcon as ThemeIcon$1 } from '../../../base/common/themables.js';
-import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
-import { MarkdownString } from './extHostTypeConverters.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+import { MarkdownString, IconPath } from './extHostTypeConverters.js';
 
 function createExtHostQuickOpen(mainContext, workspace, commands) {
     const proxy = ( mainContext.getProxy(MainContext.MainThreadQuickOpen));
@@ -25,9 +23,13 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._onDidSelectItem = undefined;
             const itemsPromise = Promise.resolve(itemsOrItemsPromise);
             const instance = ++this._instances;
+            if (options?.prompt) {
+                checkProposedApiEnabled(extension, 'quickPickPrompt');
+            }
             const quickPickWidget = proxy.$show(instance, {
                 title: options?.title,
                 placeHolder: options?.placeHolder,
+                prompt: options?.prompt,
                 matchOnDescription: options?.matchOnDescription,
                 matchOnDetail: options?.matchOnDetail,
                 ignoreFocusLost: options?.ignoreFocusOut,
@@ -39,7 +41,6 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                 if (result === widgetClosedMarker) {
                     return undefined;
                 }
-                const allowedTooltips = isProposedApiEnabled(extension, 'quickPickItemTooltip');
                 return itemsPromise.then(items => {
                     const pickItems = [];
                     for (let handle = 0; handle < items.length; handle++) {
@@ -51,19 +52,21 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                             pickItems.push({ type: 'separator', label: item.label });
                         }
                         else {
-                            if (item.tooltip && !allowedTooltips) {
-                                console.warn(`Extension '${extension.identifier.value}' uses a tooltip which is proposed API that is only available when running out of dev or with the following command line switch: --enable-proposed-api ${extension.identifier.value}`);
+                            if (item.tooltip) {
+                                checkProposedApiEnabled(extension, 'quickPickItemTooltip');
+                            }
+                            if (item.resourceUri) {
+                                checkProposedApiEnabled(extension, 'quickPickItemResource');
                             }
-                            const icon = (item.iconPath) ? getIconPathOrClass(item.iconPath) : undefined;
                             pickItems.push({
                                 label: item.label,
-                                iconPath: icon?.iconPath,
-                                iconClass: icon?.iconClass,
+                                iconPathDto: IconPath.from(item.iconPath),
                                 description: item.description,
                                 detail: item.detail,
                                 picked: item.picked,
                                 alwaysShow: item.alwaysShow,
-                                tooltip: allowedTooltips ? MarkdownString.fromStrict(item.tooltip) : undefined,
+                                tooltip: MarkdownString.fromStrict(item.tooltip),
+                                resourceUri: item.resourceUri,
                                 handle
                             });
                         }
@@ -174,9 +177,9 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                 session._fireDidChangeSelection(handles);
             }
         }
-        $onDidTriggerButton(sessionId, handle) {
+        $onDidTriggerButton(sessionId, handle, checked) {
             const session = this._sessions.get(sessionId);
-            session?._fireDidTriggerButton(handle);
+            session?._fireDidTriggerButton(handle, checked);
         }
         $onDidTriggerItemButton(sessionId, itemHandle, buttonHandle) {
             const session = this._sessions.get(sessionId);
@@ -288,9 +291,15 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             return this._buttons;
         }
         set buttons(buttons) {
-            const allowedButtonLocation = isProposedApiEnabled(this._extension, 'quickInputButtonLocation');
-            if (!allowedButtonLocation && ( buttons.some(button => button.location))) {
-                console.warn(`Extension '${this._extension.identifier.value}' uses a button location which is proposed API that is only available when running out of dev or with the following command line switch: --enable-proposed-api ${this._extension.identifier.value}`);
+            if (( buttons.some(button => button.location || button.toggle))) {
+                checkProposedApiEnabled(this._extension, 'quickInputButtonLocation');
+            }
+            if (( buttons.some(
+                button => button.toggle && button.location !== QuickInputButtonLocation.Input
+            ))) {
+                throw ( new Error(
+                    'QuickInputButtons with toggle set are only supported in the Input location.'
+                ));
             }
             this._buttons = buttons.slice();
             this._handlesToButtons.clear();
@@ -301,10 +310,11 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this.update({
                 buttons: ( buttons.map((button, i) => {
                     return {
-                        ...getIconPathOrClass(button.iconPath),
+                        iconPathDto: IconPath.from(button.iconPath),
                         tooltip: button.tooltip,
                         handle: button === QuickInputButtons.Back ? -1 : i,
-                        location: allowedButtonLocation ? button.location : undefined
+                        location: button.location,
+                        checked: button.toggle?.checked
                     };
                 }))
             });
@@ -325,9 +335,12 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._value = value;
             this._onDidChangeValueEmitter.fire(value);
         }
-        _fireDidTriggerButton(handle) {
+        _fireDidTriggerButton(handle, checked) {
             const button = this._handlesToButtons.get(handle);
             if (button) {
+                if (checked !== undefined && button.toggle) {
+                    button.toggle.checked = checked;
+                }
                 this._onDidTriggerButtonEmitter.fire(button);
             }
         }
@@ -378,38 +391,6 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._pendingUpdate = { id: this._id };
         }
     }
-    function getIconUris(iconPath) {
-        if (iconPath instanceof ThemeIcon) {
-            return { id: iconPath.id };
-        }
-        const dark = getDarkIconUri(iconPath);
-        const light = getLightIconUri(iconPath);
-        return {
-            dark: typeof dark === 'string' ? URI.file(dark) : dark,
-            light: typeof light === 'string' ? URI.file(light) : light
-        };
-    }
-    function getLightIconUri(iconPath) {
-        return typeof iconPath === 'object' && 'light' in iconPath ? iconPath.light : iconPath;
-    }
-    function getDarkIconUri(iconPath) {
-        return typeof iconPath === 'object' && 'dark' in iconPath ? iconPath.dark : iconPath;
-    }
-    function getIconPathOrClass(icon) {
-        const iconPathOrIconClass = getIconUris(icon);
-        let iconPath;
-        let iconClass;
-        if ('id' in iconPathOrIconClass) {
-            iconClass = ThemeIcon$1.asClassName(iconPathOrIconClass);
-        }
-        else {
-            iconPath = iconPathOrIconClass;
-        }
-        return {
-            iconPath,
-            iconClass
-        };
-    }
     class ExtHostQuickPick extends ExtHostQuickInput {
         constructor(extension, onDispose) {
             super(extension, onDispose);
@@ -443,7 +424,6 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                 this._handlesToItems.set(i, item);
                 this._itemsToHandles.set(item, i);
             });
-            const allowedTooltips = isProposedApiEnabled(this._extension, 'quickPickItemTooltip');
             const pickItems = [];
             for (let handle = 0; handle < items.length; handle++) {
                 const item = items[handle];
@@ -451,23 +431,25 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                     pickItems.push({ type: 'separator', label: item.label });
                 }
                 else {
-                    if (item.tooltip && !allowedTooltips) {
-                        console.warn(`Extension '${this._extension.identifier.value}' uses a tooltip which is proposed API that is only available when running out of dev or with the following command line switch: --enable-proposed-api ${this._extension.identifier.value}`);
+                    if (item.tooltip) {
+                        checkProposedApiEnabled(this._extension, 'quickPickItemTooltip');
+                    }
+                    if (item.resourceUri) {
+                        checkProposedApiEnabled(this._extension, 'quickPickItemResource');
                     }
-                    const icon = (item.iconPath) ? getIconPathOrClass(item.iconPath) : undefined;
                     pickItems.push({
                         handle,
                         label: item.label,
-                        iconPath: icon?.iconPath,
-                        iconClass: icon?.iconClass,
+                        iconPathDto: IconPath.from(item.iconPath),
                         description: item.description,
                         detail: item.detail,
                         picked: item.picked,
                         alwaysShow: item.alwaysShow,
-                        tooltip: allowedTooltips ? MarkdownString.fromStrict(item.tooltip) : undefined,
+                        tooltip: MarkdownString.fromStrict(item.tooltip),
+                        resourceUri: item.resourceUri,
                         buttons: item.buttons?.map((button, i) => {
                             return {
-                                ...getIconPathOrClass(button.iconPath),
+                                iconPathDto: IconPath.from(button.iconPath),
                                 tooltip: button.tooltip,
                                 handle: i
                             };
@@ -514,6 +496,14 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._keepScrollPosition = keepScrollPosition;
             this.update({ keepScrollPosition });
         }
+        get prompt() {
+            return this._prompt;
+        }
+        set prompt(prompt) {
+            checkProposedApiEnabled(this._extension, 'quickPickPrompt');
+            this._prompt = prompt;
+            this.update({ prompt });
+        }
         get activeItems() {
             return this._activeItems;
         }

package/vscode/src/vs/workbench/api/common/extHostSCM.d.ts

@@ -1,7 +1,7 @@
 import { URI, UriComponents } from "../../../base/common/uri.js";
 import { Event } from "../../../base/common/event.js";
 import { ExtHostCommands } from "./extHostCommands.js";
-import { MainThreadSCMShape, IMainContext, ExtHostSCMShape, SCMHistoryItemDto, SCMHistoryItemChangeDto, SCMHistoryItemRefDto } from "./extHost.protocol.js";
+import { MainThreadSCMShape, IMainContext, ExtHostSCMShape, SCMHistoryItemDto, SCMHistoryItemChangeDto, SCMHistoryItemRefDto, SCMArtifactGroupDto, SCMArtifactDto } from "./extHost.protocol.js";
 import type * as vscode from "vscode";
 import { ILogService } from "../../../platform/log/common/log.service.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
@@ -69,4 +69,6 @@ export declare class ExtHostSCM implements ExtHostSCMShape {
     $provideHistoryItemRefs(sourceControlHandle: number, historyItemRefs: string[] | undefined, token: CancellationToken): Promise<SCMHistoryItemRefDto[] | undefined>;
     $provideHistoryItems(sourceControlHandle: number, options: vscode.SourceControlHistoryOptions, token: CancellationToken): Promise<SCMHistoryItemDto[] | undefined>;
     $provideHistoryItemChanges(sourceControlHandle: number, historyItemId: string, historyItemParentId: string | undefined, token: CancellationToken): Promise<SCMHistoryItemChangeDto[] | undefined>;
+    $provideArtifactGroups(sourceControlHandle: number, token: CancellationToken): Promise<SCMArtifactGroupDto[] | undefined>;
+    $provideArtifacts(sourceControlHandle: number, group: string, token: CancellationToken): Promise<SCMArtifactDto[] | undefined>;
 }