@theia/plugin-ext 1.53.0-next.6 → 1.53.0-next.64

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "@theia/plugin-ext",
-  "version": "1.53.0-next.6+5255c512c",
+  "version": "1.53.0-next.64+23b351d26",
   "description": "Theia - Plugin Extension",
   "main": "lib/common/index.js",
   "typings": "lib/common/index.d.ts",
   "dependencies": {
-    "@theia/bulk-edit": "1.53.0-next.6+5255c512c",
-    "@theia/callhierarchy": "1.53.0-next.6+5255c512c",
-    "@theia/console": "1.53.0-next.6+5255c512c",
-    "@theia/core": "1.53.0-next.6+5255c512c",
-    "@theia/debug": "1.53.0-next.6+5255c512c",
-    "@theia/editor": "1.53.0-next.6+5255c512c",
-    "@theia/editor-preview": "1.53.0-next.6+5255c512c",
-    "@theia/file-search": "1.53.0-next.6+5255c512c",
-    "@theia/filesystem": "1.53.0-next.6+5255c512c",
-    "@theia/markers": "1.53.0-next.6+5255c512c",
-    "@theia/messages": "1.53.0-next.6+5255c512c",
-    "@theia/monaco": "1.53.0-next.6+5255c512c",
+    "@theia/bulk-edit": "1.53.0-next.64+23b351d26",
+    "@theia/callhierarchy": "1.53.0-next.64+23b351d26",
+    "@theia/console": "1.53.0-next.64+23b351d26",
+    "@theia/core": "1.53.0-next.64+23b351d26",
+    "@theia/debug": "1.53.0-next.64+23b351d26",
+    "@theia/editor": "1.53.0-next.64+23b351d26",
+    "@theia/editor-preview": "1.53.0-next.64+23b351d26",
+    "@theia/file-search": "1.53.0-next.64+23b351d26",
+    "@theia/filesystem": "1.53.0-next.64+23b351d26",
+    "@theia/markers": "1.53.0-next.64+23b351d26",
+    "@theia/messages": "1.53.0-next.64+23b351d26",
+    "@theia/monaco": "1.53.0-next.64+23b351d26",
     "@theia/monaco-editor-core": "1.83.101",
-    "@theia/navigator": "1.53.0-next.6+5255c512c",
-    "@theia/notebook": "1.53.0-next.6+5255c512c",
-    "@theia/output": "1.53.0-next.6+5255c512c",
-    "@theia/plugin": "1.53.0-next.6+5255c512c",
-    "@theia/preferences": "1.53.0-next.6+5255c512c",
-    "@theia/scm": "1.53.0-next.6+5255c512c",
-    "@theia/search-in-workspace": "1.53.0-next.6+5255c512c",
-    "@theia/task": "1.53.0-next.6+5255c512c",
-    "@theia/terminal": "1.53.0-next.6+5255c512c",
-    "@theia/test": "1.53.0-next.6+5255c512c",
-    "@theia/timeline": "1.53.0-next.6+5255c512c",
-    "@theia/typehierarchy": "1.53.0-next.6+5255c512c",
-    "@theia/variable-resolver": "1.53.0-next.6+5255c512c",
-    "@theia/workspace": "1.53.0-next.6+5255c512c",
+    "@theia/navigator": "1.53.0-next.64+23b351d26",
+    "@theia/notebook": "1.53.0-next.64+23b351d26",
+    "@theia/output": "1.53.0-next.64+23b351d26",
+    "@theia/plugin": "1.53.0-next.64+23b351d26",
+    "@theia/preferences": "1.53.0-next.64+23b351d26",
+    "@theia/scm": "1.53.0-next.64+23b351d26",
+    "@theia/search-in-workspace": "1.53.0-next.64+23b351d26",
+    "@theia/task": "1.53.0-next.64+23b351d26",
+    "@theia/terminal": "1.53.0-next.64+23b351d26",
+    "@theia/test": "1.53.0-next.64+23b351d26",
+    "@theia/timeline": "1.53.0-next.64+23b351d26",
+    "@theia/typehierarchy": "1.53.0-next.64+23b351d26",
+    "@theia/variable-resolver": "1.53.0-next.64+23b351d26",
+    "@theia/workspace": "1.53.0-next.64+23b351d26",
     "@types/mime": "^2.0.1",
     "@vscode/debugprotocol": "^1.51.0",
     "@vscode/proxy-agent": "^0.13.2",
@@ -88,7 +88,7 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.52.0",
+    "@theia/ext-scripts": "1.53.0",
     "@types/decompress": "^4.2.2",
     "@types/escape-html": "^0.0.20",
     "@types/lodash.clonedeep": "^4.5.3",
@@ -97,5 +97,5 @@
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "5255c512c6c9da44c11cb4d5fca7379de60b71cc"
+  "gitHead": "23b351d26346a2b5d6aca3ee81fba59c056132f7"
 }

package/src/common/plugin-api-rpc.ts

@@ -181,6 +181,7 @@ export interface EnvInit {
     appName: string;
     appHost: string;
     appRoot: string;
+    appUriScheme: string;
 }
 
 export interface PluginAPI {
@@ -1882,7 +1883,7 @@ export interface CustomEditorsExt {
         newWebviewHandle: string,
         viewType: string,
         title: string,
-        widgetOpenerOptions: object | undefined,
+        position: number,
         options: theia.WebviewPanelOptions,
         cancellation: CancellationToken): Promise<void>;
     $createCustomDocument(resource: UriComponents, viewType: string, openContext: theia.CustomDocumentOpenContext, cancellation: CancellationToken): Promise<{ editable: boolean }>;
@@ -1905,7 +1906,6 @@ export interface CustomEditorsMain {
     $registerTextEditorProvider(viewType: string, options: theia.WebviewPanelOptions, capabilities: CustomTextEditorCapabilities): void;
     $registerCustomEditorProvider(viewType: string, options: theia.WebviewPanelOptions, supportsMultipleEditorsPerDocument: boolean): void;
     $unregisterEditorProvider(viewType: string): void;
-    $createCustomEditorPanel(handle: string, title: string, widgetOpenerOptions: object | undefined, options: theia.WebviewPanelOptions & theia.WebviewOptions): Promise<void>;
     $onDidEdit(resource: UriComponents, viewType: string, editId: number, label: string | undefined): void;
     $onContentChange(resource: UriComponents, viewType: string): void;
 }
@@ -2242,6 +2242,17 @@ export interface TestingExt {
     $onResolveChildren(controllerId: string, path: string[]): void;
 }
 
+// based from https://github.com/microsoft/vscode/blob/1.85.1/src/vs/workbench/api/common/extHostUrls.ts
+export interface UriExt {
+    registerUriHandler(handler: theia.UriHandler, plugin: PluginInfo): theia.Disposable;
+    $handleExternalUri(uri: UriComponents): Promise<void>;
+}
+
+export interface UriMain {
+    $registerUriHandler(extensionId: string, extensionName: string): void;
+    $unregisterUriHandler(extensionId: string): void;
+}
+
 export interface TestControllerUpdate {
     label: string;
     canRefresh: boolean;
@@ -2319,7 +2330,8 @@ export const PLUGIN_RPC_CONTEXT = {
     TABS_MAIN: <ProxyIdentifier<TabsMain>>createProxyIdentifier<TabsMain>('TabsMain'),
     TELEMETRY_MAIN: <ProxyIdentifier<TelemetryMain>>createProxyIdentifier<TelemetryMain>('TelemetryMain'),
     LOCALIZATION_MAIN: <ProxyIdentifier<LocalizationMain>>createProxyIdentifier<LocalizationMain>('LocalizationMain'),
-    TESTING_MAIN: createProxyIdentifier<TestingMain>('TestingMain')
+    TESTING_MAIN: createProxyIdentifier<TestingMain>('TestingMain'),
+    URI_MAIN: createProxyIdentifier<UriMain>('UriMain')
 };
 
 export const MAIN_RPC_CONTEXT = {
@@ -2361,7 +2373,8 @@ export const MAIN_RPC_CONTEXT = {
     COMMENTS_EXT: createProxyIdentifier<CommentsExt>('CommentsExt'),
     TABS_EXT: createProxyIdentifier<TabsExt>('TabsExt'),
     TELEMETRY_EXT: createProxyIdentifier<TelemetryExt>('TelemetryExt)'),
-    TESTING_EXT: createProxyIdentifier<TestingExt>('TestingExt')
+    TESTING_EXT: createProxyIdentifier<TestingExt>('TestingExt'),
+    URI_EXT: createProxyIdentifier<UriExt>('UriExt')
 };
 
 export interface TasksExt {
@@ -2385,13 +2398,14 @@ export interface TasksMain {
 }
 
 export interface AuthenticationExt {
-    $getSessions(id: string, scopes?: string[]): Promise<ReadonlyArray<theia.AuthenticationSession>>;
-    $createSession(id: string, scopes: string[]): Promise<theia.AuthenticationSession>;
+    $getSessions(providerId: string, scopes: string[] | undefined, options: theia.AuthenticationProviderSessionOptions): Promise<ReadonlyArray<theia.AuthenticationSession>>;
+    $createSession(id: string, scopes: string[], options: theia.AuthenticationProviderSessionOptions): Promise<theia.AuthenticationSession>;
     $removeSession(id: string, sessionId: string): Promise<void>;
     $onDidChangeAuthenticationSessions(provider: theia.AuthenticationProviderInformation): Promise<void>;
 }
 
 export interface AuthenticationMain {
+    $getAccounts(providerId: string): Thenable<readonly theia.AuthenticationSessionAccountInformation[]>;
     $registerAuthenticationProvider(id: string, label: string, supportsMultipleAccounts: boolean): void;
     $unregisterAuthenticationProvider(id: string): void;
     $onDidChangeSessions(providerId: string, event: AuthenticationProviderAuthenticationSessionsChangeEvent): void;
@@ -2659,6 +2673,7 @@ export interface NotebookDocumentsExt {
 
 export interface NotebookDocumentsAndEditorsExt {
     $acceptDocumentsAndEditorsDelta(delta: NotebookDocumentsAndEditorsDelta): Promise<void>;
+    $acceptActiveCellEditorChange(newActiveEditor: string | null): void;
 }
 
 export interface NotebookDocumentsAndEditorsMain extends Disposable {

package/src/common/rpc-protocol.ts

@@ -22,17 +22,14 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { Channel, Disposable, DisposableCollection, isObject, ReadBuffer, URI, WriteBuffer } from '@theia/core';
+import { Channel, Disposable, DisposableCollection, isObject, ReadBuffer, RpcProtocol, URI, WriteBuffer } from '@theia/core';
 import { Emitter, Event } from '@theia/core/lib/common/event';
-import { ChannelMultiplexer, MessageProvider } from '@theia/core/lib/common/message-rpc/channel';
-import { MsgPackMessageDecoder, MsgPackMessageEncoder } from '@theia/core/lib/common/message-rpc/rpc-message-encoder';
+import { MessageProvider } from '@theia/core/lib/common/message-rpc/channel';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '@theia/core/lib/common/message-rpc/uint8-array-message-buffer';
-import { ClientProxyHandler, ProxySynchronizer, RpcInvocationHandler } from './proxy-handler';
 import { MsgPackExtensionManager } from '@theia/core/lib/common/message-rpc/msg-pack-extension-manager';
 import { URI as VSCodeURI } from '@theia/core/shared/vscode-uri';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 import { Range, Position } from '../plugin/types-impl';
-import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export interface MessageConnection {
     send(msg: string): void;
@@ -79,21 +76,36 @@ export namespace ConnectionClosedError {
 }
 
 export class RPCProtocolImpl implements RPCProtocol {
-    private readonly locals = new Map<string, RpcInvocationHandler>();
+    private readonly locals = new Map<string, any>();
     private readonly proxies = new Map<string, any>();
-    private readonly multiplexer: ChannelMultiplexer;
-    private readonly encoder = new MsgPackMessageEncoder();
-    private readonly decoder = new MsgPackMessageDecoder();
-    private readonly initCallback: ProxySynchronizer;
+    private readonly rpc: RpcProtocol;
 
     private readonly toDispose = new DisposableCollection(
         Disposable.create(() => { /* mark as no disposed */ })
     );
 
     constructor(channel: Channel) {
-        this.toDispose.push(this.multiplexer = new ChannelMultiplexer(new BatchingChannel(channel)));
+        this.rpc = new RpcProtocol(new BatchingChannel(channel), (method, args) => this.handleRequest(method, args));
+        this.rpc.onNotification((evt: { method: string; args: any[]; }) => this.handleNotification(evt.method, evt.args));
         this.toDispose.push(Disposable.create(() => this.proxies.clear()));
-        this.initCallback = new ProxySynchronizerImpl();
+    }
+
+    handleNotification(method: any, args: any[]): void {
+        const serviceId = args[0] as string;
+        const handler: any = this.locals.get(serviceId);
+        if (!handler) {
+            throw new Error(`no local service handler with id ${serviceId}`);
+        }
+        handler[method](...(args.slice(1)));
+    }
+
+    handleRequest(method: string, args: any[]): Promise<any> {
+        const serviceId = args[0] as string;
+        const handler: any = this.locals.get(serviceId);
+        if (!handler) {
+            throw new Error(`no local service handler with id ${serviceId}`);
+        }
+        return handler[method](...(args.slice(1)));
     }
 
     dispose(): void {
@@ -117,76 +129,60 @@ export class RPCProtocolImpl implements RPCProtocol {
     }
 
     protected createProxy<T>(proxyId: string): T {
-        const handler = new ClientProxyHandler({
-            id: proxyId, encoder: this.encoder, decoder: this.decoder, channelProvider: () => this.multiplexer.open(proxyId), proxySynchronizer: this.initCallback
-        });
+        const handler = {
+            get: (target: any, name: string, receiver: any): any => {
+                if (target[name] || name.charCodeAt(0) !== 36 /* CharCode.DollarSign */) {
+                    // not a remote property
+                    return target[name];
+                }
+                const isNotify = this.isNotification(name);
+                return async (...args: any[]) => {
+                    const method = name.toString();
+                    if (isNotify) {
+                        this.rpc.sendNotification(method, [proxyId, ...args]);
+                    } else {
+                        return await this.rpc.sendRequest(method, [proxyId, ...args]) as Promise<any>;
+                    }
+                };
+            }
+
+        };
         return new Proxy(Object.create(null), handler);
     }
 
+    /**
+     * Return whether the given property represents a notification. If true,
+     * the promise returned from the invocation will resolve immediately to `undefined`
+     *
+     * A property leads to a notification rather than a method call if its name
+     * begins with `notify` or `on`.
+     *
+     * @param p - The property being called on the proxy.
+     * @return Whether `p` represents a notification.
+     */
+    protected isNotification(p: PropertyKey): boolean {
+        let propertyString = p.toString();
+        if (propertyString.charCodeAt(0) === 36/* CharCode.DollarSign */) {
+            propertyString = propertyString.substring(1);
+        }
+        return propertyString.startsWith('notify') || propertyString.startsWith('on');
+    }
+
     set<T, R extends T>(identifier: ProxyIdentifier<T>, instance: R): R {
         if (this.isDisposed) {
             throw ConnectionClosedError.create();
         }
-        const invocationHandler = this.locals.get(identifier.id);
-        if (!invocationHandler) {
-            const handler = new RpcInvocationHandler({ id: identifier.id, target: instance, encoder: this.encoder, decoder: this.decoder });
-
-            const channel = this.multiplexer.getOpenChannel(identifier.id);
-            if (channel) {
-                handler.listen(channel);
-            } else {
-                const channelOpenListener = this.multiplexer.onDidOpenChannel(event => {
-                    if (event.id === identifier.id) {
-                        handler.listen(event.channel);
-                        channelOpenListener.dispose();
-                    }
-                });
-            }
-
-            this.locals.set(identifier.id, handler);
+        if (!this.locals.has(identifier.id)) {
+            this.locals.set(identifier.id, instance);
             if (Disposable.is(instance)) {
                 this.toDispose.push(instance);
             }
             this.toDispose.push(Disposable.create(() => this.locals.delete(identifier.id)));
-
         }
         return instance;
     }
 }
 
-export class ProxySynchronizerImpl implements ProxySynchronizer {
-
-    private readonly runningInitializations = new Set<string>();
-
-    private _pendingProxyInitializations: Deferred<void>;
-
-    constructor() {
-        this._pendingProxyInitializations = new Deferred();
-        /* after creation no init is active */
-        this._pendingProxyInitializations.resolve();
-    }
-
-    startProxyInitialization(id: string, init: Promise<void>): void {
-        if (this.runningInitializations.size === 0) {
-            this._pendingProxyInitializations = new Deferred();
-        }
-        init.then(() => this.finishedProxyInitialization(id));
-        this.runningInitializations.add(id);
-    }
-
-    protected finishedProxyInitialization(id: string): void {
-        this.runningInitializations.delete(id);
-        if (this.runningInitializations.size === 0) {
-            this._pendingProxyInitializations.resolve();
-        }
-    }
-
-    pendingProxyInitializations(): Promise<void> {
-        return this._pendingProxyInitializations.promise;
-    }
-
-}
-
 /**
  * Wraps and underlying channel to send/receive multiple messages in one go:
  *  - multiple messages to be sent from one stack get sent in bulk at `process.nextTick`.

package/src/hosted/browser/hosted-plugin.ts

@@ -40,10 +40,10 @@ import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { PluginContributionHandler } from '../../main/browser/plugin-contribution-handler';
 import { getQueryParameters } from '../../main/browser/env-main';
 import { getPreferences } from '../../main/browser/preference-registry-main';
-import { Deferred } from '@theia/core/lib/common/promise-util';
+import { Deferred, waitForEvent } from '@theia/core/lib/common/promise-util';
 import { DebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
 import { DebugConfigurationManager } from '@theia/debug/lib/browser/debug-configuration-manager';
-import { WaitUntilEvent } from '@theia/core/lib/common/event';
+import { Event, WaitUntilEvent } from '@theia/core/lib/common/event';
 import { FileSearchService } from '@theia/file-search/lib/common/file-search-service';
 import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
 import { PluginViewRegistry } from '../../main/browser/view/plugin-view-registry';
@@ -209,7 +209,8 @@ export class HostedPluginSupport extends AbstractHostedPluginSupport<PluginManag
         this.notebookRendererMessagingService.onWillActivateRenderer(rendererId => this.activateByNotebookRenderer(rendererId));
 
         this.widgets.onDidCreateWidget(({ factoryId, widget }) => {
-            if ((factoryId === WebviewWidget.FACTORY_ID || factoryId === CustomEditorWidget.FACTORY_ID) && widget instanceof WebviewWidget) {
+            // note: state restoration of custom editors is handled in `PluginCustomEditorRegistry.init`
+            if (factoryId === WebviewWidget.FACTORY_ID && widget instanceof WebviewWidget) {
                 const storeState = widget.storeState.bind(widget);
                 const restoreState = widget.restoreState.bind(widget);
 
@@ -327,7 +328,8 @@ export class HostedPluginSupport extends AbstractHostedPluginSupport<PluginManag
                     uiKind: isElectron ? UIKind.Desktop : UIKind.Web,
                     appName: FrontendApplicationConfigProvider.get().applicationName,
                     appHost: isElectron ? 'desktop' : 'web', // TODO: 'web' could be the embedder's name, e.g. 'github.dev'
-                    appRoot
+                    appRoot,
+                    appUriScheme: FrontendApplicationConfigProvider.get().electron.uriScheme
                 },
                 extApi,
                 webview: {
@@ -415,6 +417,10 @@ export class HostedPluginSupport extends AbstractHostedPluginSupport<PluginManag
         await this.activateByEvent(`onLanguage:${languageId}`);
     }
 
+    async activateByUri(scheme: string, authority: string): Promise<void> {
+        await this.activateByEvent(`onUri:${scheme}://${authority}`);
+    }
+
     async activateByCommand(commandId: string): Promise<void> {
         await this.activateByEvent(`onCommand:${commandId}`);
     }
@@ -448,7 +454,12 @@ export class HostedPluginSupport extends AbstractHostedPluginSupport<PluginManag
     }
 
     protected ensureFileSystemActivation(event: FileSystemProviderActivationEvent): void {
-        event.waitUntil(this.activateByFileSystem(event));
+        event.waitUntil(this.activateByFileSystem(event).then(() => {
+            if (!this.fileService.hasProvider(event.scheme)) {
+                return waitForEvent(Event.filter(this.fileService.onDidChangeFileSystemProviderRegistrations,
+                    ({ added, scheme }) => added && scheme === event.scheme), 3000);
+            }
+        }));
     }
 
     protected ensureCommandHandlerRegistration(event: WillExecuteCommandEvent): void {

package/src/hosted/node/scanners/scanner-theia.ts

@@ -192,11 +192,22 @@ export class TheiaPluginScanner extends AbstractPluginScanner {
         try {
             if (rawPlugin.contributes.configuration) {
                 const configurations = Array.isArray(rawPlugin.contributes.configuration) ? rawPlugin.contributes.configuration : [rawPlugin.contributes.configuration];
+                const hasMultipleConfigs = configurations.length > 1;
                 contributions.configuration = [];
                 for (const c of configurations) {
                     const config = this.readConfiguration(c, rawPlugin.packagePath);
                     if (config) {
-                        Object.values(config.properties).forEach(property => property.title = config.title);
+                        Object.values(config.properties).forEach(property => {
+                            if (hasMultipleConfigs) {
+                                // If there are multiple configuration contributions, we need to distinguish them by their title in the settings UI.
+                                // They are placed directly under the plugin's name in the settings UI.
+                                property.owner = rawPlugin.displayName;
+                                property.group = config.title;
+                            } else {
+                                // If there's only one configuration contribution, we display the title in the settings UI.
+                                property.owner = config.title;
+                            }
+                        });
                         contributions.configuration.push(config);
                     }
                 }

package/src/main/browser/authentication-main.ts

@@ -27,7 +27,10 @@ import { MessageService } from '@theia/core/lib/common/message-service';
 import { ConfirmDialog, Dialog, StorageService } from '@theia/core/lib/browser';
 import {
     AuthenticationProvider,
+    AuthenticationProviderSessionOptions,
     AuthenticationService,
+    AuthenticationSession,
+    AuthenticationSessionAccountInformation,
     readAllowedExtensions
 } from '@theia/core/lib/browser/authentication-service';
 import { QuickPickService } from '@theia/core/lib/common/quick-pick-service';
@@ -77,9 +80,13 @@ export class AuthenticationMainImpl implements AuthenticationMain {
         return this.authenticationService.requestNewSession(providerId, scopes, extensionId, extensionName);
     }
 
+    $getAccounts(providerId: string): Thenable<readonly theia.AuthenticationSessionAccountInformation[]> {
+        return this.authenticationService.getSessions(providerId).then(sessions => sessions.map(session => session.account));
+    }
+
     async $getSession(providerId: string, scopes: string[], extensionId: string, extensionName: string,
         options: theia.AuthenticationGetSessionOptions): Promise<theia.AuthenticationSession | undefined> {
-        const sessions = await this.authenticationService.getSessions(providerId, scopes);
+        const sessions = await this.authenticationService.getSessions(providerId, scopes, options?.account);
 
         // Error cases
         if (options.forceNewSession && !sessions.length) {
@@ -140,26 +147,32 @@ export class AuthenticationMainImpl implements AuthenticationMain {
     }
 
     protected async selectSession(providerId: string, providerName: string, extensionId: string, extensionName: string,
-        potentialSessions: Readonly<theia.AuthenticationSession[]>, scopes: string[], clearSessionPreference: boolean): Promise<theia.AuthenticationSession> {
+        potentialSessions: Readonly<AuthenticationSession[]>, scopes: string[], clearSessionPreference: boolean): Promise<theia.AuthenticationSession> {
+
         if (!potentialSessions.length) {
             throw new Error('No potential sessions found');
         }
 
         return new Promise(async (resolve, reject) => {
-            const items: QuickPickValue<{ session?: theia.AuthenticationSession }>[] = potentialSessions.map(session => ({
+            const items: QuickPickValue<{ session?: AuthenticationSession, account?: AuthenticationSessionAccountInformation }>[] = potentialSessions.map(session => ({
                 label: session.account.label,
                 value: { session }
             }));
             items.push({
                 label: nls.localizeByDefault('Sign in to another account'),
-                value: { session: undefined }
+                value: {}
             });
+
+            // VS Code has code here that pushes accounts that have no active sessions. However, since we do not store
+            // any accounts that don't have sessions, we dont' do this.
             const selected = await this.quickPickService.show(items,
                 {
                     title: nls.localizeByDefault("The extension '{0}' wants to access a {1} account", extensionName, providerName),
                     ignoreFocusOut: true
                 });
             if (selected) {
+
+                // if we ever have accounts without sessions, pass the account to the login call
                 const session = selected.value?.session ?? await this.authenticationService.login(providerId, scopes);
                 const accountName = session.account.label;
 
@@ -318,13 +331,13 @@ export class AuthenticationProviderImpl implements AuthenticationProvider {
         }
     }
 
-    async getSessions(scopes?: string[]): Promise<ReadonlyArray<theia.AuthenticationSession>> {
-        return this.proxy.$getSessions(this.id, scopes);
+    async getSessions(scopes?: string[], account?: AuthenticationSessionAccountInformation): Promise<ReadonlyArray<theia.AuthenticationSession>> {
+        return this.proxy.$getSessions(this.id, scopes, { account: account });
     }
 
     async updateSessionItems(event: theia.AuthenticationProviderAuthenticationSessionsChangeEvent): Promise<void> {
         const { added, removed } = event;
-        const session = await this.proxy.$getSessions(this.id);
+        const session = await this.proxy.$getSessions(this.id, undefined, {});
         const addedSessions = added ? session.filter(s => added.some(addedSession => addedSession.id === s.id)) : [];
 
         removed?.forEach(removedSession => {
@@ -347,16 +360,16 @@ export class AuthenticationProviderImpl implements AuthenticationProvider {
         addedSessions.forEach(s => this.registerSession(s));
     }
 
-    async login(scopes: string[]): Promise<theia.AuthenticationSession> {
-        return this.createSession(scopes);
+    async login(scopes: string[], options: AuthenticationProviderSessionOptions): Promise<theia.AuthenticationSession> {
+        return this.createSession(scopes, options);
     }
 
     async logout(sessionId: string): Promise<void> {
         return this.removeSession(sessionId);
     }
 
-    createSession(scopes: string[]): Thenable<theia.AuthenticationSession> {
-        return this.proxy.$createSession(this.id, scopes);
+    createSession(scopes: string[], options: AuthenticationProviderSessionOptions): Thenable<theia.AuthenticationSession> {
+        return this.proxy.$createSession(this.id, scopes, options);
     }
 
     removeSession(sessionId: string): Thenable<void> {