@codingame/monaco-vscode-extensions-service-override 31.0.1 → 32.0.1

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

@@ -109,7 +109,9 @@ let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
                 requestName: event.requestName,
                 inputTokens: event.inputTokens,
                 outputTokens: event.outputTokens,
+                cachedTokens: event.cachedTokens,
                 totalTokens: event.totalTokens,
+                copilotUsageNanoAiu: event.copilotUsageNanoAiu,
                 durationInMillis: event.durationInMillis
             };
         case "generic":
@@ -181,7 +183,9 @@ let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
                 requestName: dto.requestName,
                 inputTokens: dto.inputTokens,
                 outputTokens: dto.outputTokens,
+                cachedTokens: dto.cachedTokens,
                 totalTokens: dto.totalTokens,
+                copilotUsageNanoAiu: dto.copilotUsageNanoAiu,
                 durationInMillis: dto.durationInMillis
             };
         case "generic":
@@ -250,10 +254,15 @@ let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
                 model: dto.model,
                 status: dto.status,
                 durationInMillis: dto.durationInMillis,
+                timeToFirstTokenInMillis: dto.timeToFirstTokenInMillis,
+                requestId: dto.requestId,
+                maxInputTokens: dto.maxInputTokens,
+                maxOutputTokens: dto.maxOutputTokens,
                 inputTokens: dto.inputTokens,
                 outputTokens: dto.outputTokens,
                 cachedTokens: dto.cachedTokens,
                 totalTokens: dto.totalTokens,
+                requestOptions: dto.requestOptions,
                 errorMessage: dto.errorMessage,
                 sections: dto.sections
             };

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

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { ChatInputNotificationDto, MainThreadChatInputNotificationShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadChatInputNotification extends Disposable implements MainThreadChatInputNotificationShape {
+    private readonly _chatInputNotificationService;
+    constructor(_extHostContext: IExtHostContext, _chatInputNotificationService: IChatInputNotificationService);
+    $setNotification(notification: ChatInputNotificationDto): void;
+    $disposeNotification(id: string): void;
+}

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

@@ -0,0 +1,33 @@
+
+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 { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+let MainThreadChatInputNotification = class MainThreadChatInputNotification extends Disposable {
+    constructor(_extHostContext, _chatInputNotificationService) {
+        super();
+        this._chatInputNotificationService = _chatInputNotificationService;
+    }
+    $setNotification(notification) {
+        this._chatInputNotificationService.setNotification({
+            id: notification.id,
+            severity: notification.severity,
+            message: notification.message,
+            description: notification.description,
+            actions: notification.actions,
+            dismissible: notification.dismissible,
+            autoDismissOnMessage: notification.autoDismissOnMessage
+        });
+    }
+    $disposeNotification(id) {
+        this._chatInputNotificationService.deleteNotification(id);
+    }
+};
+MainThreadChatInputNotification = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatInputNotification),
+    ( __param(1, IChatInputNotificationService))
+], MainThreadChatInputNotification);
+
+export { MainThreadChatInputNotification };

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

@@ -84,7 +84,8 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     private readonly _proxy;
     constructor(_extHostContext: IExtHostContext, _agentSessionsService: IAgentSessionsService, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _chatTodoListService: IChatTodoListService, _chatArtifactsService: IChatArtifactsService, _chatDebugService: IChatDebugService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService, _instantiationService: IInstantiationService);
     private _getHandleForSessionType;
-    $registerChatSessionItemController(handle: number, chatSessionType: string): void;
+    $registerChatSessionItemController(handle: number, chatSessionType: string, supportsResolve: boolean): void;
+    $updateChatSessionItemControllerCapabilities(handle: number, supportsResolve: boolean): void;
     private _refreshControllerInputState;
     private _applyOptionGroups;
     private getController;

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

@@ -27,7 +27,7 @@ import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { ChatSessionOptionsMap } 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 { getChatSessionType, isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 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';
@@ -118,7 +118,8 @@ class ObservableChatSession extends Disposable {
                 return {
                     type: "response",
                     parts: ( turn.parts.map(part => revive(part))),
-                    participant: turn.participant
+                    participant: turn.participant,
+                    details: turn.details
                 };
             })));
             if (sessionContent.hasActiveResponseCallback && !this.interruptActiveResponseCallback) {
@@ -135,7 +136,7 @@ class ObservableChatSession extends Disposable {
                         return confirmInterrupt();
                     }
                     return this._dialogService.confirm({
-                        message: ( localize(2549, "Are you sure you want to interrupt the active session?"))
+                        message: ( localize(2588, "Are you sure you want to interrupt the active session?"))
                     }).then(confirmed => {
                         if (confirmed.confirmed) {
                             return confirmInterrupt();
@@ -282,17 +283,19 @@ class ObservableChatSession extends Disposable {
     }
 }
 let MainThreadChatSessionItemController = class MainThreadChatSessionItemController extends Disposable {
-    constructor(proxy, chatSessionType, handle, _chatService, _logService) {
+    constructor(proxy, chatSessionType, handle, supportsResolve, _chatService) {
         super();
         this._chatService = _chatService;
-        this._logService = _logService;
         this._onDidChangeChatSessionItems = this._register(( new Emitter()));
         this.onDidChangeChatSessionItems = this._onDidChangeChatSessionItems.event;
         this._modelListeners = this._register(( new DisposableResourceMap()));
+        this._resolveCache = ( new ResourceMap());
+        this._resolving = ( new ResourceMap());
         this._isDisposed = false;
         this._items = ( new ResourceMap());
         this._proxy = proxy;
         this._handle = handle;
+        this._supportsResolve = supportsResolve;
         const addModelListeners = async model => {
             if (getChatSessionType(model.sessionResource) !== chatSessionType) {
                 return;
@@ -324,6 +327,7 @@ let MainThreadChatSessionItemController = class MainThreadChatSessionItemControl
     }
     dispose() {
         this._isDisposed = true;
+        this._resolveCache.clear();
         super.dispose();
     }
     get items() {
@@ -347,9 +351,14 @@ let MainThreadChatSessionItemController = class MainThreadChatSessionItemControl
     async acceptChange(change) {
         const addedOrUpdatedItems = [];
         for (const item of change.addedOrUpdated) {
+            const resource = URI.revive(item.resource);
+            if (!( this._resolving.has(resource))) {
+                this._resolveCache.delete(resource);
+            }
             addedOrUpdatedItems.push(await this.addOrUpdateItem(item));
         }
         for (const uri of change.removed) {
+            this._resolveCache.delete(uri);
             this._items.delete(uri);
         }
         this._onDidChangeChatSessionItems.fire({
@@ -359,7 +368,6 @@ let MainThreadChatSessionItemController = class MainThreadChatSessionItemControl
     }
     async addOrUpdateItem(dto) {
         const resource = URI.revive(dto.resource);
-        warnOnUntitledSessionResource(resource, this._logService);
         const existing = this._items.get(resource);
         const updated = ( new MainThreadChatSessionItem(
             dto,
@@ -369,6 +377,9 @@ let MainThreadChatSessionItemController = class MainThreadChatSessionItemControl
         if (existing?.isEqual(updated)) {
             return existing;
         }
+        if (existing && existing.label !== updated.label && this._chatService.getSession(resource)) {
+            this._chatService.setSessionTitle(resource, updated.label);
+        }
         this._items.set(resource, updated);
         this._onDidChangeChatSessionItems.fire({
             addedOrUpdated: [updated]
@@ -389,8 +400,64 @@ let MainThreadChatSessionItemController = class MainThreadChatSessionItemControl
         }
         return optionGroups;
     }
+    async resolveChatSessionItem(resource, token) {
+        if (!this._supportsResolve) {
+            return undefined;
+        }
+        const cached = this._resolveCache.get(resource);
+        if (cached) {
+            return cached;
+        }
+        const promise = this._doResolveItem(resource, token).catch(err => {
+            this._resolveCache.delete(resource);
+            throw err;
+        });
+        this._resolveCache.set(resource, promise);
+        return promise;
+    }
+    async _doResolveItem(resource, token) {
+        const expectedItem = this._items.get(resource);
+        this._resolving.set(resource, true);
+        let dto;
+        try {
+            dto = await raceCancellationError(this._proxy.$resolveChatSessionItem(this._handle, resource, token), token);
+        } finally {
+            this._resolving.delete(resource);
+        }
+        if (!dto) {
+            return undefined;
+        }
+        if (this._items.get(resource) !== expectedItem) {
+            return this._items.get(resource);
+        }
+        const updated = ( new MainThreadChatSessionItem(
+            dto,
+            this._chatService.getSession(resource),
+            await this._chatService.getMetadataForSession(resource)
+        ));
+        if (this._items.get(resource) !== expectedItem) {
+            return this._items.get(resource);
+        }
+        if (expectedItem?.isEqual(updated)) {
+            return expectedItem;
+        }
+        this._items.set(resource, updated);
+        this._onDidChangeChatSessionItems.fire({
+            addedOrUpdated: [updated]
+        });
+        return updated;
+    }
+    setSupportsResolve(supportsResolve) {
+        if (this._supportsResolve === supportsResolve) {
+            return;
+        }
+        this._supportsResolve = supportsResolve;
+        if (supportsResolve) {
+            this._resolveCache.clear();
+        }
+    }
 };
-MainThreadChatSessionItemController = ( __decorate([( __param(3, IChatService)), ( __param(4, ILogService))], MainThreadChatSessionItemController));
+MainThreadChatSessionItemController = ( __decorate([( __param(4, IChatService))], MainThreadChatSessionItemController));
 class MainThreadChatSessionItem {
     constructor(dto, model, detailOverrides) {
         this.resource = URI.revive(dto.resource);
@@ -461,16 +528,16 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 updates
             }
         ) => {
-            warnOnUntitledSessionResource(sessionResource, this._logService);
-            const handle = this._getHandleForSessionType(sessionResource.scheme);
+            const sessionType = getChatSessionType(sessionResource);
+            const handle = this._getHandleForSessionType(sessionType);
             this._logService.trace(
-                `[MainThreadChatSessions] onRequestNotifyExtension received: scheme '${sessionResource.scheme}', handle ${handle}, ${updates.size} update(s)`
+                `[MainThreadChatSessions] onRequestNotifyExtension received: sessionType '${sessionType}', handle ${handle}, ${updates.size} update(s)`
             );
             if (handle !== undefined) {
                 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(", ")}]`
+                    `[MainThreadChatSessions] Cannot notify option change for sessionType '${sessionType}': no provider registered. Registered types: [${Array.from(( this._sessionTypeToHandle.keys())).join(", ")}]`
                 );
             }
         }));
@@ -480,7 +547,6 @@ 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());
                     }
                 }
@@ -490,11 +556,15 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     _getHandleForSessionType(chatSessionType) {
         return this._sessionTypeToHandle.get(chatSessionType);
     }
-    $registerChatSessionItemController(handle, chatSessionType) {
+    $registerChatSessionItemController(handle, chatSessionType, supportsResolve) {
         const disposables = ( new DisposableStore());
-        const controller = disposables.add(
-            this._instantiationService.createInstance(MainThreadChatSessionItemController, this._proxy, chatSessionType, handle)
-        );
+        const controller = disposables.add(this._instantiationService.createInstance(
+            MainThreadChatSessionItemController,
+            this._proxy,
+            chatSessionType,
+            handle,
+            supportsResolve
+        ));
         disposables.add(
             this._chatSessionsService.registerChatSessionItemController(chatSessionType, controller)
         );
@@ -505,6 +575,14 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         });
         this._refreshControllerInputState(handle, chatSessionType);
     }
+    $updateChatSessionItemControllerCapabilities(handle, supportsResolve) {
+        const registration = this._itemControllerRegistrations.get(handle);
+        if (!registration) {
+            this._logService.warn(`No chat session item controller found for handle ${handle}`);
+            return;
+        }
+        registration.controller.setSupportsResolve(supportsResolve);
+    }
     _refreshControllerInputState(handle, chatSessionType) {
         this._proxy.$provideChatSessionInputState(handle, undefined, CancellationToken.None).then(optionGroups => {
             if (optionGroups?.length) {
@@ -548,7 +626,6 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     }
     $onDidChangeChatSessionOptions(handle, sessionResourceComponents, updates) {
         const sessionResource = URI.revive(sessionResourceComponents);
-        warnOnUntitledSessionResource(sessionResource, this._logService);
         this._chatSessionsService.updateSessionOptions(sessionResource, ChatSessionOptionsMap.fromRecord(updates));
     }
     async $onDidCommitChatSessionItem(handle, originalComponents, modifiedCompoennts) {
@@ -575,7 +652,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             const options = {
                 title: {
                     preferred: originalEditor?.getName() || undefined,
-                    fallback: ( localize(2550, "{0}", contribution?.displayName))
+                    fallback: ( localize(2589, "{0}", contribution?.displayName))
                 }
             };
             const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
@@ -619,7 +696,10 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._chatService.migrateRequests(originalResource, modifiedResource);
     }
     async _provideChatSessionContent(providerHandle, sessionResource, token) {
-        warnOnUntitledSessionResource(sessionResource, this._logService);
+        const t0 = Date.now();
+        this._logService.trace(
+            `[MainThreadChatSessions] _provideChatSessionContent start handle=${providerHandle} uri=${( sessionResource.toString())}`
+        );
         let session = this._activeSessions.get(sessionResource);
         if (!session) {
             session = ( new ObservableChatSession(
@@ -655,6 +735,9 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                     }
                 }
             }
+            this._logService.trace(
+                `[MainThreadChatSessions] _provideChatSessionContent done total=${Date.now() - t0}ms handle=${providerHandle} uri=${( sessionResource.toString())}`
+            );
             return session;
         } catch (error) {
             session.dispose();
@@ -711,7 +794,6 @@ 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(
@@ -794,13 +876,6 @@ 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, 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())}`
-        );
-    }
-}
 function reviveMarkdownString(value) {
     if (!value) {
         return undefined;

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

@@ -15,6 +15,7 @@ import { ICellRange } from "@codingame/monaco-vscode-api/vscode/vs/workbench/con
 import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
 import { MarshalledCommentThread } from "../../common/comments.js";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
 export declare class MainThreadCommentThread<T> implements languages.CommentThread<T> {
     commentThreadHandle: number;
@@ -82,12 +83,13 @@ export declare class MainThreadCommentThread<T> implements languages.CommentThre
 }
 export declare class MainThreadCommentController extends Disposable implements ICommentController {
     private readonly _proxy;
-    private readonly _commentService;
     private readonly _handle;
     private readonly _uniqueId;
     private readonly _id;
     private readonly _label;
     private _features;
+    private readonly _commentService;
+    private readonly _uriIdentityService;
     get handle(): number;
     get id(): string;
     get contextValue(): string;
@@ -101,7 +103,7 @@ export declare class MainThreadCommentController extends Disposable implements I
     activeEditingCommentThread?: MainThreadCommentThread<IRange | ICellRange>;
     get features(): CommentProviderFeatures;
     get owner(): string;
-    constructor(_proxy: ExtHostCommentsShape, _commentService: ICommentService, _handle: number, _uniqueId: string, _id: string, _label: string, _features: CommentProviderFeatures);
+    constructor(_proxy: ExtHostCommentsShape, _handle: number, _uniqueId: string, _id: string, _label: string, _features: CommentProviderFeatures, _commentService: ICommentService, _uriIdentityService: IUriIdentityService);
     get activeComment(): {
         thread: languages.CommentThread;
         comment?: languages.Comment;
@@ -149,6 +151,7 @@ export declare class MainThreadComments extends Disposable implements MainThread
     private readonly _viewDescriptorService;
     private readonly _uriIdentityService;
     private readonly _editorService;
+    private readonly _instantiationService;
     private readonly _proxy;
     private _handlers;
     private _commentControllers;
@@ -157,7 +160,7 @@ export declare class MainThreadComments extends Disposable implements MainThread
     private readonly _openViewListener;
     private readonly _onChangeContainerListener;
     private readonly _onChangeContainerLocationListener;
-    constructor(extHostContext: IExtHostContext, _commentService: ICommentService, _viewsService: IViewsService, _viewDescriptorService: IViewDescriptorService, _uriIdentityService: IUriIdentityService, _editorService: IEditorService);
+    constructor(extHostContext: IExtHostContext, _commentService: ICommentService, _viewsService: IViewsService, _viewDescriptorService: IViewDescriptorService, _uriIdentityService: IUriIdentityService, _editorService: IEditorService, _instantiationService: IInstantiationService);
     $registerCommentController(handle: number, id: string, label: string, extensionId: string): void;
     $unregisterCommentController(handle: number): void;
     $updateCommentControllerFeatures(handle: number, features: CommentProviderFeatures): void;

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

@@ -23,6 +23,7 @@ import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/netw
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
 import { revealCommentThread } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/comments/browser/commentsController';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 
 class MainThreadCommentThread {
@@ -220,7 +221,7 @@ class CommentThreadWithDisposable {
         this.disposableStore.dispose();
     }
 }
-class MainThreadCommentController extends Disposable {
+let MainThreadCommentController = class MainThreadCommentController extends Disposable {
     get handle() {
         return this._handle;
     }
@@ -251,15 +252,25 @@ class MainThreadCommentController extends Disposable {
     get owner() {
         return this._id;
     }
-    constructor(_proxy, _commentService, _handle, _uniqueId, _id, _label, _features) {
+    constructor(
+        _proxy,
+        _handle,
+        _uniqueId,
+        _id,
+        _label,
+        _features,
+        _commentService,
+        _uriIdentityService
+    ) {
         super();
         this._proxy = _proxy;
-        this._commentService = _commentService;
         this._handle = _handle;
         this._uniqueId = _uniqueId;
         this._id = _id;
         this._label = _label;
         this._features = _features;
+        this._commentService = _commentService;
+        this._uriIdentityService = _uriIdentityService;
         this._threads = this._register(( new DisposableMap()));
     }
     get activeComment() {
@@ -392,7 +403,7 @@ class MainThreadCommentController extends Disposable {
         const ret = [];
         for (const thread of [...( this._threads.keys())]) {
             const commentThread = this._threads.get(thread);
-            if (commentThread.thread.resource === ( resource.toString())) {
+            if (commentThread.thread.resource && this._uriIdentityService.extUri.isEqual(( URI.parse(commentThread.thread.resource)), resource)) {
                 if (commentThread.thread.isDocumentCommentThread()) {
                     ret.push(commentThread.thread);
                 }
@@ -455,8 +466,9 @@ class MainThreadCommentController extends Disposable {
             handle: this.handle
         };
     }
-}
-const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2551, "View icon of the comments view.")));
+};
+MainThreadCommentController = ( __decorate([( __param(6, ICommentService)), ( __param(7, IUriIdentityService))], MainThreadCommentController));
+const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2590, "View icon of the comments view.")));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(
         extHostContext,
@@ -464,7 +476,8 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         _viewsService,
         _viewDescriptorService,
         _uriIdentityService,
-        _editorService
+        _editorService,
+        _instantiationService
     ) {
         super();
         this._commentService = _commentService;
@@ -472,6 +485,7 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         this._viewDescriptorService = _viewDescriptorService;
         this._uriIdentityService = _uriIdentityService;
         this._editorService = _editorService;
+        this._instantiationService = _instantiationService;
         this._handlers = ( new Map());
         this._commentControllers = ( new Map());
         this._activeEditingCommentThreadDisposables = this._register(( new DisposableStore()));
@@ -492,19 +506,27 @@ let MainThreadComments = class MainThreadComments extends Disposable {
                 controller.activeEditingCommentThread = this._activeEditingCommentThread;
             })
         );
+        this._register(this._commentService.onResourceHasCommentingRanges(() => {
+            this.registerView();
+        }));
+        this._register(this._commentService.onDidUpdateCommentThreads(() => {
+            this.registerView();
+        }));
     }
     $registerCommentController(handle, id, label, extensionId) {
         const providerId = `${id}-${extensionId}`;
         this._handlers.set(handle, providerId);
-        const provider = ( new MainThreadCommentController(this._proxy, this._commentService, handle, providerId, id, label, {}));
+        const provider = this._instantiationService.createInstance(
+            MainThreadCommentController,
+            this._proxy,
+            handle,
+            providerId,
+            id,
+            label,
+            {}
+        );
         this._commentService.registerCommentController(providerId, provider);
         this._commentControllers.set(handle, provider);
-        this._register(this._commentService.onResourceHasCommentingRanges(e => {
-            this.registerView();
-        }));
-        this._register(this._commentService.onDidUpdateCommentThreads(e => {
-            this.registerView();
-        }));
         this._commentService.setWorkspaceComments(String(handle), []);
     }
     $unregisterCommentController(handle) {
@@ -682,6 +704,6 @@ let MainThreadComments = class MainThreadComments extends Disposable {
         return this._handlers.get(handle);
     }
 };
-MainThreadComments = __decorate([extHostNamedCustomer(MainContext.MainThreadComments), ( __param(1, ICommentService)), ( __param(2, IViewsService)), ( __param(3, IViewDescriptorService)), ( __param(4, IUriIdentityService)), ( __param(5, IEditorService))], MainThreadComments);
+MainThreadComments = __decorate([extHostNamedCustomer(MainContext.MainThreadComments), ( __param(1, ICommentService)), ( __param(2, IViewsService)), ( __param(3, IViewDescriptorService)), ( __param(4, IUriIdentityService)), ( __param(5, IEditorService)), ( __param(6, IInstantiationService))], MainThreadComments);
 
 export { MainThreadCommentController, MainThreadCommentThread, MainThreadComments };

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

@@ -6,7 +6,8 @@ import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log
 export declare class MainThreadConsole implements MainThreadConsoleShape {
     private readonly _environmentService;
     private readonly _logService;
-    private readonly _isExtensionDevTestFromCli;
+    private readonly _logAllExtensionHostConsole;
+    private readonly _logExtensionHostConsoleToLocalConsole;
     constructor(_extHostContext: IExtHostContext, _environmentService: IEnvironmentService, _logService: ILogService);
     dispose(): void;
     $logExtensionHostMessage(entry: IRemoteConsoleLog): void;

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

@@ -6,6 +6,7 @@ import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { log } from '../../../base/common/console.js';
 import { logRemoteEntry, logRemoteEntryIfError } from '../../services/extensions/common/remoteConsoleUtil.js';
 import { parseExtensionDevOptions } from '../../services/extensions/common/extensionDevOptions.js';
+import { isDevConsoleLogForwardingEnabled } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 
 let MainThreadConsole = class MainThreadConsole {
@@ -13,12 +14,17 @@ let MainThreadConsole = class MainThreadConsole {
         this._environmentService = _environmentService;
         this._logService = _logService;
         const devOpts = parseExtensionDevOptions(this._environmentService);
-        this._isExtensionDevTestFromCli = devOpts.isExtensionDevTestFromCli;
+        const isDevConsoleLogForwardingActive = !this._environmentService.isBuilt && isDevConsoleLogForwardingEnabled;
+        this._logAllExtensionHostConsole = devOpts.isExtensionDevTestFromCli || isDevConsoleLogForwardingActive;
+        this._logExtensionHostConsoleToLocalConsole = !devOpts.isExtensionDevTestFromCli && !isDevConsoleLogForwardingActive;
     }
     dispose() {}
     $logExtensionHostMessage(entry) {
-        if (this._isExtensionDevTestFromCli) {
+        if (this._logAllExtensionHostConsole) {
             logRemoteEntry(this._logService, entry);
+            if (this._logExtensionHostConsoleToLocalConsole) {
+                log(entry, "Extension Host");
+            }
         } else {
             logRemoteEntryIfError(this._logService, entry, "Extension Host");
             log(entry, "Extension Host");

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

@@ -14,6 +14,7 @@ import { IExtHostContext } from "../../services/extensions/common/extHostCustome
 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";
 import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IUntitledTextEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service";
 export declare class MainThreadCustomEditors extends Disposable implements extHostProtocol.MainThreadCustomEditorsShape {
     private readonly mainThreadWebview;
     private readonly mainThreadWebviewPanels;
@@ -23,14 +24,17 @@ export declare class MainThreadCustomEditors extends Disposable implements extHo
     private readonly _instantiationService;
     private readonly _webviewWorkbenchService;
     private readonly _uriIdentityService;
+    private readonly _untitledTextEditorService;
     private readonly _proxyCustomEditors;
     private readonly _editorProviders;
     private readonly _editorRenameBackups;
+    private readonly _pendingSideBySideDiffResolutions;
     private readonly _webviewOriginStore;
-    constructor(context: IExtHostContext, mainThreadWebview: MainThreadWebviews, mainThreadWebviewPanels: MainThreadWebviewPanels, extensionService: IExtensionService, storageService: IStorageService, workingCopyService: IWorkingCopyService, workingCopyFileService: IWorkingCopyFileService, _customEditorService: ICustomEditorService, _editorGroupService: IEditorGroupsService, _editorService: IEditorService, _instantiationService: IInstantiationService, _webviewWorkbenchService: IWebviewWorkbenchService, _uriIdentityService: IUriIdentityService);
-    $registerTextEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, capabilities: extHostProtocol.CustomTextEditorCapabilities, serializeBuffersForPostMessage: boolean): void;
-    $registerCustomEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, supportsMultipleEditorsPerDocument: boolean, serializeBuffersForPostMessage: boolean): void;
+    constructor(context: IExtHostContext, mainThreadWebview: MainThreadWebviews, mainThreadWebviewPanels: MainThreadWebviewPanels, extensionService: IExtensionService, storageService: IStorageService, workingCopyService: IWorkingCopyService, workingCopyFileService: IWorkingCopyFileService, _customEditorService: ICustomEditorService, _editorGroupService: IEditorGroupsService, _editorService: IEditorService, _instantiationService: IInstantiationService, _webviewWorkbenchService: IWebviewWorkbenchService, _uriIdentityService: IUriIdentityService, _untitledTextEditorService: IUntitledTextEditorService);
+    $registerTextEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, capabilities: extHostProtocol.CustomEditorProviderCapabilities, serializeBuffersForPostMessage: boolean): void;
+    $registerCustomEditorProvider(extensionData: extHostProtocol.WebviewExtensionDescription, viewType: string, options: extHostProtocol.IWebviewPanelOptions, capabilities: extHostProtocol.CustomEditorProviderCapabilities, supportsMultipleEditorsPerDocument: boolean, serializeBuffersForPostMessage: boolean): void;
     private registerEditorProvider;
+    private resolveCustomEditorSideBySideDiff;
     $unregisterEditorProvider(viewType: string): void;
     private getOrCreateCustomEditorModel;
     $onDidEdit(resourceComponents: UriComponents, viewType: string, editId: number, label: string | undefined): Promise<void>;