@codingame/monaco-vscode-extensions-service-override 20.4.1 → 21.0.0

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

@@ -2,9 +2,10 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
@@ -15,7 +16,191 @@ import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
+class ObservableChatSession extends Disposable {
+    static generateSessionKey(providerHandle, sessionId) {
+        return `${providerHandle}_${sessionId}`;
+    }
+    get sessionKey() {
+        return ObservableChatSession.generateSessionKey(this.providerHandle, this.sessionId);
+    }
+    get progressObs() {
+        return this._progressObservable;
+    }
+    get isCompleteObs() {
+        return this._isCompleteObservable;
+    }
+    constructor(id, providerHandle, proxy, logService, dialogService) {
+        super();
+        this._progressObservable = observableValue(this, []);
+        this._isCompleteObservable = observableValue(this, false);
+        this._onWillDispose = ( new Emitter());
+        this.onWillDispose = this._onWillDispose.event;
+        this._pendingProgressChunks = ( new Map());
+        this._isInitialized = false;
+        this._interruptionWasCanceled = false;
+        this._disposalPending = false;
+        this.sessionId = id;
+        this.providerHandle = providerHandle;
+        this.history = [];
+        this._proxy = proxy;
+        this._providerHandle = providerHandle;
+        this._logService = logService;
+        this._dialogService = dialogService;
+    }
+    initialize(token) {
+        if (!this._initializationPromise) {
+            this._initializationPromise = this._doInitializeContent(token);
+        }
+        return this._initializationPromise;
+    }
+    async _doInitializeContent(token) {
+        try {
+            const sessionContent = await raceCancellationError(this._proxy.$provideChatSessionContent(this._providerHandle, this.sessionId, token), token);
+            this.history.length = 0;
+            this.history.push(...( sessionContent.history.map((turn) => {
+                if (turn.type === 'request') {
+                    return { type: 'request', prompt: turn.prompt, participant: turn.participant };
+                }
+                return {
+                    type: 'response',
+                    parts: ( turn.parts.map((part) => revive(part))),
+                    participant: turn.participant
+                };
+            })));
+            if (sessionContent.hasActiveResponseCallback && !this.interruptActiveResponseCallback) {
+                this.interruptActiveResponseCallback = async () => {
+                    const confirmInterrupt = () => {
+                        if (this._disposalPending) {
+                            this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionId);
+                            this._disposalPending = false;
+                        }
+                        this._proxy.$interruptChatSessionActiveResponse(this._providerHandle, this.sessionId, 'ongoing');
+                        return true;
+                    };
+                    if (sessionContent.supportsInterruption) {
+                        return confirmInterrupt();
+                    }
+                    return this._dialogService.confirm({
+                        message: ( localize(2449, 'Are you sure you want to interrupt the active session?'))
+                    }).then(confirmed => {
+                        if (confirmed.confirmed) {
+                            return confirmInterrupt();
+                        }
+                        else {
+                            this._addProgress([{
+                                    kind: 'progressMessage',
+                                    content: { value: '', isTrusted: false }
+                                }]);
+                            this._interruptionWasCanceled = true;
+                            if (this._disposalPending) {
+                                this._logService.info(`Canceling deferred disposal for session ${this.sessionId} (user canceled interruption)`);
+                                this._disposalPending = false;
+                            }
+                            return false;
+                        }
+                    });
+                };
+            }
+            if (sessionContent.hasRequestHandler && !this.requestHandler) {
+                this.requestHandler = async (request, progress, history, token) => {
+                    this._progressObservable.set([], undefined);
+                    this._isCompleteObservable.set(false, undefined);
+                    let lastProgressLength = 0;
+                    const progressDisposable = autorun(reader => {
+                        const progressArray = this._progressObservable.read(reader);
+                        const isComplete = this._isCompleteObservable.read(reader);
+                        if (progressArray.length > lastProgressLength) {
+                            const newProgress = progressArray.slice(lastProgressLength);
+                            progress(newProgress);
+                            lastProgressLength = progressArray.length;
+                        }
+                        if (isComplete) {
+                            progressDisposable.dispose();
+                        }
+                    });
+                    try {
+                        await this._proxy.$invokeChatSessionRequestHandler(this._providerHandle, this.sessionId, request, history, token);
+                        if (!this._isCompleteObservable.get() && !this.interruptActiveResponseCallback) {
+                            this._markComplete();
+                        }
+                    }
+                    catch (error) {
+                        const errorProgress = {
+                            kind: 'progressMessage',
+                            content: { value: `Error: ${error instanceof Error ? error.message : String(error)}`, isTrusted: false }
+                        };
+                        this._addProgress([errorProgress]);
+                        this._markComplete();
+                        throw error;
+                    }
+                    finally {
+                        progressDisposable.dispose();
+                    }
+                };
+            }
+            this._isInitialized = true;
+            const hasActiveResponse = sessionContent.hasActiveResponseCallback;
+            const hasRequestHandler = sessionContent.hasRequestHandler;
+            const hasAnyCapability = hasActiveResponse || hasRequestHandler;
+            for (const [requestId, chunks] of this._pendingProgressChunks) {
+                this._logService.debug(`Processing ${chunks.length} pending progress chunks for session ${this.sessionId}, requestId ${requestId}`);
+                this._addProgress(chunks);
+            }
+            this._pendingProgressChunks.clear();
+            if (!hasAnyCapability) {
+                this._isCompleteObservable.set(true, undefined);
+            }
+        }
+        catch (error) {
+            this._logService.error(`Failed to initialize chat session ${this.sessionId}:`, error);
+            throw error;
+        }
+    }
+    handleProgressChunk(requestId, progress) {
+        if (!this._isInitialized) {
+            const existing = this._pendingProgressChunks.get(requestId) || [];
+            this._pendingProgressChunks.set(requestId, [...existing, ...progress]);
+            this._logService.debug(`Queuing ${progress.length} progress chunks for session ${this.sessionId}, requestId ${requestId} (session not initialized)`);
+            return;
+        }
+        this._addProgress(progress);
+    }
+    handleProgressComplete(requestId) {
+        this._pendingProgressChunks.delete(requestId);
+        if (this._isInitialized) {
+            if (!this._interruptionWasCanceled) {
+                this._markComplete();
+            }
+            else {
+                this._interruptionWasCanceled = false;
+            }
+        }
+    }
+    _addProgress(progress) {
+        const currentProgress = this._progressObservable.get();
+        this._progressObservable.set([...currentProgress, ...progress], undefined);
+    }
+    _markComplete() {
+        if (!this._isCompleteObservable.get()) {
+            this._isCompleteObservable.set(true, undefined);
+        }
+    }
+    dispose() {
+        this._onWillDispose.fire();
+        this._onWillDispose.dispose();
+        this._pendingProgressChunks.clear();
+        if (this.interruptActiveResponseCallback && !this._interruptionWasCanceled) {
+            this._disposalPending = true;
+        }
+        else {
+            this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionId);
+        }
+        super.dispose();
+    }
+}
 let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     constructor(_extHostContext, _chatSessionsService, _dialogService, _editorService, _logService, _viewsService) {
         super();
@@ -26,21 +211,29 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._logService = _logService;
         this._viewsService = _viewsService;
         this._itemProvidersRegistrations = this._register(( new DisposableMap()));
-        this._contentProvidersRegisterations = this._register(( new DisposableMap()));
-        this._activeProgressEmitters = ( new Map());
-        this._completionEmitters = ( new Map());
-        this._pendingProgressChunks = ( new Map());
+        this._contentProvidersRegistrations = this._register(( new DisposableMap()));
+        this._activeSessions = ( new Map());
+        this._sessionDisposables = ( new Map());
         this._proxy = ( this._extHostContext.getProxy(ExtHostContext.ExtHostChatSessions));
     }
     $registerChatSessionItemProvider(handle, chatSessionType) {
+        const disposables = ( new DisposableStore());
+        const changeEmitter = disposables.add(( new Emitter()));
         const provider = {
             chatSessionType,
-            provideChatSessionItems: (token) => this._provideChatSessionItems(handle, token)
+            onDidChangeChatSessionItems: changeEmitter.event,
+            provideChatSessionItems: (token) => this._provideChatSessionItems(handle, token),
+            provideNewChatSessionItem: (options, token) => this._provideNewChatSessionItem(handle, options, token)
         };
-        this._itemProvidersRegistrations.set(handle, this._chatSessionsService.registerChatSessionItemProvider(provider));
+        disposables.add(this._chatSessionsService.registerChatSessionItemProvider(provider));
+        this._itemProvidersRegistrations.set(handle, {
+            dispose: () => disposables.dispose(),
+            provider,
+            onDidChangeItems: changeEmitter,
+        });
     }
-    $onDidChangeChatSessionItems(chatSessionType) {
-        this._chatSessionsService.notifySessionItemsChange(chatSessionType);
+    $onDidChangeChatSessionItems(handle) {
+        this._itemProvidersRegistrations.get(handle)?.onDidChangeItems.fire();
     }
     async _provideChatSessionItems(handle, token) {
         try {
@@ -48,7 +241,8 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             return ( sessions.map(session => ({
                 ...session,
                 id: session.id,
-                iconPath: session.iconPath ? this._reviveIconPath(session.iconPath) : undefined
+                iconPath: session.iconPath,
+                tooltip: session.tooltip ? this._reviveTooltip(session.tooltip) : undefined
             })));
         }
         catch (error) {
@@ -56,75 +250,43 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         }
         return [];
     }
-    async _provideChatSessionContent(providerHandle, id, token) {
+    async _provideNewChatSessionItem(handle, options, token) {
         try {
-            const sessionContent = await raceCancellationError(this._proxy.$provideChatSessionContent(providerHandle, id, token), token);
-            const progressEmitter = ( new Emitter());
-            const completionEmitter = ( new Emitter());
-            let progressEvent = undefined;
-            let interruptActiveResponseCallback = undefined;
-            if (sessionContent.hasActiveResponseCallback) {
-                const requestId = 'ongoing';
-                progressEvent = progressEmitter.event;
-                const progressKey = `${providerHandle}_${id}_${requestId}`;
-                interruptActiveResponseCallback = async () => {
-                    return this._dialogService.confirm({
-                        message: ( localize(2445, 'Are you sure you want to interrupt the active session?'))
-                    }).then(confirmed => {
-                        if (confirmed.confirmed) {
-                            this._proxy.$interruptChatSessionActiveResponse(providerHandle, id, requestId);
-                            return true;
-                        }
-                        else {
-                            progressEmitter.fire([{
-                                    kind: 'progressMessage',
-                                    content: { value: '' }
-                                }]);
-                            return false;
-                        }
-                    });
-                };
-                this._activeProgressEmitters.set(progressKey, progressEmitter);
-                this._completionEmitters.set(progressKey, completionEmitter);
-            }
-            let requestHandler;
-            if (sessionContent.hasRequestHandler) {
-                requestHandler = async (request, progress, history, token) => {
-                    const progressKey = `${providerHandle}_${id}_${request.requestId}`;
-                    const _progressEmitter = ( new Emitter());
-                    this._activeProgressEmitters.set(progressKey, _progressEmitter);
-                    _progressEmitter.event(e => {
-                        progress(e);
-                    });
-                    await this._proxy.$invokeChatSessionRequestHandler(providerHandle, id, request, [], token);
-                };
+            const chatSessionItem = await this._proxy.$provideNewChatSessionItem(handle, options, token);
+            if (!chatSessionItem) {
+                throw ( new Error('Extension failed to create chat session'));
             }
-            const onWillDisposeEventEmitter = ( new Emitter());
             return {
-                id: sessionContent.id,
-                onWillDispose: onWillDisposeEventEmitter.event,
-                history: ( sessionContent.history.map(turn => {
-                    if (turn.type === 'request') {
-                        return { type: 'request', prompt: turn.prompt };
-                    }
-                    return {
-                        type: 'response',
-                        parts: ( turn.parts.map(part => revive(part)))
-                    };
-                })),
-                progressEvent: progressEvent,
-                requestHandler: requestHandler,
-                interruptActiveResponseCallback: interruptActiveResponseCallback,
-                dispose: () => {
-                    onWillDisposeEventEmitter.fire();
-                    onWillDisposeEventEmitter.dispose();
-                    progressEmitter.dispose();
-                    completionEmitter.dispose();
-                    this._proxy.$disposeChatSessionContent(providerHandle, sessionContent.id);
-                },
+                ...chatSessionItem,
+                id: chatSessionItem.id,
+                iconPath: chatSessionItem.iconPath,
+                tooltip: chatSessionItem.tooltip ? this._reviveTooltip(chatSessionItem.tooltip) : undefined,
             };
         }
         catch (error) {
+            this._logService.error('Error creating chat session:', error);
+            throw error;
+        }
+    }
+    async _provideChatSessionContent(providerHandle, id, token) {
+        const sessionKey = ObservableChatSession.generateSessionKey(providerHandle, id);
+        let session = this._activeSessions.get(sessionKey);
+        if (!session) {
+            session = ( new ObservableChatSession(id, providerHandle, this._proxy, this._logService, this._dialogService));
+            this._activeSessions.set(sessionKey, session);
+            const disposable = session.onWillDispose(() => {
+                this._activeSessions.delete(sessionKey);
+                this._sessionDisposables.get(sessionKey)?.dispose();
+                this._sessionDisposables.delete(sessionKey);
+            });
+            this._sessionDisposables.set(sessionKey, disposable);
+        }
+        try {
+            await session.initialize(token);
+            return session;
+        }
+        catch (error) {
+            session.dispose();
             this._logService.error(`Error providing chat session content for handle ${providerHandle} and id ${id}:`, error);
             throw error;
         }
@@ -134,90 +296,65 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     }
     $registerChatSessionContentProvider(handle, chatSessionType) {
         const provider = {
-            chatSessionType,
             provideChatSessionContent: (id, token) => this._provideChatSessionContent(handle, id, token)
         };
-        this._contentProvidersRegisterations.set(handle, this._chatSessionsService.registerChatSessionContentProvider(provider));
+        this._contentProvidersRegistrations.set(handle, this._chatSessionsService.registerChatSessionContentProvider(chatSessionType, provider));
     }
     $unregisterChatSessionContentProvider(handle) {
-        this._contentProvidersRegisterations.deleteAndDispose(handle);
+        this._contentProvidersRegistrations.deleteAndDispose(handle);
+        for (const [key, session] of this._activeSessions) {
+            if (session.providerHandle === handle) {
+                session.dispose();
+                this._activeSessions.delete(key);
+            }
+        }
     }
     async $handleProgressChunk(handle, sessionId, requestId, chunks) {
-        const progressKey = `${handle}_${sessionId}_${requestId}`;
-        const progressEmitter = this._activeProgressEmitters.get(progressKey);
-        if (!progressEmitter) {
-            const existingChunks = this._pendingProgressChunks.get(progressKey) || [];
-            this._pendingProgressChunks.set(progressKey, [...existingChunks, ...chunks]);
-            this._logService.debug(`Storing pending progress chunks for handle ${handle}, sessionId ${sessionId}, requestId ${requestId}`);
-            return;
-        }
-        const pendingChunks = this._pendingProgressChunks.get(progressKey);
-        if (pendingChunks && pendingChunks.length > 0) {
-            this._logService.debug(`Flushing ${pendingChunks.length} pending progress chunks for handle ${handle}, sessionId ${sessionId}, requestId ${requestId}`);
-            const pendingProgressParts = ( pendingChunks.map(chunk => {
-                const [progress] = Array.isArray(chunk) ? chunk : [chunk];
-                return revive(progress);
-            }));
-            progressEmitter.fire(pendingProgressParts);
-            this._pendingProgressChunks.delete(progressKey);
-        }
+        const sessionKey = ObservableChatSession.generateSessionKey(handle, sessionId);
+        const observableSession = this._activeSessions.get(sessionKey);
         const chatProgressParts = ( chunks.map(chunk => {
             const [progress] = Array.isArray(chunk) ? chunk : [chunk];
             return revive(progress);
         }));
-        progressEmitter.fire(chatProgressParts);
+        if (observableSession) {
+            observableSession.handleProgressChunk(requestId, chatProgressParts);
+        }
+        else {
+            this._logService.warn(`No session found for progress chunks: handle ${handle}, sessionId ${sessionId}, requestId ${requestId}`);
+        }
     }
     $handleProgressComplete(handle, sessionId, requestId) {
-        const progressKey = `${handle}_${sessionId}_${requestId}`;
-        const progressEmitter = this._activeProgressEmitters.get(progressKey);
-        const completionEmitter = this._completionEmitters.get(progressKey);
-        if (!progressEmitter) {
-            this._logService.warn(`No progress emitter found for handle ${handle} and requestId ${requestId}`);
-            return;
+        const sessionKey = ObservableChatSession.generateSessionKey(handle, sessionId);
+        const observableSession = this._activeSessions.get(sessionKey);
+        if (observableSession) {
+            observableSession.handleProgressComplete(requestId);
         }
-        const completionProgress = {
-            kind: 'progressMessage',
-            content: { value: 'Session completed', isTrusted: false }
-        };
-        progressEmitter.fire([completionProgress]);
-        if (completionEmitter) {
-            completionEmitter.fire();
+        else {
+            this._logService.warn(`No session found for progress completion: handle ${handle}, sessionId ${sessionId}, requestId ${requestId}`);
         }
-        progressEmitter.dispose();
-        completionEmitter?.dispose();
-        this._activeProgressEmitters.delete(progressKey);
-        this._completionEmitters.delete(progressKey);
-        this._pendingProgressChunks.delete(progressKey);
     }
     $handleAnchorResolve(handle, sessionId, requestId, requestHandle, anchor) {
     }
     dispose() {
-        for (const emitter of ( this._activeProgressEmitters.values())) {
-            emitter.dispose();
+        for (const session of ( this._activeSessions.values())) {
+            session.dispose();
         }
-        this._activeProgressEmitters.clear();
-        for (const emitter of ( this._completionEmitters.values())) {
-            emitter.dispose();
+        this._activeSessions.clear();
+        for (const disposable of ( this._sessionDisposables.values())) {
+            disposable.dispose();
         }
-        this._completionEmitters.clear();
-        this._pendingProgressChunks.clear();
+        this._sessionDisposables.clear();
         super.dispose();
     }
-    _reviveIconPath(iconPath) {
-        if (!iconPath) {
+    _reviveTooltip(tooltip) {
+        if (!tooltip) {
             return undefined;
         }
-        if (typeof iconPath === 'object' && 'id' in iconPath) {
-            return iconPath;
+        if (typeof tooltip === 'string') {
+            return tooltip;
         }
-        if (typeof iconPath === 'object' && 'scheme' in iconPath) {
-            return URI.revive(iconPath);
-        }
-        if (typeof iconPath === 'object' && ('light' in iconPath && 'dark' in iconPath)) {
-            return {
-                light: URI.revive(iconPath.light),
-                dark: URI.revive(iconPath.dark)
-            };
+        if (typeof tooltip === 'object' && 'value' in tooltip) {
+            return MarkdownString.lift(tooltip);
         }
         return undefined;
     }
@@ -244,4 +381,4 @@ MainThreadChatSessions = __decorate([
     ( __param(5, IViewsService))
 ], MainThreadChatSessions);
 
-export { MainThreadChatSessions };
+export { MainThreadChatSessions, ObservableChatSession };

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

@@ -14,7 +14,7 @@ import { COMMENTS_VIEW_ID, COMMENTS_VIEW_STORAGE_ID, COMMENTS_VIEW_TITLE } from
 import { Extensions, ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
 import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
 import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
-import { ViewPaneContainer } from '@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { ViewPaneContainer } from '@codingame/monaco-vscode-71c8dbff-4c98-552f-aef0-e72b00fdcfc0-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
@@ -424,7 +424,7 @@ class MainThreadCommentController extends Disposable {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2446, 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2450, 'View icon of the comments view.')));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(extHostContext, _commentService, _viewsService, _viewDescriptorService, _uriIdentityService, _editorService) {
         super();

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

@@ -27,13 +27,13 @@ import { ICustomEditorService } from '@codingame/monaco-vscode-api/vscode/vs/wor
 import { CustomTextEditorModel } from '../../contrib/customEditor/common/customTextEditorModel.js';
 import { ExtensionKeyedWebviewOriginStore } from '@codingame/monaco-vscode-a654b07e-8806-5425-b124-18f03ba8e11a-common/vscode/vs/workbench/contrib/webview/browser/webview';
 import { IWebviewWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService.service';
-import { editorGroupToColumn } from '@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { editorGroupToColumn } from '@codingame/monaco-vscode-5e2c24a1-3217-55e8-bc90-521eaf7df5a6-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
 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';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
-import { ResourceWorkingCopy } from '@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/services/workingCopy/common/resourceWorkingCopy';
+import { ResourceWorkingCopy } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/resourceWorkingCopy';
 import { NO_TYPE_ID, WorkingCopyCapabilities } from '@codingame/monaco-vscode-caeb744c-8e3f-5c11-80fb-0f057d24d544-common/vscode/vs/workbench/services/workingCopy/common/workingCopy';
 import { IWorkingCopyFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 import { IWorkingCopyService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
@@ -303,7 +303,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
             this._register(workingCopyService.registerWorkingCopy(this));
             this._register(extensionService.onWillStop(e => {
                 e.veto(true, ( localize(
-                    2447,
+                    2451,
                     "An extension provided editor for '{0}' is still open that would close otherwise.",
                     this.name
                 )));
@@ -371,7 +371,7 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         this._undoService.pushElement({
             type: UndoRedoElementType.Resource,
             resource: this._editorResource,
-            label: label ?? ( localize(2448, "Edit")),
+            label: label ?? ( localize(2452, "Edit")),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),

package/vscode/src/vs/workbench/api/browser/mainThreadDataChannels.d.ts

@@ -1,5 +1,5 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IDataChannelService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/dataChannel/common/dataChannel.service";
+import { IDataChannelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { MainThreadDataChannelsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 export declare class MainThreadDataChannels extends Disposable implements MainThreadDataChannelsShape {

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

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { IDataChannelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/dataChannel/common/dataChannel.service';
+import { IDataChannelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 

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

@@ -13,7 +13,7 @@ import { MainThreadDocuments } from './mainThreadDocuments.js';
 import { MainThreadTextEditor } from './mainThreadEditor.js';
 import { MainThreadTextEditors } from './mainThreadEditors.js';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { editorGroupToColumn } from '@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { editorGroupToColumn } from '@codingame/monaco-vscode-5e2c24a1-3217-55e8-bc90-521eaf7df5a6-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';

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(2449, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2453, "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/mainThreadEditorTabs.d.ts

@@ -1,7 +1,7 @@
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { MainThreadEditorTabsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
-import { EditorGroupColumn } from "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
+import { EditorGroupColumn } from "@codingame/monaco-vscode-5e2c24a1-3217-55e8-bc90-521eaf7df5a6-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
 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";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";

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

@@ -18,9 +18,9 @@ import { InteractiveEditorInput } from '@codingame/monaco-vscode-eba0b9b3-174c-5
 import { MergeEditorInput } from '@codingame/monaco-vscode-8ccb7637-50ea-5359-97bf-00015d7fe567-common/vscode/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput';
 import { MultiDiffEditorInput } from '@codingame/monaco-vscode-0af61f78-dfc5-57ba-8d32-66268c8de38d-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
 import { NotebookEditorInput } from '@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
-import { TerminalEditorInput } from '@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/contrib/terminal/browser/terminalEditorInput';
+import { TerminalEditorInput } from '@codingame/monaco-vscode-05a2a821-e4de-5941-b7f9-bbf01c09f229-common/vscode/vs/workbench/contrib/terminal/browser/terminalEditorInput';
 import { WebviewInput } from '@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/webviewPanel/browser/webviewEditorInput';
-import { editorGroupToColumn, columnToEditorGroup } from '@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { editorGroupToColumn, columnToEditorGroup } from '@codingame/monaco-vscode-5e2c24a1-3217-55e8-bc90-521eaf7df5a6-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
 import { GroupDirection, preferredSideBySideGroupDirection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { SIDE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';

package/vscode/src/vs/workbench/api/browser/mainThreadEditors.d.ts

@@ -6,7 +6,7 @@ import { IDecorationOptions, IDecorationRenderOptions } from "@codingame/monaco-
 import { ISingleEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation";
 import { MainThreadTextEditor } from "./mainThreadEditor.js";
 import { IApplyEditsOptions, ITextDocumentShowOptions, ITextEditorConfigurationUpdate, IUndoStopOptions, MainThreadTextEditorsShape, TextEditorRevealType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
-import { EditorGroupColumn } from "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
+import { EditorGroupColumn } from "@codingame/monaco-vscode-5e2c24a1-3217-55e8-bc90-521eaf7df5a6-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
 import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";

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

@@ -8,7 +8,7 @@ import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/edito
 import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
 import { isTextEditorDiffInformationEqual, EditorResolution, EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
 import { ExtHostContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { editorGroupToColumn, columnToEditorGroup } from '@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
+import { editorGroupToColumn, columnToEditorGroup } from '@codingame/monaco-vscode-5e2c24a1-3217-55e8-bc90-521eaf7df5a6-common/vscode/vs/workbench/services/editor/common/editorGroupColumn';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';