@codingame/monaco-vscode-api 17.2.1 → 18.0.1

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

@@ -12,11 +12,18 @@ import { McpServerLaunch, McpServerTransportType, McpConnectionState, extensionP
 import { MainContext } from './extHost.protocol.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
 import { McpServerDefinition } from './extHostTypeConverters.js';
+import { parseWWWAuthenticateHeader, getMetadataWithDefaultValues, getDefaultMetadataForUrl, isAuthorizationProtectedResourceMetadata, AUTH_SERVER_METADATA_DISCOVERY_PATH, isAuthorizationServerMetadata } from '../../../base/common/oauth.js';
+import { URI } from '../../../base/common/uri.js';
+import { MCP } from '../../contrib/mcp/common/modelContextProtocol.js';
+import { CancellationError } from '../../../base/common/errors.js';
+import { ConfigurationTarget } from '../../../platform/configuration/common/configuration.js';
+import { IExtHostInitDataService } from './extHostInitDataService.js';
 
 const IExtHostMpcService = ( createDecorator('IExtHostMpcService'));
 let ExtHostMcpService = class ExtHostMcpService extends Disposable {
-    constructor(extHostRpc) {
+    constructor(extHostRpc, _extHostInitData) {
         super();
+        this._extHostInitData = _extHostInitData;
         this._initialProviderPromises = ( new Set());
         this._sseEventSources = this._register(( new DisposableMap()));
         this._unresolvedMcpServers = ( new Map());
@@ -61,10 +68,10 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
     }
     registerMcpConfigurationProvider(extension, id, provider) {
         const store = ( new DisposableStore());
-        const metadata = extension.contributes?.modelContextServerCollections?.find(m => m.id === id);
+        const metadata = extension.contributes?.mcpServerDefinitionProviders?.find(m => m.id === id);
         if (!metadata) {
             throw ( new Error(
-                `MCP configuration providers must be registered in the contributes.modelContextServerCollections array within your package.json, but "${id}" was not`
+                `MCP configuration providers must be registered in the contributes.mcpServerDefinitionProviders array within your package.json, but "${id}" was not`
             ));
         }
         const mcp = {
@@ -74,6 +81,7 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
             scope: StorageScope.WORKSPACE,
             canResolveLaunch: typeof provider.resolveMcpServerDefinition === 'function',
             extensionId: extension.identifier.value,
+            configTarget: this._extHostInitData.remote.isRemote ? ConfigurationTarget.USER_REMOTE : ConfigurationTarget.USER,
         };
         const update = async () => {
             const list = await provider.provideMcpServerDefinitions(CancellationToken.None);
@@ -92,7 +100,7 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
                     id,
                     label: item.label,
                     cacheNonce: item.version,
-                    launch: McpServerDefinition.from(item)
+                    launch: McpServerDefinition.from(item),
                 });
             }
             this._proxy.$upsertMcpCollection(mcp, servers);
@@ -101,6 +109,9 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
             this._unresolvedMcpServers.delete(mcp.id);
             this._proxy.$deleteMcpCollection(mcp.id);
         }));
+        if (provider.onDidChangeMcpServerDefinitions) {
+            store.add(provider.onDidChangeMcpServerDefinitions(update));
+        }
         if (provider.onDidChangeServerDefinitions) {
             store.add(provider.onDidChangeServerDefinitions(update));
         }
@@ -118,7 +129,8 @@ let ExtHostMcpService = class ExtHostMcpService extends Disposable {
     }
 };
 ExtHostMcpService = ( __decorate([
-    ( __param(0, IExtHostRpcService))
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, IExtHostInitDataService))
 ], ExtHostMcpService));
 var HttpMode;
 (function (HttpMode) {
@@ -170,28 +182,27 @@ class McpHTTPHandle extends Disposable {
         if (sessionId) {
             headers['Mcp-Session-Id'] = sessionId;
         }
-        const res = await fetch(( this._launch.uri.toString(true)), {
+        await this._addAuthHeader(headers);
+        const res = await this._fetchWithAuthRetry(( this._launch.uri.toString(true)), {
             method: 'POST',
             signal: this._abortCtrl.signal,
             headers,
             body: asBytes,
-        });
+        }, headers);
         const wasUnknown = this._mode.value === HttpMode.Unknown;
         const nextSessionId = res.headers.get('Mcp-Session-Id');
         if (nextSessionId) {
             this._mode = { value: HttpMode.Http, sessionId: nextSessionId };
         }
-        if (this._mode.value === HttpMode.Unknown && res.status >= 400 && res.status < 500) {
+        if (this._mode.value === HttpMode.Unknown &&
+            res.status >= 400 && res.status < 500
+            && res.status !== 401 && res.status !== 403) {
             this._log(LogLevel.Info, `${res.status} status sending message to ${this._launch.uri}, will attempt to fall back to legacy SSE`);
-            const endpoint = await this._attachSSE();
-            if (endpoint) {
-                this._mode = { value: HttpMode.SSE, endpoint };
-                await this._sendLegacySSE(endpoint, message);
-            }
+            this._sseFallbackWithMessage(message);
             return;
         }
         if (res.status >= 300) {
-            const retryWithSessionId = this._mode.value === HttpMode.Http && !!this._mode.sessionId;
+            const retryWithSessionId = this._mode.value === HttpMode.Http && !!this._mode.sessionId && (res.status === 400 || res.status === 404);
             this._proxy.$onDidChangeState(this._id, {
                 state: McpConnectionState.Kind.Error,
                 message: `${res.status} status sending message to ${this._launch.uri}: ${await this._getErrText(res)}` + retryWithSessionId ? `; will retry with new session ID` : '',
@@ -205,9 +216,129 @@ class McpHTTPHandle extends Disposable {
         if (wasUnknown) {
             this._attachStreamableBackchannel();
         }
-        this._handleSuccessfulStreamableHttp(res);
+        this._handleSuccessfulStreamableHttp(res, message);
+    }
+    async _sseFallbackWithMessage(message) {
+        const endpoint = await this._attachSSE();
+        if (endpoint) {
+            this._mode = { value: HttpMode.SSE, endpoint };
+            await this._sendLegacySSE(endpoint, message);
+        }
+    }
+    async _populateAuthMetadata(originalResponse) {
+        let resourceMetadataChallenge;
+        if (( originalResponse.headers.has('WWW-Authenticate'))) {
+            const authHeader = originalResponse.headers.get('WWW-Authenticate');
+            const { scheme, params } = parseWWWAuthenticateHeader(authHeader);
+            if (scheme === 'Bearer' && params['resource_metadata']) {
+                resourceMetadataChallenge = params['resource_metadata'];
+            }
+        }
+        let serverMetadataUrl;
+        let scopesSupported;
+        let resource;
+        if (resourceMetadataChallenge) {
+            const resourceMetadata = await this._getResourceMetadata(resourceMetadataChallenge);
+            serverMetadataUrl = resourceMetadata.authorization_servers?.[0];
+            scopesSupported = resourceMetadata.scopes_supported;
+            resource = resourceMetadata;
+        }
+        const baseUrl = ( new URL(originalResponse.url)).origin;
+        let addtionalHeaders = {};
+        if (!serverMetadataUrl) {
+            serverMetadataUrl = baseUrl;
+            addtionalHeaders = {
+                ...Object.fromEntries(this._launch.headers)
+            };
+        }
+        try {
+            const serverMetadataResponse = await this._getAuthorizationServerMetadata(serverMetadataUrl, addtionalHeaders);
+            const serverMetadataWithDefaults = getMetadataWithDefaultValues(serverMetadataResponse);
+            this._authMetadata = {
+                authorizationServer: ( URI.parse(serverMetadataUrl)),
+                serverMetadata: serverMetadataWithDefaults,
+                resourceMetadata: resource
+            };
+            return;
+        }
+        catch (e) {
+            this._log(LogLevel.Warning, `Error populating auth metadata: ${String(e)}`);
+        }
+        const defaultMetadata = getDefaultMetadataForUrl(( new URL(baseUrl)));
+        defaultMetadata.scopes_supported = scopesSupported ?? defaultMetadata.scopes_supported ?? [];
+        this._authMetadata = {
+            authorizationServer: ( URI.parse(serverMetadataUrl)),
+            serverMetadata: defaultMetadata,
+            resourceMetadata: resource
+        };
+    }
+    async _getResourceMetadata(resourceMetadata) {
+        const resourceMetadataUrl = ( new URL(resourceMetadata));
+        const mcpServerUrl = ( new URL(( this._launch.uri.toString(true))));
+        let additionalHeaders = {};
+        if (resourceMetadataUrl.origin === mcpServerUrl.origin) {
+            additionalHeaders = {
+                ...Object.fromEntries(this._launch.headers)
+            };
+        }
+        const resourceMetadataResponse = await fetch(resourceMetadata, {
+            method: 'GET',
+            signal: this._abortCtrl.signal,
+            headers: {
+                ...additionalHeaders,
+                'Accept': 'application/json',
+                'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION
+            }
+        });
+        if (resourceMetadataResponse.status !== 200) {
+            throw ( new Error(
+                `Failed to fetch resource metadata: ${resourceMetadataResponse.status} ${await this._getErrText(resourceMetadataResponse)}`
+            ));
+        }
+        const body = await resourceMetadataResponse.json();
+        if (isAuthorizationProtectedResourceMetadata(body)) {
+            return body;
+        }
+        else {
+            throw ( new Error(`Invalid resource metadata: ${JSON.stringify(body)}`));
+        }
     }
-    async _handleSuccessfulStreamableHttp(res) {
+    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;
+        let authServerMetadataResponse = await fetch(pathToFetch, {
+            method: 'GET',
+            signal: this._abortCtrl.signal,
+            headers: {
+                ...addtionalHeaders,
+                'Accept': 'application/json',
+                'MCP-Protocol-Version': MCP.LATEST_PROTOCOL_VERSION,
+            }
+        });
+        if (authServerMetadataResponse.status !== 200) {
+            authServerMetadataResponse = await fetch(( URI.joinPath(( URI.parse(authorizationServer)), '.well-known', 'openid-configuration').toString(true)), {
+                method: 'GET',
+                signal: this._abortCtrl.signal,
+                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;
         }
@@ -217,6 +348,11 @@ class McpHTTPHandle extends Disposable {
                     if (event.type === 'message') {
                         this._proxy.$onDidReceiveMessage(this._id, event.data);
                     }
+                    else if (event.type === 'endpoint') {
+                        this._log(LogLevel.Warning, `Received SSE endpoint from a POST to ${this._launch.uri}, will fall back to legacy SSE`);
+                        this._sseFallbackWithMessage(message);
+                        throw ( new CancellationError());
+                    }
                 }));
                 try {
                     await this._doSSE(parser, res);
@@ -250,17 +386,18 @@ class McpHTTPHandle extends Disposable {
                     ...Object.fromEntries(this._launch.headers),
                     'Accept': 'text/event-stream',
                 };
+                await this._addAuthHeader(headers);
                 if (this._mode.value === HttpMode.Http && this._mode.sessionId !== undefined) {
                     headers['Mcp-Session-Id'] = this._mode.sessionId;
                 }
                 if (lastEventId) {
                     headers['Last-Event-ID'] = lastEventId;
                 }
-                res = await fetch(( this._launch.uri.toString(true)), {
+                res = await this._fetchWithAuthRetry(( this._launch.uri.toString(true)), {
                     method: 'GET',
                     signal: this._abortCtrl.signal,
                     headers,
-                });
+                }, headers);
             }
             catch (e) {
                 this._log(LogLevel.Info, `Error connecting to ${this._launch.uri} for async notifications, will retry`);
@@ -289,16 +426,18 @@ class McpHTTPHandle extends Disposable {
     }
     async _attachSSE() {
         const postEndpoint = ( new DeferredPromise());
+        const headers = {
+            ...Object.fromEntries(this._launch.headers),
+            'Accept': 'text/event-stream',
+        };
+        await this._addAuthHeader(headers);
         let res;
         try {
-            res = await fetch(( this._launch.uri.toString(true)), {
+            res = await this._fetchWithAuthRetry(( this._launch.uri.toString(true)), {
                 method: 'GET',
                 signal: this._abortCtrl.signal,
-                headers: {
-                    ...Object.fromEntries(this._launch.headers),
-                    'Accept': 'text/event-stream',
-                },
-            });
+                headers,
+            }, headers);
             if (res.status >= 300) {
                 this._proxy.$onDidChangeState(this._id, { state: McpConnectionState.Kind.Error, message: `${res.status} status connecting to ${this._launch.uri} as SSE: ${await this._getErrText(res)}` });
                 return;
@@ -324,14 +463,16 @@ class McpHTTPHandle extends Disposable {
     }
     async _sendLegacySSE(url, message) {
         const asBytes = ( new TextEncoder()).encode(message);
+        const headers = {
+            ...Object.fromEntries(this._launch.headers),
+            'Content-Type': 'application/json',
+            'Content-Length': String(asBytes.length),
+        };
+        await this._addAuthHeader(headers);
         const res = await fetch(url, {
             method: 'POST',
             signal: this._abortCtrl.signal,
-            headers: {
-                ...Object.fromEntries(this._launch.headers),
-                'Content-Type': 'application/json',
-                'Content-Length': String(asBytes.length),
-            },
+            headers,
             body: asBytes,
         });
         if (res.status >= 300) {
@@ -362,6 +503,20 @@ class McpHTTPHandle extends Disposable {
             }
         } while (!chunk.done);
     }
+    async _addAuthHeader(headers) {
+        if (this._authMetadata) {
+            try {
+                const token = await this._proxy.$getTokenFromServerMetadata(this._id, this._authMetadata.authorizationServer, this._authMetadata.serverMetadata, this._authMetadata.resourceMetadata);
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
+                }
+            }
+            catch (e) {
+                this._log(LogLevel.Warning, `Error getting token from server metadata: ${String(e)}`);
+            }
+        }
+        return headers;
+    }
     _log(level, message) {
         if (!this._store.isDisposed) {
             this._proxy.$onDidPublishLog(this._id, level, message);
@@ -375,6 +530,21 @@ class McpHTTPHandle extends Disposable {
             return res.statusText;
         }
     }
+    async _fetchWithAuthRetry(url, init, headers) {
+        const doFetch = () => fetch(url, init);
+        let res = await doFetch();
+        if (res.status === 401) {
+            if (!this._authMetadata) {
+                await this._populateAuthMetadata(res);
+                await this._addAuthHeader(headers);
+                if (headers['Authorization']) {
+                    init.headers = headers;
+                    res = await doFetch();
+                }
+            }
+        }
+        return res;
+    }
 }
 function isJSON(str) {
     try {

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-42931eb9-e564-530c-bafc-fa23ab43a070-common/vscode/vs/workbench/contrib/search/common/search";
+import { NotebookPriorityInfo } from "@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-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;

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

@@ -260,7 +260,7 @@ class ExtHostNotebookController {
             throw ( new Error('Document version mismatch'));
         }
         if (!this._extHostFileSystem.value.isWritableFileSystem(uri.scheme)) {
-            throw new FileOperationError(( localize(2564, "Unable to modify read-only file '{0}'", this._resourceForError(uri))), FileOperationResult.FILE_PERMISSION_DENIED);
+            throw new FileOperationError(( localize(2588, "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]),
@@ -432,7 +432,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(2565, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
+            throw new FileOperationError(( localize(2589, "File Modified Since")), FileOperationResult.FILE_MODIFIED_SINCE, options);
         }
         return;
     }

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

@@ -35,8 +35,8 @@ class ExtHostNotebookEditor {
                     if (!Array.isArray(value) || !value.every(NotebookRange$1.isNotebookRange)) {
                         throw illegalArgument('selections');
                     }
-                    that._selections = value;
-                    that._trySetSelections(value);
+                    that._selections = value.length === 0 ? [( new NotebookRange$1(0, 0))] : value;
+                    that._trySetSelections(that._selections);
                 },
                 get visibleRanges() {
                     return that._visibleRanges;
@@ -71,7 +71,7 @@ class ExtHostNotebookEditor {
         this._visibleRanges = value;
     }
     _acceptSelections(selections) {
-        this._selections = selections;
+        this._selections = selections.length === 0 ? [( new NotebookRange$1(0, 0))] : selections;
     }
     _trySetSelections(value) {
         this._proxy.$trySetSelections(this.id, ( value.map(NotebookRange.from)));

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

@@ -6,7 +6,7 @@ import { ExtHostNotebookKernelsShape, IMainContext } from "./extHost.protocol.js
 import { ExtHostCommands } from "./extHostCommands.js";
 import { IExtHostInitDataService } from "./extHostInitDataService.js";
 import { ExtHostNotebookController } from "./extHostNotebook.js";
-import { INotebookKernelSourceAction, NotebookCellExecutionState } from "../../contrib/notebook/common/notebookCommon.js";
+import { INotebookKernelSourceAction } from "../../contrib/notebook/common/notebookCommon.js";
 import * as vscode from "vscode";
 export declare class ExtHostNotebookKernels implements ExtHostNotebookKernelsShape {
     private readonly _initData;
@@ -22,8 +22,6 @@ export declare class ExtHostNotebookKernels implements ExtHostNotebookKernelsSha
     private _kernelSourceActionProviderHandlePool;
     private readonly _kernelData;
     private _handlePool;
-    private readonly _onDidChangeCellExecutionState;
-    readonly onDidChangeNotebookCellExecutionState: import("../../../base/common/event.js").Event<vscode.NotebookCellExecutionStateChangeEvent>;
     constructor(mainContext: IMainContext, _initData: IExtHostInitDataService, _extHostNotebook: ExtHostNotebookController, _commands: ExtHostCommands, _logService: ILogService);
     createNotebookController(extension: IExtensionDescription, id: string, viewType: string, label: string, handler?: (cells: vscode.NotebookCell[], notebook: vscode.NotebookDocument, controller: vscode.NotebookController) => void | Thenable<void>, preloads?: vscode.NotebookRendererScript[]): vscode.NotebookController;
     getIdByController(controller: vscode.NotebookController): string | null;
@@ -39,7 +37,6 @@ export declare class ExtHostNotebookKernels implements ExtHostNotebookKernelsSha
     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;
-    $cellExecutionChanged(uri: UriComponents, cellHandle: number, state: NotebookCellExecutionState | undefined): void;
     _createNotebookCellExecution(cell: vscode.NotebookCell, controllerId: string): vscode.NotebookCellExecution;
     _createNotebookExecution(nb: vscode.NotebookDocument, controllerId: string): vscode.NotebookExecution;
 }

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

@@ -11,8 +11,8 @@ import { ExtensionIdentifier } from '../../../platform/extensions/common/extensi
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { MainContext } from './extHost.protocol.js';
 import { ApiCommand, ApiCommandArgument, ApiCommandResult } from './extHostCommands.js';
-import { NotebookRendererScript, NotebookKernelSourceAction, NotebookCellExecutionState, NotebookCellOutput as NotebookCellOutput$1, NotebookCellOutputItem } from './extHostTypeConverters.js';
-import { NotebookControllerAffinity2, NotebookVariablesRequestKind, NotebookCellExecutionState as NotebookCellExecutionState$1, NotebookCellOutput } from './extHostTypes.js';
+import { NotebookRendererScript, NotebookKernelSourceAction, NotebookCellOutput as NotebookCellOutput$1, NotebookCellOutputItem } from './extHostTypeConverters.js';
+import { NotebookControllerAffinity2, NotebookVariablesRequestKind, NotebookCellOutput } from './extHostTypes.js';
 import { asWebviewUri } from '../../contrib/webview/common/webview.js';
 import { CellExecutionUpdateType } from '../../contrib/notebook/common/notebookExecutionService.js';
 import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
@@ -33,8 +33,6 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
         this._kernelSourceActionProviderHandlePool = 0;
         this._kernelData = ( new Map());
         this._handlePool = 0;
-        this._onDidChangeCellExecutionState = ( new Emitter());
-        this.onDidChangeNotebookCellExecutionState = this._onDidChangeCellExecutionState.event;
         this.id = 0;
         this.variableStore = {};
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadNotebookKernels));
@@ -424,19 +422,6 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
         const editor = this._extHostNotebook.getEditorById(editorId);
         obj.onDidReceiveMessage.fire(( Object.freeze({ editor: editor.apiEditor, message })));
     }
-    $cellExecutionChanged(uri, cellHandle, state) {
-        const document = this._extHostNotebook.getNotebookDocument(URI.revive(uri));
-        const cell = document.getCell(cellHandle);
-        if (cell) {
-            const newState = state ? NotebookCellExecutionState.to(state) : NotebookCellExecutionState$1.Idle;
-            if (newState !== undefined) {
-                this._onDidChangeCellExecutionState.fire({
-                    cell: cell.apiCell,
-                    state: newState
-                });
-            }
-        }
-    }
     _createNotebookCellExecution(cell, controllerId) {
         if (cell.index < 0) {
             throw ( new Error('CANNOT execute cell that has been REMOVED from notebook'));

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

@@ -1,14 +1,21 @@
 import { ProgressOptions } from "vscode";
-import { MainThreadProgressShape, ExtHostProgressShape } from "./extHost.protocol.js";
+import { ExtHostProgressShape } from "./extHost.protocol.js";
 import { Progress, IProgressStep } from "../../../platform/progress/common/progress.js";
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
+import { INotificationSource } from "../../../platform/notification/common/notification.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+export interface IExtHostProgress extends ExtHostProgress {
+}
+export declare const IExtHostProgress: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostProgress>;
 export declare class ExtHostProgress implements ExtHostProgressShape {
+    readonly _serviceBrand: undefined;
     private _proxy;
     private _handles;
     private _mapHandleToCancellationSource;
-    constructor(proxy: MainThreadProgressShape);
+    constructor(extHostRpc: IExtHostRpcService);
     withProgress<R>(extension: IExtensionDescription, options: ProgressOptions, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>): Promise<R>;
+    withProgressFromSource<R>(source: string | INotificationSource, options: ProgressOptions, task: (progress: Progress<IProgressStep>, token: CancellationToken) => Thenable<R>): Promise<R>;
     private _withProgress;
     $acceptProgressCanceled(handle: number): void;
 }

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

@@ -1,16 +1,20 @@
 
-import { __decorate } from '../../../../../../external/tslib/tslib.es6.js';
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { MainContext } from './extHost.protocol.js';
 import { ProgressLocation } from './extHostTypeConverters.js';
 import { Progress } from '../../../platform/progress/common/progress.js';
 import { CancellationTokenSource, CancellationToken } from '../../../base/common/cancellation.js';
 import { throttle } from '../../../base/common/decorators.js';
 import { onUnexpectedExternalError } from '../../../base/common/errors.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
 
-class ExtHostProgress {
-    constructor(proxy) {
+const IExtHostProgress = ( createDecorator('IExtHostProgress'));
+let ExtHostProgress = class ExtHostProgress {
+    constructor(extHostRpc) {
         this._handles = 0;
         this._mapHandleToCancellationSource = ( new Map());
-        this._proxy = proxy;
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadProgress));
     }
     async withProgress(extension, options, task) {
         const handle = this._handles++;
@@ -19,6 +23,12 @@ class ExtHostProgress {
         this._proxy.$startProgress(handle, { location: ProgressLocation.from(location), title, source, cancellable }, !extension.isUnderDevelopment ? extension.identifier.value : undefined).catch(onUnexpectedExternalError);
         return this._withProgress(handle, task, !!cancellable);
     }
+    async withProgressFromSource(source, options, task) {
+        const handle = this._handles++;
+        const { title, location, cancellable } = options;
+        this._proxy.$startProgress(handle, { location: ProgressLocation.from(location), title, source, cancellable }, undefined).catch(onUnexpectedExternalError);
+        return this._withProgress(handle, task, !!cancellable);
+    }
     _withProgress(handle, task, cancellable) {
         let source;
         if (cancellable) {
@@ -48,7 +58,10 @@ class ExtHostProgress {
             this._mapHandleToCancellationSource.delete(handle);
         }
     }
-}
+};
+ExtHostProgress = ( __decorate([
+    ( __param(0, IExtHostRpcService))
+], ExtHostProgress));
 function mergeProgress(result, currentValue) {
     result.message = currentValue.message;
     if (typeof currentValue.increment === 'number') {
@@ -75,4 +88,4 @@ ProgressCallback.__decorator = ( __decorate([
     throttle(100, (result, currentValue) => mergeProgress(result, currentValue), () => Object.create(null))
 ], ProgressCallback.prototype, "throttledReport", null));
 
-export { ExtHostProgress };
+export { ExtHostProgress, IExtHostProgress };

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

@@ -63,6 +63,7 @@ export declare class ExtHostSCM implements ExtHostSCMShape {
         number
     ] | undefined>;
     $setSelectedSourceControl(selectedSourceControlHandle: number | undefined): Promise<void>;
+    $resolveHistoryItemChatContext(sourceControlHandle: number, historyItemId: string, token: CancellationToken): Promise<string | undefined>;
     $resolveHistoryItemRefsCommonAncestor(sourceControlHandle: number, historyItemRefs: string[], token: CancellationToken): Promise<string | undefined>;
     $provideHistoryItemRefs(sourceControlHandle: number, historyItemRefs: string[] | undefined, token: CancellationToken): Promise<SCMHistoryItemRefDto[] | undefined>;
     $provideHistoryItems(sourceControlHandle: number, options: any, token: CancellationToken): Promise<SCMHistoryItemDto[] | undefined>;

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

@@ -831,6 +831,17 @@ let ExtHostSCM = class ExtHostSCM {
         this._selectedSourceControlHandle = selectedSourceControlHandle;
         return Promise.resolve(undefined);
     }
+    async $resolveHistoryItemChatContext(sourceControlHandle, historyItemId, token) {
+        try {
+            const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;
+            const chatContext = await historyProvider?.resolveHistoryItemChatContext(historyItemId, token);
+            return chatContext ?? undefined;
+        }
+        catch (err) {
+            this.logService.error('ExtHostSCM#$resolveHistoryItemChatContext', err);
+            return undefined;
+        }
+    }
     async $resolveHistoryItemRefsCommonAncestor(sourceControlHandle, historyItemRefs, token) {
         try {
             const historyProvider = this._sourceControls.get(sourceControlHandle)?.historyProvider;

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

@@ -188,7 +188,7 @@ class ExtHostStatusBarEntry {
             }
             else {
                 name = ( localize(
-                    2566,
+                    2590,
                     "{0} (Extension)",
                     this._extension.displayName || this._extension.name
                 ));
@@ -221,7 +221,7 @@ class StatusBarMessage {
     constructor(statusBar) {
         this._messages = [];
         this._item = statusBar.createStatusBarEntry(undefined, 'status.extensionMessage', StatusBarAlignment.Left, Number.MIN_VALUE);
-        this._item.name = ( localize(2567, "Extension Status"));
+        this._item.name = ( localize(2591, "Extension Status"));
     }
     dispose() {
         this._messages.length = 0;

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

@@ -1,6 +1,6 @@
 import { ExtHostStorageShape } from "./extHost.protocol.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
-import { IExtensionIdWithVersion } from "@codingame/monaco-vscode-a2719803-af40-5ae9-a29f-8a2231c33056-common/vscode/vs/platform/extensionManagement/common/extensionStorage";
+import { IExtensionIdWithVersion } from "@codingame/monaco-vscode-cecd476b-6f89-54b7-b016-fe6fdaa6675e-common/vscode/vs/platform/extensionManagement/common/extensionStorage";
 import { ILogService } from "../../../platform/log/common/log.service.js";
 export interface IStorageChangeEvent {
     shared: boolean;

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

@@ -28,7 +28,7 @@ let ExtHostTelemetry = class ExtHostTelemetry extends Disposable {
         const id = initData.remote.isRemote ? 'remoteExtHostTelemetry' : isWorker ? 'workerExtHostTelemetry' : 'extHostTelemetry';
         this._outputLogger = this._register(loggerService.createLogger(id, {
             name: ( localize(
-                2568,
+                2592,
                 "Extension Telemetry{0}",
                 this._inLoggingOnlyMode ? ' (Not Sent)' : ''
             )),

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

@@ -482,7 +482,7 @@ let BaseExtHostTerminalService = class BaseExtHostTerminalService extends Dispos
     async $startExtensionTerminal(id, initialDimensions) {
         const terminal = this.getTerminalById(id);
         if (!terminal) {
-            return { message: ( localize(2569, "Could not find the terminal with id {0} on the extension host", id)) };
+            return { message: ( localize(2593, "Could not find the terminal with id {0} on the extension host", id)) };
         }
         if (!terminal.isOpen) {
             await ( new Promise(r => {