@codingame/monaco-vscode-extensions-service-override 2.2.2 → 3.1.0

package/vscode/src/vs/workbench/api/browser/mainThreadChat.js

@@ -34,7 +34,6 @@ let MainThreadChat = class MainThreadChat extends Disposable {
         }
         const unreg = this._chatService.registerProvider({
             id,
-            displayName: registration.label,
             prepareSession: async (token) => {
                 const session = await this._proxy.$prepareChat(handle, token);
                 if (!session) {
@@ -58,12 +57,6 @@ let MainThreadChat = class MainThreadChat extends Disposable {
                     }
                 };
             },
-            provideWelcomeMessage: (token) => {
-                return this._proxy.$provideWelcomeMessage(handle, token);
-            },
-            provideSampleQuestions: (token) => {
-                return this._proxy.$provideSampleQuestions(handle, token);
-            },
         });
         this._providerRegistrations.set(handle, unreg);
     }

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js

@@ -36,10 +36,10 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 for (const [handle, agent] of this._agents) {
                     if (agent.name === e.agentId) {
                         if (e.action.kind === 'vote') {
-                            this._proxy.$acceptFeedback(handle, e.sessionId, e.requestId, e.action.direction);
+                            this._proxy.$acceptFeedback(handle, e.result ?? {}, e.action.direction);
                         }
                         else {
-                            this._proxy.$acceptAction(handle, e.sessionId, e.requestId, e);
+                            this._proxy.$acceptAction(handle, e.result || {}, e);
                         }
                         break;
                     }
@@ -50,9 +50,11 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     $unregisterAgent(handle) {
         this._agents.deleteAndDispose(handle);
     }
-    $registerAgent(handle, name, metadata) {
+    $registerAgent(handle, extension, name, metadata) {
+        const lastSlashCommands = ( new WeakMap());
         const d = this._chatAgentService.registerAgent({
             id: name,
+            extensionId: extension,
             metadata: revive(metadata),
             invoke: async (request, progress, history, token) => {
                 this._pendingProgress.set(request.requestId, progress);
@@ -63,17 +65,30 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     this._pendingProgress.delete(request.requestId);
                 }
             },
-            provideFollowups: async (sessionId, token) => {
+            provideFollowups: async (request, result, token) => {
                 if (!this._agents.get(handle)?.hasFollowups) {
                     return [];
                 }
-                return this._proxy.$provideFollowups(handle, sessionId, token);
+                return this._proxy.$provideFollowups(request, handle, result, token);
             },
-            provideSlashCommands: async (token) => {
+            getLastSlashCommands: (model) => {
+                return lastSlashCommands.get(model);
+            },
+            provideSlashCommands: async (model, history, token) => {
                 if (!this._agents.get(handle)?.hasSlashCommands) {
                     return [];
                 }
-                return this._proxy.$provideSlashCommands(handle, token);
+                const commands = await this._proxy.$provideSlashCommands(handle, { history }, token);
+                if (model) {
+                    lastSlashCommands.set(model, commands);
+                }
+                return commands;
+            },
+            provideWelcomeMessage: (token) => {
+                return this._proxy.$provideWelcomeMessage(handle, token);
+            },
+            provideSampleQuestions: (token) => {
+                return this._proxy.$provideSampleQuestions(handle, token);
             }
         });
         this._agents.set(handle, {
@@ -111,7 +126,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
                     return;
                 }
-                const parsedRequest = (await this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const parsedRequest = this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue()).parts;
                 const agentPart = parsedRequest.find((part) => part instanceof ChatRequestAgentPart);
                 const thisAgentName = this._agents.get(handle)?.name;
                 if (agentPart?.agent.id !== thisAgentName) {

package/vscode/src/vs/workbench/api/browser/mainThreadChatProvider.js

@@ -1,37 +1,66 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore, DisposableMap, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
 import { IChatProviderService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatProvider';
+import { IAuthenticationService, INTERNAL_AUTH_PROVIDER_PREFIX } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
+import { IExtensionFeaturesManagementService, Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 
 let MainThreadChatProvider = class MainThreadChatProvider {
-    constructor(extHostContext, _chatProviderService, _logService) {
+    constructor(extHostContext, _chatProviderService, _extensionFeaturesManagementService, _logService, _authenticationService, _extensionService) {
         this._chatProviderService = _chatProviderService;
+        this._extensionFeaturesManagementService = _extensionFeaturesManagementService;
         this._logService = _logService;
+        this._authenticationService = _authenticationService;
+        this._extensionService = _extensionService;
+        this._store = ( new DisposableStore());
         this._providerRegistrations = ( new DisposableMap());
         this._pendingProgress = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatProvider));
+        this._proxy.$updateLanguageModels({ added: _chatProviderService.getProviders() });
+        this._store.add(_chatProviderService.onDidChangeProviders(this._proxy.$updateLanguageModels, this._proxy));
     }
     dispose() {
         this._providerRegistrations.dispose();
+        this._store.dispose();
     }
     $registerProvider(handle, identifier, metadata) {
-        const registration = this._chatProviderService.registerChatResponseProvider(identifier, {
+        const dipsosables = ( new DisposableStore());
+        dipsosables.add(this._chatProviderService.registerChatResponseProvider(identifier, {
             metadata,
-            provideChatResponse: async (messages, options, progress, token) => {
+            provideChatResponse: async (messages, from, options, progress, token) => {
                 const requestId = (Math.random() * 1e6) | 0;
                 this._pendingProgress.set(requestId, progress);
                 try {
-                    await this._proxy.$provideChatResponse(handle, requestId, messages, options, token);
+                    await this._proxy.$provideLanguageModelResponse(handle, requestId, from, messages, options, token);
                 }
                 finally {
                     this._pendingProgress.delete(requestId);
                 }
             }
-        });
-        this._providerRegistrations.set(handle, registration);
+        }));
+        if (metadata.auth) {
+            dipsosables.add(this._registerAuthenticationProvider(metadata.extension, metadata.auth));
+        }
+        dipsosables.add(( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+            id: `lm-${identifier}`,
+            label: ( localizeWithPath(
+                'vs/workbench/api/browser/mainThreadChatProvider',
+                'languageModels',
+                "Language Model ({0})",
+                `${identifier}`
+            )),
+            access: {
+                canToggle: false,
+            },
+        }));
+        this._providerRegistrations.set(handle, dipsosables);
     }
     async $handleProgressChunk(requestId, chunk) {
         this._pendingProgress.get(requestId)?.report(chunk);
@@ -39,26 +68,134 @@ let MainThreadChatProvider = class MainThreadChatProvider {
     $unregisterProvider(handle) {
         this._providerRegistrations.deleteAndDispose(handle);
     }
-    async $prepareChatAccess(providerId) {
+    async $prepareChatAccess(extension, providerId, justification) {
+        const activate = this._extensionService.activateByEvent(`onLanguageModelAccess:${providerId}`);
+        const metadata = this._chatProviderService.lookupChatResponseProvider(providerId);
+        if (metadata) {
+            return metadata;
+        }
+        await Promise.race([
+            activate,
+            Event.toPromise(Event.filter(this._chatProviderService.onDidChangeProviders, e => Boolean(e.added?.includes(providerId))))
+        ]);
         return this._chatProviderService.lookupChatResponseProvider(providerId);
     }
     async $fetchResponse(extension, providerId, requestId, messages, options, token) {
+        await this._extensionFeaturesManagementService.getAccess(extension, `lm-${providerId}`);
         this._logService.debug('[CHAT] extension request STARTED', extension.value, requestId);
-        const task = this._chatProviderService.fetchChatResponse(providerId, messages, options, ( new Progress(value => {
+        const task = this._chatProviderService.fetchChatResponse(providerId, extension, messages, options, ( new Progress(value => {
             this._proxy.$handleResponseFragment(requestId, value);
         })), token);
         task.catch(err => {
             this._logService.error('[CHAT] extension request ERRORED', err, extension.value, requestId);
+            throw err;
         }).finally(() => {
             this._logService.debug('[CHAT] extension request DONE', extension.value, requestId);
         });
         return task;
     }
+    _registerAuthenticationProvider(extension, auth) {
+        const authProviderId = INTERNAL_AUTH_PROVIDER_PREFIX + extension.value;
+        if (this._authenticationService.getProviderIds().includes(authProviderId)) {
+            return Disposable.None;
+        }
+        const accountLabel = auth.accountLabel ?? ( localizeWithPath(
+            'vs/workbench/api/browser/mainThreadChatProvider',
+            'languageModelsAccountId',
+            'Language Models'
+        ));
+        const disposables = ( new DisposableStore());
+        this._authenticationService.registerAuthenticationProvider(authProviderId, ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel)));
+        disposables.add(toDisposable(() => {
+            this._authenticationService.unregisterAuthenticationProvider(authProviderId);
+        }));
+        disposables.add(this._authenticationService.onDidChangeSessions(async (e) => {
+            if (e.providerId === authProviderId) {
+                if (e.event.removed?.length) {
+                    const allowedExtensions = this._authenticationService.readAllowedExtensions(authProviderId, accountLabel);
+                    const extensionsToUpdateAccess = [];
+                    for (const allowed of allowedExtensions) {
+                        const from = await this._extensionService.getExtension(allowed.id);
+                        this._authenticationService.updateAllowedExtension(authProviderId, authProviderId, allowed.id, allowed.name, false);
+                        if (from) {
+                            extensionsToUpdateAccess.push({
+                                from: from.identifier,
+                                to: extension,
+                                enabled: false
+                            });
+                        }
+                    }
+                    this._proxy.$updateModelAccesslist(extensionsToUpdateAccess);
+                }
+            }
+        }));
+        disposables.add(this._authenticationService.onDidChangeExtensionSessionAccess(async (e) => {
+            const allowedExtensions = this._authenticationService.readAllowedExtensions(authProviderId, accountLabel);
+            const accessList = [];
+            for (const allowedExtension of allowedExtensions) {
+                const from = await this._extensionService.getExtension(allowedExtension.id);
+                if (from) {
+                    accessList.push({
+                        from: from.identifier,
+                        to: extension,
+                        enabled: allowedExtension.allowed ?? true
+                    });
+                }
+            }
+            this._proxy.$updateModelAccesslist(accessList);
+        }));
+        return disposables;
+    }
 };
 MainThreadChatProvider = __decorate([
     extHostNamedCustomer(MainContext.MainThreadChatProvider),
     ( __param(1, IChatProviderService)),
-    ( __param(2, ILogService))
+    ( __param(2, IExtensionFeaturesManagementService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IAuthenticationService)),
+    ( __param(5, IExtensionService))
 ], MainThreadChatProvider);
+class LanguageModelAccessAuthProvider {
+    constructor(id, label, _accountLabel) {
+        this.id = id;
+        this.label = label;
+        this._accountLabel = _accountLabel;
+        this.supportsMultipleAccounts = false;
+        this._onDidChangeSessions = ( new Emitter());
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+    }
+    async getSessions(scopes) {
+        if (scopes === undefined && !this._session) {
+            return [];
+        }
+        if (this._session) {
+            return [this._session];
+        }
+        return [await this.createSession(scopes || [], {})];
+    }
+    async createSession(scopes, options) {
+        this._session = this._createFakeSession(scopes);
+        this._onDidChangeSessions.fire({ added: [this._session], changed: [], removed: [] });
+        return this._session;
+    }
+    removeSession(sessionId) {
+        if (this._session) {
+            this._onDidChangeSessions.fire({ added: [], changed: [], removed: [this._session] });
+            this._session = undefined;
+        }
+        return Promise.resolve();
+    }
+    _createFakeSession(scopes) {
+        return {
+            id: 'fake-session',
+            account: {
+                id: this.id,
+                label: this._accountLabel,
+            },
+            accessToken: 'fake-access-token',
+            scopes,
+        };
+    }
+}
 
 export { MainThreadChatProvider };

package/vscode/src/vs/workbench/api/browser/mainThreadChatVariables.js

@@ -9,17 +9,26 @@ let MainThreadChatVariables = class MainThreadChatVariables {
     constructor(extHostContext, _chatVariablesService) {
         this._chatVariablesService = _chatVariablesService;
         this._variables = ( new DisposableMap());
+        this._pendingProgress = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatVariables));
     }
     dispose() {
         this._variables.clearAndDisposeAll();
     }
     $registerVariable(handle, data) {
-        const registration = this._chatVariablesService.registerVariable(data, async (messageText, _arg, _model, token) => {
-            return revive(await this._proxy.$resolveVariable(handle, messageText, token));
+        const registration = this._chatVariablesService.registerVariable(data, async (messageText, _arg, model, progress, token) => {
+            const varRequestId = `${model.sessionId}-${handle}`;
+            this._pendingProgress.set(varRequestId, progress);
+            const result = revive(await this._proxy.$resolveVariable(handle, varRequestId, messageText, token));
+            this._pendingProgress.delete(varRequestId);
+            return result;
         });
         this._variables.set(handle, registration);
     }
+    async $handleProgressChunk(requestId, progress) {
+        const revivedProgress = revive(progress);
+        this._pendingProgress.get(requestId)?.(revivedProgress);
+    }
     $unregisterVariable(handle) {
         this._variables.deleteAndDispose(handle);
     }

package/vscode/src/vs/workbench/api/browser/mainThreadComments.js

@@ -205,6 +205,9 @@ class MainThreadCommentController {
         this._features = _features;
         this._threads = ( new Map());
     }
+    async setActiveCommentAndThread(commentInfo) {
+        return this._proxy.$setActiveComment(this._handle, commentInfo ? { commentThreadHandle: commentInfo.thread.commentThreadHandle, uniqueIdInThread: commentInfo.comment?.uniqueIdInThread } : undefined);
+    }
     updateFeatures(features) {
         this._features = features;
     }
@@ -278,7 +281,7 @@ class MainThreadCommentController {
         });
     }
     updateInput(input) {
-        const thread = this.activeCommentThread;
+        const thread = this.activeEditingCommentThread;
         if (thread && thread.input) {
             const commentInput = thread.input;
             commentInput.value = input;
@@ -384,19 +387,19 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         this._viewDescriptorService = _viewDescriptorService;
         this._handlers = ( new Map());
         this._commentControllers = ( new Map());
-        this._activeCommentThreadDisposables = this._register(( new DisposableStore()));
+        this._activeEditingCommentThreadDisposables = this._register(( new DisposableStore()));
         this._openViewListener = null;
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostComments));
         this._commentService.unregisterCommentController();
-        this._register(this._commentService.onDidChangeActiveCommentThread(async (thread) => {
+        this._register(this._commentService.onDidChangeActiveEditingCommentThread(async (thread) => {
             const handle = thread.controllerHandle;
             const controller = this._commentControllers.get(handle);
             if (!controller) {
                 return;
             }
-            this._activeCommentThreadDisposables.clear();
-            this._activeCommentThread = thread;
-            controller.activeCommentThread = this._activeCommentThread;
+            this._activeEditingCommentThreadDisposables.clear();
+            this._activeEditingCommentThread = thread;
+            controller.activeEditingCommentThread = this._activeEditingCommentThread;
         }));
     }
     $registerCommentController(handle, id, label, extensionId) {

package/vscode/src/vs/workbench/api/browser/mainThreadDebugService.js

@@ -18,6 +18,7 @@ let MainThreadDebugService = class MainThreadDebugService {
         this._toDispose = ( new DisposableStore());
         this._debugAdaptersHandleCounter = 1;
         this._visualizerHandles = ( new Map());
+        this._visualizerTreeHandles = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDebugService));
         const sessionListeners = ( new DisposableMap());
         this._toDispose.add(sessionListeners);
@@ -83,6 +84,18 @@ let MainThreadDebugService = class MainThreadDebugService {
         }));
         this.sendBreakpointsAndListen();
     }
+    $registerDebugVisualizerTree(treeId, canEdit) {
+        this.visualizerService.registerTree(treeId, {
+            disposeItem: id => this._proxy.$disposeVisualizedTree(id),
+            getChildren: e => this._proxy.$getVisualizerTreeItemChildren(treeId, e),
+            getTreeItem: e => this._proxy.$getVisualizerTreeItem(treeId, e),
+            editItem: canEdit ? ((e, v) => this._proxy.$editVisualizerTreeItem(e, v)) : undefined
+        });
+    }
+    $unregisterDebugVisualizerTree(treeId) {
+        this._visualizerTreeHandles.get(treeId)?.dispose();
+        this._visualizerTreeHandles.delete(treeId);
+    }
     $registerDebugVisualizer(extensionId, id) {
         const handle = this.visualizerService.register({
             extensionId: ( new ExtensionIdentifier(extensionId)),
@@ -154,15 +167,16 @@ let MainThreadDebugService = class MainThreadDebugService {
                     column: l.character > 0 ? l.character + 1 : undefined,
                     condition: l.condition,
                     hitCondition: l.hitCondition,
-                    logMessage: l.logMessage
+                    logMessage: l.logMessage,
+                    mode: l.mode,
                 })));
                 this.debugService.addBreakpoints(URI.revive(dto.uri), rawbps);
             }
             else if (dto.type === 'function') {
-                this.debugService.addFunctionBreakpoint(dto.functionName, dto.id);
+                this.debugService.addFunctionBreakpoint(dto.functionName, dto.id, dto.mode);
             }
             else if (dto.type === 'data') {
-                this.debugService.addDataBreakpoint(dto.label, dto.dataId, dto.canPersist, dto.accessTypes, dto.accessType);
+                this.debugService.addDataBreakpoint(dto.label, dto.dataId, dto.canPersist, dto.accessTypes, dto.accessType, dto.mode);
             }
         }
         return Promise.resolve();

package/vscode/src/vs/workbench/api/browser/mainThreadEditor.js

@@ -42,7 +42,7 @@ class MainThreadTextEditorProperties {
         let lineNumbers;
         if (codeEditor) {
             const options = codeEditor.getOptions();
-            const lineNumbersOpts = options.get(67 );
+            const lineNumbersOpts = options.get(68 );
             cursorStyle = options.get(28 );
             lineNumbers = lineNumbersOpts.renderType;
         }
@@ -290,6 +290,9 @@ class MainThreadTextEditor {
                 case 2 :
                     lineNumbers = 'relative';
                     break;
+                case 3 :
+                    lineNumbers = 'interval';
+                    break;
                 default:
                     lineNumbers = 'off';
             }

package/vscode/src/vs/workbench/api/browser/mainThreadFileSystemEventService.js

@@ -297,7 +297,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 const config = this._configurationService.getValue();
                 if (config.files?.watcherExclude) {
                     for (const key in config.files.watcherExclude) {
-                        if (config.files.watcherExclude[key] === true) {
+                        if (key && config.files.watcherExclude[key] === true) {
                             opts.excludes.push(key);
                         }
                     }
@@ -307,7 +307,7 @@ let MainThreadFileSystemEventService = class MainThreadFileSystemEventService {
                 const config = this._configurationService.getValue();
                 if (config.files?.watcherExclude) {
                     for (const key in config.files.watcherExclude) {
-                        if (config.files.watcherExclude[key] === true) {
+                        if (key && config.files.watcherExclude[key] === true) {
                             if (!opts.includes) {
                                 opts.includes = [];
                             }

package/vscode/src/vs/workbench/api/browser/mainThreadLanguageFeatures.js

@@ -391,6 +391,13 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
                 : undefined
         }));
     }
+    $registerNewSymbolNamesProvider(handle, selector) {
+        this._registrations.set(handle, this._languageFeaturesService.newSymbolNamesProvider.register(selector, {
+            provideNewSymbolNames: (model, range, token) => {
+                return this._proxy.$provideNewSymbolNames(handle, model.uri, range, token);
+            }
+        }));
+    }
     $registerDocumentSemanticTokensProvider(handle, selector, legend, eventHandle) {
         let event = undefined;
         if (typeof eventHandle === 'number') {
@@ -500,6 +507,17 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         };
         this._registrations.set(handle, this._languageFeaturesService.inlineCompletionsProvider.register(selector, provider));
     }
+    $registerInlineEditProvider(handle, selector, extensionId) {
+        const provider = {
+            provideInlineEdit: async (model, context, token) => {
+                return this._proxy.$provideInlineEdit(handle, model.uri, context, token);
+            },
+            freeInlineEdit: (edit) => {
+                this._proxy.$freeInlineEdit(handle, edit.pid);
+            }
+        };
+        this._registrations.set(handle, this._languageFeaturesService.inlineEditProvider.register(selector, provider));
+    }
     $registerSignatureHelpProvider(handle, selector, metadata) {
         this._registrations.set(handle, this._languageFeaturesService.signatureHelpProvider.register(selector, {
             signatureHelpTriggerCharacters: metadata.triggerCharacters,

package/vscode/src/vs/workbench/api/browser/mainThreadMessageService.js

@@ -6,12 +6,14 @@ import { extHostNamedCustomer } from '../../services/extensions/common/extHostCu
 import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
 import { Event } from 'vscode/vscode/vs/base/common/event';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
 
 let MainThreadMessageService = class MainThreadMessageService {
-    constructor(extHostContext, _notificationService, _dialogService, extensionService) {
+    constructor(extHostContext, _notificationService, _commandService, _dialogService, extensionService) {
         this._notificationService = _notificationService;
+        this._commandService = _commandService;
         this._dialogService = _dialogService;
         this.extensionsListener = extensionService.onDidChangeExtensions(e => {
             for (const extension of e.removed) {
@@ -56,6 +58,19 @@ let MainThreadMessageService = class MainThreadMessageService {
                 ));
             }
             const secondaryActions = [];
+            if (options.source) {
+                secondaryActions.push(toAction({
+                    id: options.source.identifier.value,
+                    label: ( localizeWithPath(
+                        'vs/workbench/api/browser/mainThreadMessageService',
+                        'manageExtension',
+                        "Manage Extension"
+                    )),
+                    run: () => {
+                        return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
+                    }
+                }));
+            }
             const messageHandle = this._notificationService.notify({
                 severity,
                 message,
@@ -114,8 +129,9 @@ let MainThreadMessageService = class MainThreadMessageService {
 MainThreadMessageService = __decorate([
     extHostNamedCustomer(MainContext.MainThreadMessageService),
     ( __param(1, INotificationService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, IExtensionService))
+    ( __param(2, ICommandService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, IExtensionService))
 ], MainThreadMessageService);
 
 export { MainThreadMessageService };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookSaveParticipant.js

@@ -11,7 +11,7 @@ class ExtHostNotebookDocumentSaveParticipant {
     constructor(extHostContext) {
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookDocumentSaveParticipant));
     }
-    async participate(workingCopy, env, _progress, token) {
+    async participate(workingCopy, context, _progress, token) {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return undefined;
         }
@@ -22,7 +22,7 @@ class ExtHostNotebookDocumentSaveParticipant {
                 'timeout.onWillSave',
                 "Aborted onWillSaveNotebookDocument-event after 1750ms"
             ))))), 1750);
-            this._proxy.$participateInSave(workingCopy.resource, env.reason, token).then(_ => {
+            this._proxy.$participateInSave(workingCopy.resource, context.reason, token).then(_ => {
                 clearTimeout(_warningTimeout);
                 return undefined;
             }).then(resolve, reject);

package/vscode/src/vs/workbench/api/browser/mainThreadSaveParticipant.js

@@ -11,7 +11,7 @@ class ExtHostSaveParticipant {
     constructor(extHostContext) {
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentSaveParticipant));
     }
-    async participate(editorModel, env, _progress, token) {
+    async participate(editorModel, context, _progress, token) {
         if (!editorModel.textEditorModel || !shouldSynchronizeModel(editorModel.textEditorModel)) {
             return undefined;
         }
@@ -21,7 +21,7 @@ class ExtHostSaveParticipant {
                 'timeout.onWillSave',
                 "Aborted onWillSaveTextDocument-event after 1750ms"
             ))))), 1750);
-            this._proxy.$participateInSave(editorModel.resource, env.reason).then(values => {
+            this._proxy.$participateInSave(editorModel.resource, context.reason).then(values => {
                 if (!values.every(success => success)) {
                     return Promise.reject(( new Error('listener failed')));
                 }

package/vscode/src/vs/workbench/api/browser/mainThreadSpeech.js

@@ -1,6 +1,5 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
 import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
@@ -20,38 +19,44 @@ let MainThreadSpeech = class MainThreadSpeech {
         this.logService.trace('[Speech] extension registered provider', metadata.extension.value);
         const registration = this.speechService.registerSpeechProvider(identifier, {
             metadata,
-            createSpeechToTextSession: token => {
+            createSpeechToTextSession: (token, options) => {
+                if (token.isCancellationRequested) {
+                    return {
+                        onDidChange: Event.None
+                    };
+                }
                 const disposables = ( new DisposableStore());
-                const cts = ( new CancellationTokenSource(token));
                 const session = Math.random();
-                this.proxy.$createSpeechToTextSession(handle, session);
-                disposables.add(token.onCancellationRequested(() => this.proxy.$cancelSpeechToTextSession(session)));
+                this.proxy.$createSpeechToTextSession(handle, session, options?.language);
                 const onDidChange = disposables.add(( new Emitter()));
                 this.speechToTextSessions.set(session, { onDidChange });
+                disposables.add(token.onCancellationRequested(() => {
+                    this.proxy.$cancelSpeechToTextSession(session);
+                    this.speechToTextSessions.delete(session);
+                    disposables.dispose();
+                }));
                 return {
-                    onDidChange: onDidChange.event,
-                    dispose: () => {
-                        cts.dispose(true);
-                        this.speechToTextSessions.delete(session);
-                        disposables.dispose();
-                    }
+                    onDidChange: onDidChange.event
                 };
             },
             createKeywordRecognitionSession: token => {
+                if (token.isCancellationRequested) {
+                    return {
+                        onDidChange: Event.None
+                    };
+                }
                 const disposables = ( new DisposableStore());
-                const cts = ( new CancellationTokenSource(token));
                 const session = Math.random();
                 this.proxy.$createKeywordRecognitionSession(handle, session);
-                disposables.add(token.onCancellationRequested(() => this.proxy.$cancelKeywordRecognitionSession(session)));
                 const onDidChange = disposables.add(( new Emitter()));
                 this.keywordRecognitionSessions.set(session, { onDidChange });
+                disposables.add(token.onCancellationRequested(() => {
+                    this.proxy.$cancelKeywordRecognitionSession(session);
+                    this.keywordRecognitionSessions.delete(session);
+                    disposables.dispose();
+                }));
                 return {
-                    onDidChange: onDidChange.event,
-                    dispose: () => {
-                        cts.dispose(true);
-                        this.keywordRecognitionSessions.delete(session);
-                        disposables.dispose();
-                    }
+                    onDidChange: onDidChange.event
                 };
             }
         });