@codingame/monaco-vscode-extensions-service-override 4.1.0 → 4.1.1

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

@@ -0,0 +1,185 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
+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 { ILanguageModelsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { IAuthenticationAccessService } from 'vscode/vscode/vs/workbench/services/authentication/browser/authenticationAccessService';
+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 MainThreadLanguageModels = class MainThreadLanguageModels {
+    constructor(extHostContext, _chatProviderService, _extensionFeaturesManagementService, _logService, _authenticationService, _authenticationAccessService, _extensionService) {
+        this._chatProviderService = _chatProviderService;
+        this._extensionFeaturesManagementService = _extensionFeaturesManagementService;
+        this._logService = _logService;
+        this._authenticationService = _authenticationService;
+        this._authenticationAccessService = _authenticationAccessService;
+        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: coalesce(( _chatProviderService.getLanguageModelIds().map(id => _chatProviderService.lookupLanguageModel(id)))) });
+        this._store.add(_chatProviderService.onDidChangeLanguageModels(this._proxy.$updateLanguageModels, this._proxy));
+    }
+    dispose() {
+        this._providerRegistrations.dispose();
+        this._store.dispose();
+    }
+    $registerLanguageModelProvider(handle, identifier, metadata) {
+        const dipsosables = ( new DisposableStore());
+        dipsosables.add(this._chatProviderService.registerLanguageModelChat(identifier, {
+            metadata,
+            provideChatResponse: async (messages, from, options, progress, token) => {
+                const requestId = (Math.random() * 1e6) | 0;
+                this._pendingProgress.set(requestId, progress);
+                try {
+                    await this._proxy.$provideLanguageModelResponse(handle, requestId, from, messages, options, token);
+                }
+                finally {
+                    this._pendingProgress.delete(requestId);
+                }
+            }
+        }));
+        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/mainThreadLanguageModels',
+                'languageModels',
+                "Language Model ({0})",
+                `${identifier}`
+            )),
+            access: {
+                canToggle: false,
+            },
+        }));
+        this._providerRegistrations.set(handle, dipsosables);
+    }
+    async $handleProgressChunk(requestId, chunk) {
+        this._pendingProgress.get(requestId)?.report(chunk);
+    }
+    $unregisterProvider(handle) {
+        this._providerRegistrations.deleteAndDispose(handle);
+    }
+    async $prepareChatAccess(extension, providerId, justification) {
+        const activate = this._extensionService.activateByEvent(`onLanguageModelAccess:${providerId}`);
+        const metadata = this._chatProviderService.lookupLanguageModel(providerId);
+        if (metadata) {
+            return metadata;
+        }
+        await Promise.race([
+            activate,
+            Event.toPromise(Event.filter(this._chatProviderService.onDidChangeLanguageModels, e => Boolean(e.added?.some(value => value.identifier === providerId))))
+        ]);
+        return this._chatProviderService.lookupLanguageModel(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.makeLanguageModelChatRequest(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/mainThreadLanguageModels',
+            '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._authenticationAccessService.onDidChangeExtensionSessionAccess(async (e) => {
+            const allowedExtensions = this._authenticationAccessService.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;
+    }
+};
+MainThreadLanguageModels = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLanguageModels),
+    ( __param(1, ILanguageModelsService)),
+    ( __param(2, IExtensionFeaturesManagementService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IAuthenticationService)),
+    ( __param(5, IAuthenticationAccessService)),
+    ( __param(6, IExtensionService))
+], MainThreadLanguageModels);
+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 { MainThreadLanguageModels };

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

@@ -0,0 +1,78 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { ILanguageStatusService } from 'vscode/vscode/vs/workbench/services/languageStatus/common/languageStatusService';
+import { DisposableStore, DisposableMap } from 'vscode/vscode/vs/base/common/lifecycle';
+
+let MainThreadLanguages = class MainThreadLanguages {
+    constructor(_extHostContext, _languageService, _modelService, _resolverService, _languageStatusService) {
+        this._languageService = _languageService;
+        this._modelService = _modelService;
+        this._resolverService = _resolverService;
+        this._languageStatusService = _languageStatusService;
+        this._disposables = ( new DisposableStore());
+        this._status = ( new DisposableMap());
+        this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostLanguages));
+        this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
+        this._disposables.add(_languageService.onDidChange(_ => {
+            this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._status.dispose();
+    }
+    async $changeLanguage(resource, languageId) {
+        if (!this._languageService.isRegisteredLanguageId(languageId)) {
+            return Promise.reject(( new Error(`Unknown language id: ${languageId}`)));
+        }
+        const uri = URI.revive(resource);
+        const ref = await this._resolverService.createModelReference(uri);
+        try {
+            ref.object.textEditorModel.setLanguage(this._languageService.createById(languageId));
+        }
+        finally {
+            ref.dispose();
+        }
+    }
+    async $tokensAtPosition(resource, position) {
+        const uri = URI.revive(resource);
+        const model = this._modelService.getModel(uri);
+        if (!model) {
+            return undefined;
+        }
+        model.tokenization.tokenizeIfCheap(position.lineNumber);
+        const tokens = model.tokenization.getLineTokens(position.lineNumber);
+        const idx = tokens.findTokenIndexAtOffset(position.column - 1);
+        return {
+            type: tokens.getStandardTokenType(idx),
+            range: ( new Range(
+                position.lineNumber,
+                1 + tokens.getStartOffset(idx),
+                position.lineNumber,
+                1 + tokens.getEndOffset(idx)
+            ))
+        };
+    }
+    $setLanguageStatus(handle, status) {
+        this._status.get(handle)?.dispose();
+        this._status.set(handle, this._languageStatusService.addStatus(status));
+    }
+    $removeLanguageStatus(handle) {
+        this._status.get(handle)?.dispose();
+    }
+};
+MainThreadLanguages = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLanguages),
+    ( __param(1, ILanguageService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ITextModelService)),
+    ( __param(4, ILanguageStatusService))
+], MainThreadLanguages);
+
+export { MainThreadLanguages };

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

@@ -0,0 +1,35 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ILanguagePackService } from 'vscode/vscode/vs/platform/languagePacks/common/languagePacks';
+
+let MainThreadLocalization = class MainThreadLocalization extends Disposable {
+    constructor(extHostContext, fileService, languagePackService) {
+        super();
+        this.fileService = fileService;
+        this.languagePackService = languagePackService;
+    }
+    async $fetchBuiltInBundleUri(id, language) {
+        try {
+            const uri = await this.languagePackService.getBuiltInExtensionTranslationsUri(id, language);
+            return uri;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    async $fetchBundleContents(uriComponents) {
+        const contents = await this.fileService.readFile(URI.revive(uriComponents));
+        return ( contents.value.toString());
+    }
+};
+MainThreadLocalization = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLocalization),
+    ( __param(1, IFileService)),
+    ( __param(2, ILanguagePackService))
+], MainThreadLocalization);
+
+export { MainThreadLocalization };

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

@@ -0,0 +1,78 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ILoggerService, parseLogLevel, ILogService, LogLevelToString, isLogLevel, log } from 'vscode/vscode/vs/platform/log/common/log';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
+
+let MainThreadLoggerService = class MainThreadLoggerService {
+    constructor(extHostContext, loggerService) {
+        this.loggerService = loggerService;
+        this.disposables = ( new DisposableStore());
+        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLogLevelServiceShape));
+        this.disposables.add(loggerService.onDidChangeLogLevel(arg => {
+            if (isLogLevel(arg)) {
+                proxy.$setLogLevel(arg);
+            }
+            else {
+                proxy.$setLogLevel(arg[1], arg[0]);
+            }
+        }));
+    }
+    $log(file, messages) {
+        const logger = this.loggerService.getLogger(URI.revive(file));
+        if (!logger) {
+            throw new Error('Create the logger before logging');
+        }
+        for (const [level, message] of messages) {
+            log(logger, level, message);
+        }
+    }
+    async $createLogger(file, options) {
+        this.loggerService.createLogger(URI.revive(file), options);
+    }
+    async $registerLogger(logResource) {
+        this.loggerService.registerLogger({
+            ...logResource,
+            resource: URI.revive(logResource.resource)
+        });
+    }
+    async $deregisterLogger(resource) {
+        this.loggerService.deregisterLogger(URI.revive(resource));
+    }
+    async $setVisibility(resource, visible) {
+        this.loggerService.setVisibility(URI.revive(resource), visible);
+    }
+    $flush(file) {
+        const logger = this.loggerService.getLogger(URI.revive(file));
+        if (!logger) {
+            throw new Error('Create the logger before flushing');
+        }
+        logger.flush();
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+};
+MainThreadLoggerService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLogger),
+    ( __param(1, ILoggerService))
+], MainThreadLoggerService);
+CommandsRegistry.registerCommand('_extensionTests.setLogLevel', function (accessor, level) {
+    const loggerService = accessor.get(ILoggerService);
+    const environmentService = accessor.get(IEnvironmentService);
+    if (environmentService.isExtensionDevelopment && !!environmentService.extensionTestsLocationURI) {
+        const logLevel = parseLogLevel(level);
+        if (logLevel !== undefined) {
+            loggerService.setLogLevel(logLevel);
+        }
+    }
+});
+CommandsRegistry.registerCommand('_extensionTests.getLogLevel', function (accessor) {
+    const logService = accessor.get(ILogService);
+    return LogLevelToString(logService.getLevel());
+});
+
+export { MainThreadLoggerService };

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

@@ -0,0 +1,93 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ManagedSocket, connectManagedSocket } from '../../../platform/remote/common/managedSocket.js';
+import { IRemoteSocketFactoryService } from 'vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+
+let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable {
+    constructor(extHostContext, _remoteSocketFactoryService) {
+        super();
+        this._remoteSocketFactoryService = _remoteSocketFactoryService;
+        this._registrations = ( new Map());
+        this._remoteSockets = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostManagedSockets));
+    }
+    async $registerSocketFactory(socketFactoryId) {
+        const that = this;
+        const socketFactory = new (class {
+            supports(connectTo) {
+                return (connectTo.id === socketFactoryId);
+            }
+            connect(connectTo, path, query, debugLabel) {
+                return ( new Promise((resolve, reject) => {
+                    if (connectTo.id !== socketFactoryId) {
+                        return reject(( new Error('Invalid connectTo')));
+                    }
+                    const factoryId = connectTo.id;
+                    that._proxy.$openRemoteSocket(factoryId).then(socketId => {
+                        const half = {
+                            onClose: ( new Emitter()),
+                            onData: ( new Emitter()),
+                            onEnd: ( new Emitter()),
+                        };
+                        that._remoteSockets.set(socketId, half);
+                        MainThreadManagedSocket.connect(socketId, that._proxy, path, query, debugLabel, half)
+                            .then(socket => {
+                            socket.onDidDispose(() => that._remoteSockets.delete(socketId));
+                            resolve(socket);
+                        }, err => {
+                            that._remoteSockets.delete(socketId);
+                            reject(err);
+                        });
+                    }).catch(reject);
+                }));
+            }
+        });
+        this._registrations.set(socketFactoryId, this._remoteSocketFactoryService.register(1 , socketFactory));
+    }
+    async $unregisterSocketFactory(socketFactoryId) {
+        this._registrations.get(socketFactoryId)?.dispose();
+    }
+    $onDidManagedSocketHaveData(socketId, data) {
+        this._remoteSockets.get(socketId)?.onData.fire(data);
+    }
+    $onDidManagedSocketClose(socketId, error) {
+        this._remoteSockets.get(socketId)?.onClose.fire({
+            type: 0 ,
+            error: error ? ( new Error(error)) : undefined,
+            hadError: !!error
+        });
+        this._remoteSockets.delete(socketId);
+    }
+    $onDidManagedSocketEnd(socketId) {
+        this._remoteSockets.get(socketId)?.onEnd.fire();
+    }
+};
+MainThreadManagedSockets = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadManagedSockets),
+    ( __param(1, IRemoteSocketFactoryService))
+], MainThreadManagedSockets);
+class MainThreadManagedSocket extends ManagedSocket {
+    static connect(socketId, proxy, path, query, debugLabel, half) {
+        const socket = ( new MainThreadManagedSocket(socketId, proxy, debugLabel, half));
+        return connectManagedSocket(socket, path, query, debugLabel, half);
+    }
+    constructor(socketId, proxy, debugLabel, half) {
+        super(debugLabel, half);
+        this.socketId = socketId;
+        this.proxy = proxy;
+    }
+    write(buffer) {
+        this.proxy.$remoteSocketWrite(this.socketId, buffer);
+    }
+    closeRemote() {
+        this.proxy.$remoteSocketEnd(this.socketId);
+    }
+    drain() {
+        return this.proxy.$remoteSocketDrain(this.socketId);
+    }
+}
+
+export { MainThreadManagedSocket, MainThreadManagedSockets };

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

@@ -0,0 +1,137 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { toAction } from 'vscode/vscode/vs/base/common/actions';
+import { MainContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+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, _commandService, _dialogService, extensionService) {
+        this._notificationService = _notificationService;
+        this._commandService = _commandService;
+        this._dialogService = _dialogService;
+        this.extensionsListener = extensionService.onDidChangeExtensions(e => {
+            for (const extension of e.removed) {
+                this._notificationService.removeFilter(extension.identifier.value);
+            }
+        });
+    }
+    dispose() {
+        this.extensionsListener.dispose();
+    }
+    $showMessage(severity, message, options, commands) {
+        if (options.modal) {
+            return this._showModalMessage(severity, message, options.detail, commands, options.useCustom);
+        }
+        else {
+            return this._showMessage(severity, message, commands, options);
+        }
+    }
+    _showMessage(severity, message, commands, options) {
+        return ( new Promise(resolve => {
+            const primaryActions = ( commands.map(command => toAction({
+                id: `_extension_message_handle_${command.handle}`,
+                label: command.title,
+                enabled: true,
+                run: () => {
+                    resolve(command.handle);
+                    return Promise.resolve();
+                }
+            })));
+            let source;
+            if (options.source) {
+                source = {
+                    label: options.source.label,
+                    id: options.source.identifier.value
+                };
+            }
+            if (!source) {
+                source = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadMessageService',
+                    'defaultSource',
+                    "Extension"
+                ));
+            }
+            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,
+                actions: { primary: primaryActions, secondary: secondaryActions },
+                source
+            });
+            Event.once(messageHandle.onDidClose)(() => {
+                resolve(undefined);
+            });
+        }));
+    }
+    async _showModalMessage(severity, message, detail, commands, useCustom) {
+        const buttons = [];
+        let cancelButton = undefined;
+        for (const command of commands) {
+            const button = {
+                label: command.title,
+                run: () => command.handle
+            };
+            if (command.isCloseAffordance) {
+                cancelButton = button;
+            }
+            else {
+                buttons.push(button);
+            }
+        }
+        if (!cancelButton) {
+            if (buttons.length > 0) {
+                cancelButton = {
+                    label: ( localizeWithPath('vs/workbench/api/browser/mainThreadMessageService', 'cancel', "Cancel")),
+                    run: () => undefined
+                };
+            }
+            else {
+                cancelButton = {
+                    label: ( localizeWithPath(
+                        'vs/workbench/api/browser/mainThreadMessageService',
+                        { key: 'ok', comment: ['&& denotes a mnemonic'] },
+                        "&&OK"
+                    )),
+                    run: () => undefined
+                };
+            }
+        }
+        const { result } = await this._dialogService.prompt({
+            type: severity,
+            message,
+            detail,
+            buttons,
+            cancelButton,
+            custom: useCustom
+        });
+        return result;
+    }
+};
+MainThreadMessageService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadMessageService),
+    ( __param(1, INotificationService)),
+    ( __param(2, ICommandService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, IExtensionService))
+], MainThreadMessageService);
+
+export { MainThreadMessageService };