@codingame/monaco-vscode-extensions-service-override 2.2.1 → 3.0.0

package/vscode/src/vs/workbench/api/browser/extensionHost.contribution.js

@@ -0,0 +1,104 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { JSONValidationExtensionPoint } from 'vscode/vscode/vs/workbench/api/common/jsonValidationExtensionPoint';
+import { ColorExtensionPoint } from 'vscode/vscode/vs/workbench/services/themes/common/colorExtensionPoint';
+import { IconExtensionPoint } from 'vscode/vscode/vs/workbench/services/themes/common/iconExtensionPoint';
+import { TokenClassificationExtensionPoints } from 'vscode/vscode/vs/workbench/services/themes/common/tokenClassificationExtensionPoint';
+import { LanguageConfigurationFileHandler } from 'vscode/vscode/vs/workbench/contrib/codeEditor/browser/languageConfigurationExtensionPoint';
+import { StatusBarItemsExtensionPoint } from 'vscode/vscode/vs/workbench/api/browser/statusBarExtensionPoint';
+import './mainThreadLocalization.js';
+import './mainThreadBulkEdits.js';
+import './mainThreadChatProvider.js';
+import './mainThreadChatAgents2.js';
+import './mainThreadChatVariables.js';
+import './mainThreadCodeInsets.js';
+import './mainThreadCLICommands.js';
+import './mainThreadClipboard.js';
+import './mainThreadCommands.js';
+import './mainThreadConfiguration.js';
+import './mainThreadConsole.js';
+import './mainThreadDebugService.js';
+import './mainThreadDecorations.js';
+import './mainThreadDiagnostics.js';
+import './mainThreadDialogs.js';
+import './mainThreadDocumentContentProviders.js';
+import './mainThreadDocuments.js';
+import './mainThreadDocumentsAndEditors.js';
+import 'vscode/vscode/vs/editor/common/config/editorOptions';
+import 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetController2';
+import 'vscode/vscode/vs/editor/contrib/editorState/browser/keybindingCancellation';
+import 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetParser';
+import './mainThreadEditors.js';
+import './mainThreadEditorTabs.js';
+import './mainThreadErrors.js';
+import './mainThreadExtensionService.js';
+import './mainThreadFileSystem.js';
+import './mainThreadFileSystemEventService.js';
+import './mainThreadLanguageFeatures.js';
+import './mainThreadLanguages.js';
+import './mainThreadLogService.js';
+import './mainThreadMessageService.js';
+import './mainThreadManagedSockets.js';
+import './mainThreadOutputService.js';
+import './mainThreadProgress.js';
+import './mainThreadQuickDiff.js';
+import './mainThreadQuickOpen.js';
+import './mainThreadRemoteConnectionData.js';
+import './mainThreadSaveParticipant.js';
+import './mainThreadSpeech.js';
+import './mainThreadEditSessionIdentityParticipant.js';
+import './mainThreadSCM.js';
+import './mainThreadSearch.js';
+import './mainThreadStatusBar.js';
+import './mainThreadStorage.js';
+import './mainThreadTelemetry.js';
+import './mainThreadTerminalService.js';
+import './mainThreadTheming.js';
+import './mainThreadTreeViews.js';
+import './mainThreadDownloadService.js';
+import './mainThreadUrls.js';
+import './mainThreadUriOpeners.js';
+import './mainThreadWindow.js';
+import './mainThreadWebviewManager.js';
+import './mainThreadWorkspace.js';
+import './mainThreadComments.js';
+import './mainThreadNotebook.js';
+import './mainThreadNotebookKernels.js';
+import './mainThreadNotebookDocumentsAndEditors.js';
+import './mainThreadNotebookRenderers.js';
+import './mainThreadNotebookSaveParticipant.js';
+import './mainThreadInteractive.js';
+import './mainThreadInlineChat.js';
+import './mainThreadChat.js';
+import './mainThreadTask.js';
+import './mainThreadLabelService.js';
+import './mainThreadTunnelService.js';
+import './mainThreadAuthentication.js';
+import './mainThreadTimeline.js';
+import './mainThreadTesting.js';
+import './mainThreadSecretState.js';
+import './mainThreadShare.js';
+import './mainThreadProfilContentHandlers.js';
+import './mainThreadAiRelatedInformation.js';
+import './mainThreadAiEmbeddingVector.js';
+import './mainThreadIssueReporter.js';
+
+let ExtensionPoints = class ExtensionPoints {
+    static { this.ID = 'workbench.contrib.extensionPoints'; }
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.instantiationService.createInstance(JSONValidationExtensionPoint);
+        this.instantiationService.createInstance(ColorExtensionPoint);
+        this.instantiationService.createInstance(IconExtensionPoint);
+        this.instantiationService.createInstance(TokenClassificationExtensionPoints);
+        this.instantiationService.createInstance(LanguageConfigurationFileHandler);
+        this.instantiationService.createInstance(StatusBarItemsExtensionPoint);
+    }
+};
+ExtensionPoints = ( __decorate([
+    ( __param(0, IInstantiationService))
+], ExtensionPoints));
+registerWorkbenchContribution2(ExtensionPoints.ID, ExtensionPoints, 1 );
+
+export { ExtensionPoints };

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

@@ -0,0 +1,103 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import { isString } from 'vscode/vscode/vs/base/common/types';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { CommandsRegistry, ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IExtensionManagementService, IExtensionGalleryService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { ExtensionManagementCLI } from '../../../platform/extensionManagement/common/extensionManagementCLI.js';
+import { getExtensionId } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagementUtil';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
+import { AbstractMessageLogger } from 'vscode/vscode/vs/platform/log/common/log';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IExtensionManagementServerService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
+
+CommandsRegistry.registerCommand('_remoteCLI.openExternal', function (accessor, uri) {
+    const openerService = accessor.get(IOpenerService);
+    return openerService.open(isString(uri) ? uri : URI.revive(uri), { openExternal: true, allowTunneling: true });
+});
+CommandsRegistry.registerCommand('_remoteCLI.windowOpen', function (accessor, toOpen, options) {
+    const commandService = accessor.get(ICommandService);
+    if (!toOpen.length) {
+        return commandService.executeCommand('_files.newWindow', options);
+    }
+    return commandService.executeCommand('_files.windowOpen', toOpen, options);
+});
+CommandsRegistry.registerCommand('_remoteCLI.getSystemStatus', function (accessor) {
+    const commandService = accessor.get(ICommandService);
+    return commandService.executeCommand('_issues.getSystemStatus');
+});
+CommandsRegistry.registerCommand('_remoteCLI.manageExtensions', async function (accessor, args) {
+    const instantiationService = accessor.get(IInstantiationService);
+    const extensionManagementServerService = accessor.get(IExtensionManagementServerService);
+    const remoteExtensionManagementService = extensionManagementServerService.remoteExtensionManagementServer?.extensionManagementService;
+    if (!remoteExtensionManagementService) {
+        return;
+    }
+    const lines = [];
+    const logger = new (class extends AbstractMessageLogger {
+        log(level, message) {
+            lines.push(message);
+        }
+    })();
+    const cliService = instantiationService.createChild(( new ServiceCollection([IExtensionManagementService, remoteExtensionManagementService]))).createInstance(RemoteExtensionManagementCLI, logger);
+    if (args.list) {
+        await cliService.listExtensions(!!args.list.showVersions, args.list.category, undefined);
+    }
+    else {
+        const revive = (inputs) => ( inputs.map(input => isString(input) ? input : URI.revive(input)));
+        if (Array.isArray(args.install) && args.install.length) {
+            try {
+                await cliService.installExtensions(revive(args.install), [], { isMachineScoped: true }, !!args.force);
+            }
+            catch (e) {
+                lines.push(e.message);
+            }
+        }
+        if (Array.isArray(args.uninstall) && args.uninstall.length) {
+            try {
+                await cliService.uninstallExtensions(revive(args.uninstall), !!args.force, undefined);
+            }
+            catch (e) {
+                lines.push(e.message);
+            }
+        }
+    }
+    return lines.join('\n');
+});
+let RemoteExtensionManagementCLI = class RemoteExtensionManagementCLI extends ExtensionManagementCLI {
+    constructor(logger, extensionManagementService, extensionGalleryService, labelService, envService, _extensionManifestPropertiesService) {
+        super(logger, extensionManagementService, extensionGalleryService);
+        this._extensionManifestPropertiesService = _extensionManifestPropertiesService;
+        const remoteAuthority = envService.remoteAuthority;
+        this._location = remoteAuthority ? labelService.getHostLabel(Schemas.vscodeRemote, remoteAuthority) : undefined;
+    }
+    get location() {
+        return this._location;
+    }
+    validateExtensionKind(manifest) {
+        if (!this._extensionManifestPropertiesService.canExecuteOnWorkspace(manifest)
+            && !(isWeb && this._extensionManifestPropertiesService.canExecuteOnWeb(manifest))) {
+            this.logger.info(( localizeWithPath(
+                'vs/workbench/api/browser/mainThreadCLICommands',
+                'cannot be installed',
+                "Cannot install the '{0}' extension because it is declared to not run in this setup.",
+                getExtensionId(manifest.publisher, manifest.name)
+            )));
+            return false;
+        }
+        return true;
+    }
+};
+RemoteExtensionManagementCLI = ( __decorate([
+    ( __param(1, IExtensionManagementService)),
+    ( __param(2, IExtensionGalleryService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IWorkbenchEnvironmentService)),
+    ( __param(5, IExtensionManifestPropertiesService))
+], RemoteExtensionManagementCLI));

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';
             }