@codingame/monaco-vscode-extensions-service-override 28.4.1 → 29.0.0

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

@@ -12,6 +12,7 @@ import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/reso
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { hasValidDiff } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
 import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
@@ -21,9 +22,12 @@ import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
 import { ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { ChatSessionOptionsMap, ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { IChatArtifactsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service';
 import { IChatTodoListService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
@@ -34,7 +38,7 @@ import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 
 class ObservableChatSession extends Disposable {
     get options() {
-        return this._options;
+        return this._options ? ( new Map(this._options)) : undefined;
     }
     get progressObs() {
         return this._progressObservable;
@@ -60,19 +64,19 @@ class ObservableChatSession extends Disposable {
         this._logService = logService;
         this._dialogService = dialogService;
     }
-    initialize(token) {
+    initialize(token, context) {
         if (!this._initializationPromise) {
-            this._initializationPromise = this._doInitializeContent(token);
+            this._initializationPromise = this._doInitializeContent(token, context);
         }
         return this._initializationPromise;
     }
-    async _doInitializeContent(token) {
+    async _doInitializeContent(token, context) {
         try {
             const sessionContent = await raceCancellationError(
-                this._proxy.$provideChatSessionContent(this._providerHandle, this.sessionResource, token),
+                this._proxy.$provideChatSessionContent(this._providerHandle, this.sessionResource, context, token),
                 token
             );
-            this._options = sessionContent.options;
+            this._options = sessionContent.options ? ChatSessionOptionsMap.fromRecord(sessionContent.options) : undefined;
             this.title = sessionContent.title;
             this.history.length = 0;
             this.history.push(...( sessionContent.history.map(turn => {
@@ -116,7 +120,7 @@ class ObservableChatSession extends Disposable {
                         return confirmInterrupt();
                     }
                     return this._dialogService.confirm({
-                        message: ( localize(2546, "Are you sure you want to interrupt the active session?"))
+                        message: ( localize(2554, "Are you sure you want to interrupt the active session?"))
                     }).then(confirmed => {
                         if (confirmed.confirmed) {
                             return confirmInterrupt();
@@ -178,6 +182,17 @@ class ObservableChatSession extends Disposable {
                     }
                 };
             }
+            if (sessionContent.hasForkHandler && !this.forkSession) {
+                this.forkSession = async (request, token) => {
+                    const result = await this._proxy.$forkChatSession(
+                        this._providerHandle,
+                        this.sessionResource,
+                        request ? this.toRequestDto(request) : undefined,
+                        token
+                    );
+                    return revive(result);
+                };
+            }
             this._isInitialized = true;
             const hasActiveResponse = sessionContent.hasActiveResponseCallback;
             const hasRequestHandler = sessionContent.hasRequestHandler;
@@ -227,6 +242,17 @@ class ObservableChatSession extends Disposable {
             this._isCompleteObservable.set(true, undefined);
         }
     }
+    toRequestDto(request) {
+        return {
+            type: "request",
+            id: request.id,
+            prompt: request.prompt,
+            participant: request.participant,
+            command: request.command,
+            variableData: undefined,
+            modelId: request.modelId
+        };
+    }
     dispose() {
         this._onWillDispose.fire();
         this._onWillDispose.dispose();
@@ -239,14 +265,25 @@ class ObservableChatSession extends Disposable {
         super.dispose();
     }
 }
-class MainThreadChatSessionItemController extends Disposable {
-    constructor(proxy, handle) {
+let MainThreadChatSessionItemController = class MainThreadChatSessionItemController extends Disposable {
+    constructor(proxy, chatSessionType, handle, chatService, _logService) {
         super();
+        this._logService = _logService;
         this._onDidChangeChatSessionItems = this._register(( new Emitter()));
         this.onDidChangeChatSessionItems = this._onDidChangeChatSessionItems.event;
         this._items = ( new ResourceMap());
         this._proxy = proxy;
         this._handle = handle;
+        this._register(
+            chatService.registerChatModelChangeListeners(chatSessionType, sessionResource => {
+                const item = this._items.get(sessionResource);
+                if (item) {
+                    this._onDidChangeChatSessionItems.fire({
+                        addedOrUpdated: [item]
+                    });
+                }
+            })
+        );
     }
     get items() {
         return Array.from(( this._items.values()));
@@ -255,7 +292,11 @@ class MainThreadChatSessionItemController extends Disposable {
         return this._proxy.$refreshChatSessionItems(this._handle, token);
     }
     async newChatSessionItem(request, token) {
-        const dto = await raceCancellationError(this._proxy.$newChatSessionItem(this._handle, request, token), token);
+        const dto = await raceCancellationError(this._proxy.$newChatSessionItem(this._handle, {
+            prompt: request.prompt,
+            command: request.command,
+            initialSessionOptions: request.initialSessionOptions ? ChatSessionOptionsMap.toStrValueArray(request.initialSessionOptions) : undefined
+        }, token), token);
         if (!dto) {
             return undefined;
         }
@@ -265,26 +306,33 @@ class MainThreadChatSessionItemController extends Disposable {
             changes: revive(dto.changes)
         };
         this._items.set(item.resource, item);
-        this._onDidChangeChatSessionItems.fire();
+        this._onDidChangeChatSessionItems.fire({
+            addedOrUpdated: [item]
+        });
         return item;
     }
     acceptChange(change) {
         for (const item of change.addedOrUpdated) {
+            warnOnUntitledSessionResource(item.resource, this._logService);
             this._items.set(item.resource, item);
         }
         for (const uri of change.removed) {
             this._items.delete(uri);
         }
-        this._onDidChangeChatSessionItems.fire();
+        this._onDidChangeChatSessionItems.fire({
+            addedOrUpdated: change.addedOrUpdated,
+            removed: change.removed
+        });
     }
     addOrUpdateItem(item) {
+        warnOnUntitledSessionResource(item.resource, this._logService);
         this._items.set(item.resource, item);
-        this._onDidChangeChatSessionItems.fire();
-    }
-    fireOnDidChangeChatSessionItems() {
-        this._onDidChangeChatSessionItems.fire();
+        this._onDidChangeChatSessionItems.fire({
+            addedOrUpdated: [item]
+        });
     }
-}
+};
+MainThreadChatSessionItemController = ( __decorate([( __param(3, IChatService)), ( __param(4, ILogService))], MainThreadChatSessionItemController));
 let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     constructor(
         _extHostContext,
@@ -293,10 +341,13 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         _chatService,
         _chatWidgetService,
         _chatTodoListService,
+        _chatArtifactsService,
+        _chatDebugService,
         _dialogService,
         _editorService,
         editorGroupService,
-        _logService
+        _logService,
+        _instantiationService
     ) {
         super();
         this._extHostContext = _extHostContext;
@@ -305,29 +356,32 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._chatService = _chatService;
         this._chatWidgetService = _chatWidgetService;
         this._chatTodoListService = _chatTodoListService;
+        this._chatArtifactsService = _chatArtifactsService;
+        this._chatDebugService = _chatDebugService;
         this._dialogService = _dialogService;
         this._editorService = _editorService;
         this.editorGroupService = editorGroupService;
         this._logService = _logService;
+        this._instantiationService = _instantiationService;
         this._itemControllerRegistrations = this._register(( new DisposableMap()));
         this._contentProvidersRegistrations = this._register(( new DisposableMap()));
         this._sessionTypeToHandle = ( new Map());
         this._activeSessions = ( new ResourceMap());
         this._sessionDisposables = ( new ResourceMap());
         this._proxy = ( this._extHostContext.getProxy(ExtHostContext.ExtHostChatSessions));
-        this._register(this._chatSessionsService.onRequestNotifyExtension((
+        this._register(this._chatSessionsService.onDidChangeSessionOptions((
             {
                 sessionResource,
-                updates,
-                waitUntil
+                updates
             }
         ) => {
+            warnOnUntitledSessionResource(sessionResource, this._logService);
             const handle = this._getHandleForSessionType(sessionResource.scheme);
             this._logService.trace(
-                `[MainThreadChatSessions] onRequestNotifyExtension received: scheme '${sessionResource.scheme}', handle ${handle}, ${updates.length} update(s)`
+                `[MainThreadChatSessions] onRequestNotifyExtension received: scheme '${sessionResource.scheme}', handle ${handle}, ${updates.size} update(s)`
             );
             if (handle !== undefined) {
-                waitUntil(this.notifyOptionsChange(handle, sessionResource, updates));
+                this.notifyOptionsChange(handle, sessionResource, updates);
             } else {
                 this._logService.warn(
                     `[MainThreadChatSessions] Cannot notify option change for scheme '${sessionResource.scheme}': no provider registered. Registered schemes: [${Array.from(( this._sessionTypeToHandle.keys())).join(", ")}]`
@@ -340,6 +394,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                     chatSessionType
                 }] of this._itemControllerRegistrations) {
                     if (chatSessionType === session.providerType) {
+                        warnOnUntitledSessionResource(session.resource, this._logService);
                         this._proxy.$onDidChangeChatSessionItemState(handle, session.resource, session.isArchived());
                     }
                 }
@@ -351,7 +406,9 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     }
     $registerChatSessionItemController(handle, chatSessionType) {
         const disposables = ( new DisposableStore());
-        const controller = disposables.add(( new MainThreadChatSessionItemController(this._proxy, handle)));
+        const controller = disposables.add(
+            this._instantiationService.createInstance(MainThreadChatSessionItemController, this._proxy, chatSessionType, handle)
+        );
         disposables.add(
             this._chatSessionsService.registerChatSessionItemController(chatSessionType, controller)
         );
@@ -360,11 +417,6 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             controller,
             dispose: () => disposables.dispose()
         });
-        disposables.add(this._chatSessionsService.registerChatModelChangeListeners(
-            this._chatService,
-            chatSessionType,
-            () => controller.fireOnDidChangeChatSessionItems()
-        ));
     }
     getController(handle) {
         const registration = this._itemControllerRegistrations.get(handle);
@@ -373,17 +425,14 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         }
         return registration.controller;
     }
-    $onDidChangeChatSessionItems(handle) {
-        const controller = this.getController(handle);
-        controller.fireOnDidChangeChatSessionItems();
-    }
     async _resolveSessionItem(item) {
         const uri = URI.revive(item.resource);
         const model = this._chatService.getSession(uri);
         if (model) {
             item = await this.handleSessionModelOverrides(model, item);
         }
-        if (!item.changes || !model) {
+        let changes = revive(item.changes);
+        if (!changes || !model) {
             const stats = (await this._chatService.getMetadataForSession(uri))?.stats;
             const diffs = {
                 files: stats?.fileCount || 0,
@@ -391,12 +440,12 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 deletions: stats?.removed || 0
             };
             if (hasValidDiff(diffs)) {
-                item.changes = diffs;
+                changes = diffs;
             }
         }
         return {
             ...item,
-            changes: revive(item.changes),
+            changes,
             resource: uri,
             iconPath: item.iconPath,
             tooltip: item.tooltip ? this._reviveTooltip(item.tooltip) : undefined,
@@ -418,7 +467,8 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     }
     $onDidChangeChatSessionOptions(handle, sessionResourceComponents, updates) {
         const sessionResource = URI.revive(sessionResourceComponents);
-        this._chatSessionsService.notifySessionOptionsChange(sessionResource, updates);
+        warnOnUntitledSessionResource(sessionResource, this._logService);
+        this._chatSessionsService.updateSessionOptions(sessionResource, ChatSessionOptionsMap.fromRecord(updates));
     }
     async $onDidCommitChatSessionItem(handle, originalComponents, modifiedCompoennts) {
         const originalResource = URI.revive(originalComponents);
@@ -436,11 +486,15 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         const contribution = this._chatSessionsService.getAllChatSessionContributions().find(c => c.type === chatSessionType);
         try {
             this._chatTodoListService.migrateTodos(originalResource, modifiedResource);
+            this._chatArtifactsService.migrateArtifacts(originalResource, modifiedResource);
+            if (chatSessionType === "copilotcli") {
+                this._chatDebugService.invokeProviders(modifiedResource).catch(() => {});
+            }
             const originalGroup = this.editorGroupService.groups.find(group => ( group.editors.some(editor => isEqual(editor.resource, originalResource)))) ?? this.editorGroupService.activeGroup;
             const options = {
                 title: {
                     preferred: originalEditor?.getName() || undefined,
-                    fallback: ( localize(2547, "{0}", contribution?.displayName))
+                    fallback: ( localize(2555, "{0}", contribution?.displayName))
                 }
             };
             const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
@@ -456,6 +510,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                         options
                     }
                 }], originalGroup);
+                this._resendPendingRequests(originalResource, modifiedResource);
                 return;
             }
             if (originalModel) {
@@ -473,19 +528,26 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 const ref = await this._chatService.acquireOrLoadSession(modifiedResource, ChatAgentLocation.Chat, CancellationToken.None);
                 ref?.dispose();
             }
+            this._resendPendingRequests(originalResource, modifiedResource);
         } finally {
             originalModel?.dispose();
         }
     }
+    _resendPendingRequests(originalResource, modifiedResource) {
+        this._chatService.migrateRequests(originalResource, modifiedResource);
+    }
     async handleSessionModelOverrides(model, session) {
+        const outgoingSession = {
+            ...session
+        };
         const inProgress = model.getRequests().filter(r => r.response && !r.response.isComplete);
         if (inProgress.length) {
-            session.description = this._chatSessionsService.getInProgressSessionDescription(model);
+            outgoingSession.description = this._chatSessionsService.getInProgressSessionDescription(model);
         }
-        if (!(session.changes instanceof Array)) {
+        if (!(outgoingSession.changes instanceof Array)) {
             const modelStats = await awaitStatsForSession(model);
             if (modelStats) {
-                session.changes = {
+                outgoingSession.changes = {
                     files: modelStats.fileCount,
                     insertions: modelStats.added,
                     deletions: modelStats.removed
@@ -493,11 +555,12 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             }
         }
         if (model.lastRequest?.response?.state === ResponseModelState.NeedsInput) {
-            session.status = ChatSessionStatus.NeedsInput;
+            outgoingSession.status = ChatSessionStatus.NeedsInput;
         }
-        return session;
+        return outgoingSession;
     }
     async _provideChatSessionContent(providerHandle, sessionResource, token) {
+        warnOnUntitledSessionResource(sessionResource, this._logService);
         let session = this._activeSessions.get(sessionResource);
         if (!session) {
             session = ( new ObservableChatSession(
@@ -516,11 +579,17 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             this._sessionDisposables.set(sessionResource, disposable);
         }
         try {
-            await session.initialize(token);
+            const initialSessionOptions = this._chatSessionsService.getSessionOptions(sessionResource);
+            await session.initialize(token, {
+                initialSessionOptions: initialSessionOptions ? ( [...initialSessionOptions].map(([optionId, value]) => ({
+                    optionId,
+                    value: typeof value === "string" ? value : value?.id
+                }))) : undefined
+            });
             if (session.options) {
                 for (const [_, handle] of this._sessionTypeToHandle) {
                     if (handle === providerHandle) {
-                        for (const [optionId, value] of Object.entries(session.options)) {
+                        for (const [optionId, value] of session.options) {
                             this._chatSessionsService.setSessionOption(sessionResource, optionId, value);
                         }
                         break;
@@ -583,6 +652,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     }
     $handleProgressComplete(handle, sessionResource, requestId) {
         const resource = URI.revive(sessionResource);
+        warnOnUntitledSessionResource(resource, this._logService);
         const observableSession = this._activeSessions.get(resource);
         if (!observableSession) {
             this._logService.warn(
@@ -621,7 +691,10 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 this._chatSessionsService.setOptionGroupsForSessionType(chatSessionScheme, handle, groupsWithCallbacks);
             }
             if (options?.newSessionOptions) {
-                this._chatSessionsService.setNewSessionOptionsForSessionType(chatSessionScheme, options.newSessionOptions);
+                this._chatSessionsService.setNewSessionOptionsForSessionType(
+                    chatSessionScheme,
+                    ChatSessionOptionsMap.fromRecord(options.newSessionOptions)
+                );
             }
         }).catch(err => this._logService.error("Error fetching chat session options", err));
     }
@@ -653,7 +726,12 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             `[MainThreadChatSessions] notifyOptionsChange: starting proxy call for handle ${handle}, sessionResource ${sessionResource}`
         );
         try {
-            await this._proxy.$provideHandleOptionsChange(handle, sessionResource, updates, CancellationToken.None);
+            await this._proxy.$provideHandleOptionsChange(
+                handle,
+                sessionResource,
+                Object.fromEntries(updates),
+                CancellationToken.None
+            );
             this._logService.trace(
                 `[MainThreadChatSessions] notifyOptionsChange: proxy call completed for handle ${handle}, sessionResource ${sessionResource}`
             );
@@ -665,6 +743,13 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         }
     }
 };
-MainThreadChatSessions = __decorate([extHostNamedCustomer(MainContext.MainThreadChatSessions), ( __param(1, IAgentSessionsService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetService)), ( __param(5, IChatTodoListService)), ( __param(6, IDialogService)), ( __param(7, IEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, ILogService))], MainThreadChatSessions);
+MainThreadChatSessions = __decorate([extHostNamedCustomer(MainContext.MainThreadChatSessions), ( __param(1, IAgentSessionsService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetService)), ( __param(5, IChatTodoListService)), ( __param(6, IChatArtifactsService)), ( __param(7, IChatDebugService)), ( __param(8, IDialogService)), ( __param(9, IEditorService)), ( __param(10, IEditorGroupsService)), ( __param(11, ILogService)), ( __param(12, IInstantiationService))], MainThreadChatSessions);
+function warnOnUntitledSessionResource(resource, logService) {
+    if (isUntitledChatSession(resource)) {
+        logService.warn(
+            `[MainThreadChatSessions] untitled-style sessionResource detected ${( resource.toString())}`
+        );
+    }
+}
 
 export { MainThreadChatSessions, ObservableChatSession };

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

@@ -456,7 +456,7 @@ class MainThreadCommentController extends Disposable {
         };
     }
 }
-const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2548, "View icon of the comments view.")));
+const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2556, "View icon of the comments view.")));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(
         extHostContext,

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

@@ -405,7 +405,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2549,
+                    2557,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -473,7 +473,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2550, "Edit")),
+            label: label ?? ( localize(2558, "Edit")),
             code: "undoredo.customEditorEdit",
             undo: () => this.undo(),
             redo: () => this.redo()

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

@@ -12,7 +12,7 @@ let MainThreadDownloadService = class MainThreadDownloadService extends Disposab
         this.downloadService = downloadService;
     }
     $download(uri, to) {
-        return this.downloadService.download(URI.revive(uri), URI.revive(to));
+        return this.downloadService.download(URI.revive(uri), URI.revive(to), "mainThreadDownloadService.download");
     }
 };
 MainThreadDownloadService = __decorate([

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

@@ -14,7 +14,7 @@ class ExtHostEditSessionIdentityCreateParticipant {
     }
     async participate(workspaceFolder, token) {
         const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localize(2551, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2559, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
             this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
         }));
         return raceCancellationError(p, token);

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

@@ -111,7 +111,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2552,
+                    2560,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension, which is not loaded. Would you like to reload the window to load the extension?",
                     extName,
                     missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -119,7 +119,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "reload",
-                        label: ( localize(2553, "Reload Window")),
+                        label: ( localize(2561, "Reload Window")),
                         run: () => this._hostService.reload()
                     })]
                 }
@@ -130,7 +130,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2554,
+                        2562,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in the current workspace",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -140,7 +140,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2555,
+                        2563,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is not supported in Restricted Mode",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -148,7 +148,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "manageWorkspaceTrust",
-                            label: ( localize(2556, "Manage Workspace Trust")),
+                            label: ( localize(2564, "Manage Workspace Trust")),
                             run: () => this._commandService.executeCommand("workbench.trust.manage")
                         })]
                     }
@@ -157,7 +157,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2557,
+                        2565,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled. Would you like to enable the extension and reload the window?",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -165,7 +165,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                     actions: {
                         primary: [toAction({
                             id: "enable",
-                            label: ( localize(2558, "Enable and Reload")),
+                            label: ( localize(2566, "Enable and Reload")),
                             enabled: true,
                             run: () => this._extensionEnablementService.setEnablement(
                                 [missingInstalledDependency],
@@ -178,7 +178,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 this._notificationService.notify({
                     severity: Severity.Error,
                     message: ( localize(
-                        2559,
+                        2567,
                         "Cannot activate the '{0}' extension because it depends on the '{1}' extension which is disabled.",
                         extName,
                         missingInstalledDependency.manifest.displayName || missingInstalledDependency.manifest.name
@@ -199,7 +199,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
             this._notificationService.notify({
                 severity: Severity.Error,
                 message: ( localize(
-                    2560,
+                    2568,
                     "Cannot activate the '{0}' extension because it depends on the '{1}' extension from '{2}', which is not installed. Would you like to install the extension and reload the window?",
                     extName,
                     dependencyExtension.displayName,
@@ -208,14 +208,14 @@ let MainThreadExtensionService = class MainThreadExtensionService {
                 actions: {
                     primary: [toAction({
                         id: "install",
-                        label: ( localize(2561, "Install and Reload")),
+                        label: ( localize(2569, "Install and Reload")),
                         run: () => this._extensionsWorkbenchService.install(dependencyExtension).then(() => this._hostService.reload(), e => this._notificationService.error(e))
                     })]
                 }
             });
         } else {
             this._notificationService.error(( localize(
-                2562,
+                2570,
                 "Cannot activate the '{0}' extension because it depends on an unknown '{1}' extension.",
                 extName,
                 missingDependency