@codingame/monaco-vscode-extensions-service-override 22.1.9 → 23.0.1

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

@@ -5,28 +5,26 @@ import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 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 { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { ChatViewId } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatEditorInput } from '@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
-import { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
 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 { 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 options() {
+        return this._options;
     }
     get progressObs() {
         return this._progressObservable;
@@ -34,7 +32,7 @@ class ObservableChatSession extends Disposable {
     get isCompleteObs() {
         return this._isCompleteObservable;
     }
-    constructor(id, providerHandle, proxy, logService, dialogService) {
+    constructor(resource, providerHandle, proxy, logService, dialogService) {
         super();
         this._progressObservable = observableValue(this, []);
         this._isCompleteObservable = observableValue(this, false);
@@ -44,7 +42,7 @@ class ObservableChatSession extends Disposable {
         this._isInitialized = false;
         this._interruptionWasCanceled = false;
         this._disposalPending = false;
-        this.sessionId = id;
+        this.sessionResource = resource;
         this.providerHandle = providerHandle;
         this.history = [];
         this._proxy = proxy;
@@ -60,11 +58,25 @@ class ObservableChatSession extends Disposable {
     }
     async _doInitializeContent(token) {
         try {
-            const sessionContent = await raceCancellationError(this._proxy.$provideChatSessionContent(this._providerHandle, this.sessionId, token), token);
+            const sessionContent = await raceCancellationError(this._proxy.$provideChatSessionContent(this._providerHandle, this.sessionResource, token), token);
+            this._options = sessionContent.options;
             this.history.length = 0;
             this.history.push(...( sessionContent.history.map((turn) => {
                 if (turn.type === 'request') {
-                    return { type: 'request', prompt: turn.prompt, participant: turn.participant };
+                    const variables = turn.variableData?.variables.map(v => {
+                        const entry = {
+                            ...v,
+                            value: revive(v.value)
+                        };
+                        return entry;
+                    });
+                    return {
+                        type: 'request',
+                        prompt: turn.prompt,
+                        participant: turn.participant,
+                        command: turn.command,
+                        variableData: variables ? { variables } : undefined
+                    };
                 }
                 return {
                     type: 'response',
@@ -76,17 +88,17 @@ class ObservableChatSession extends Disposable {
                 this.interruptActiveResponseCallback = async () => {
                     const confirmInterrupt = () => {
                         if (this._disposalPending) {
-                            this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionId);
+                            this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionResource);
                             this._disposalPending = false;
                         }
-                        this._proxy.$interruptChatSessionActiveResponse(this._providerHandle, this.sessionId, 'ongoing');
+                        this._proxy.$interruptChatSessionActiveResponse(this._providerHandle, this.sessionResource, 'ongoing');
                         return true;
                     };
                     if (sessionContent.supportsInterruption) {
                         return confirmInterrupt();
                     }
                     return this._dialogService.confirm({
-                        message: ( localize(2455, 'Are you sure you want to interrupt the active session?'))
+                        message: ( localize(2466, 'Are you sure you want to interrupt the active session?'))
                     }).then(confirmed => {
                         if (confirmed.confirmed) {
                             return confirmInterrupt();
@@ -98,7 +110,7 @@ class ObservableChatSession extends Disposable {
                                 }]);
                             this._interruptionWasCanceled = true;
                             if (this._disposalPending) {
-                                this._logService.info(`Canceling deferred disposal for session ${this.sessionId} (user canceled interruption)`);
+                                this._logService.info(`Canceling deferred disposal for session ${this.sessionResource} (user canceled interruption)`);
                                 this._disposalPending = false;
                             }
                             return false;
@@ -124,7 +136,7 @@ class ObservableChatSession extends Disposable {
                         }
                     });
                     try {
-                        await this._proxy.$invokeChatSessionRequestHandler(this._providerHandle, this.sessionId, request, history, token);
+                        await this._proxy.$invokeChatSessionRequestHandler(this._providerHandle, this.sessionResource, request, history, token);
                         if (!this._isCompleteObservable.get() && !this.interruptActiveResponseCallback) {
                             this._markComplete();
                         }
@@ -148,7 +160,7 @@ class ObservableChatSession extends Disposable {
             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._logService.debug(`Processing ${chunks.length} pending progress chunks for session ${this.sessionResource}, requestId ${requestId}`);
                 this._addProgress(chunks);
             }
             this._pendingProgressChunks.clear();
@@ -157,7 +169,7 @@ class ObservableChatSession extends Disposable {
             }
         }
         catch (error) {
-            this._logService.error(`Failed to initialize chat session ${this.sessionId}:`, error);
+            this._logService.error(`Failed to initialize chat session ${this.sessionResource}:`, error);
             throw error;
         }
     }
@@ -165,7 +177,7 @@ class ObservableChatSession extends Disposable {
         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)`);
+            this._logService.debug(`Queuing ${progress.length} progress chunks for session ${this.sessionResource}, requestId ${requestId} (session not initialized)`);
             return;
         }
         this._addProgress(progress);
@@ -198,13 +210,13 @@ class ObservableChatSession extends Disposable {
             this._disposalPending = true;
         }
         else {
-            this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionId);
+            this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionResource);
         }
         super.dispose();
     }
 }
 let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
-    constructor(_extHostContext, _chatSessionsService, _dialogService, _editorService, editorGroupService, _logService, _viewsService) {
+    constructor(_extHostContext, _chatSessionsService, _dialogService, _editorService, editorGroupService, _logService) {
         super();
         this._extHostContext = _extHostContext;
         this._chatSessionsService = _chatSessionsService;
@@ -212,12 +224,21 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._editorService = _editorService;
         this.editorGroupService = editorGroupService;
         this._logService = _logService;
-        this._viewsService = _viewsService;
         this._itemProvidersRegistrations = this._register(( new DisposableMap()));
         this._contentProvidersRegistrations = this._register(( new DisposableMap()));
-        this._activeSessions = ( new Map());
-        this._sessionDisposables = ( new Map());
+        this._sessionTypeToHandle = ( new Map());
+        this._activeSessions = ( new ResourceMap());
+        this._sessionDisposables = ( new ResourceMap());
         this._proxy = ( this._extHostContext.getProxy(ExtHostContext.ExtHostChatSessions));
+        this._chatSessionsService.setOptionsChangeCallback(async (sessionResource, updates) => {
+            const handle = this._getHandleForSessionType(sessionResource.scheme);
+            if (handle !== undefined) {
+                await this.notifyOptionsChange(handle, sessionResource, updates);
+            }
+        });
+    }
+    _getHandleForSessionType(chatSessionType) {
+        return this._sessionTypeToHandle.get(chatSessionType);
     }
     $registerChatSessionItemProvider(handle, chatSessionType) {
         const disposables = ( new DisposableStore());
@@ -238,36 +259,37 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     $onDidChangeChatSessionItems(handle) {
         this._itemProvidersRegistrations.get(handle)?.onDidChangeItems.fire();
     }
-    $onDidCommitChatSessionItem(handle, original, modified) {
-        this._logService.trace(`$onDidCommitChatSessionItem: handle(${handle}), original(${original}), modified(${modified})`);
+    async $onDidCommitChatSessionItem(handle, originalComponents, modifiedCompoennts) {
+        const originalResource = URI.revive(originalComponents);
+        const modifiedResource = URI.revive(modifiedCompoennts);
+        this._logService.trace(`$onDidCommitChatSessionItem: handle(${handle}), original(${originalResource}), modified(${modifiedResource})`);
         const chatSessionType = this._itemProvidersRegistrations.get(handle)?.provider.chatSessionType;
         if (!chatSessionType) {
             this._logService.error(`No chat session type found for provider handle ${handle}`);
             return;
         }
-        const originalResource = ChatSessionUri.forSession(chatSessionType, original);
-        const modifiedResource = ChatSessionUri.forSession(chatSessionType, modified);
         const originalEditor = this._editorService.editors.find(editor => editor.resource?.toString() === ( originalResource.toString()));
-        let originalGroup;
-        for (const group of this.editorGroupService.groups) {
-            if (( group.editors.some(editor => editor.resource?.toString() === ( originalResource.toString())))) {
-                originalGroup = group;
-                break;
+        const contribution = this._chatSessionsService.getAllChatSessionContributions().find(c => c.type === chatSessionType);
+        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(2467, "{0}", contribution?.displayName)),
             }
-        }
-        if (!originalGroup) {
-            originalGroup = this.editorGroupService.activeGroup;
-        }
+        };
         if (originalEditor) {
-            this._chatSessionsService.provideChatSessionContent(chatSessionType, modified, CancellationToken.None).then(() => {
-                this._editorService.replaceEditors([{
-                        editor: originalEditor,
-                        replacement: {
-                            resource: modifiedResource,
-                            options: {}
-                        },
-                    }], originalGroup);
-            });
+            const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
+            newSession.initialEditingSession = originalEditor instanceof ChatEditorInput
+                ? originalEditor.transferOutEditingSession()
+                : undefined;
+            this._editorService.replaceEditors([{
+                    editor: originalEditor,
+                    replacement: {
+                        resource: modifiedResource,
+                        options,
+                    },
+                }], originalGroup);
         }
         else {
             this._logService.warn(`Original chat session editor not found for resource ${( originalResource.toString())}`);
@@ -280,6 +302,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             return ( sessions.map(session => ({
                 ...session,
                 id: session.id,
+                resource: URI.revive(session.resource),
                 iconPath: session.iconPath,
                 tooltip: session.tooltip ? this._reviveTooltip(session.tooltip) : undefined
             })));
@@ -298,6 +321,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             return {
                 ...chatSessionItem,
                 id: chatSessionItem.id,
+                resource: URI.revive(chatSessionItem.resource),
                 iconPath: chatSessionItem.iconPath,
                 tooltip: chatSessionItem.tooltip ? this._reviveTooltip(chatSessionItem.tooltip) : undefined,
             };
@@ -307,40 +331,67 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             throw error;
         }
     }
-    async _provideChatSessionContent(providerHandle, id, token) {
-        const sessionKey = ObservableChatSession.generateSessionKey(providerHandle, id);
-        let session = this._activeSessions.get(sessionKey);
+    async _provideChatSessionContent(providerHandle, sessionResource, token) {
+        let session = this._activeSessions.get(sessionResource);
         if (!session) {
-            session = ( new ObservableChatSession(id, providerHandle, this._proxy, this._logService, this._dialogService));
-            this._activeSessions.set(sessionKey, session);
+            session = ( new ObservableChatSession(
+                sessionResource,
+                providerHandle,
+                this._proxy,
+                this._logService,
+                this._dialogService
+            ));
+            this._activeSessions.set(sessionResource, session);
             const disposable = session.onWillDispose(() => {
-                this._activeSessions.delete(sessionKey);
-                this._sessionDisposables.get(sessionKey)?.dispose();
-                this._sessionDisposables.delete(sessionKey);
+                this._activeSessions.delete(sessionResource);
+                this._sessionDisposables.get(sessionResource)?.dispose();
+                this._sessionDisposables.delete(sessionResource);
             });
-            this._sessionDisposables.set(sessionKey, disposable);
+            this._sessionDisposables.set(sessionResource, disposable);
         }
         try {
             await session.initialize(token);
+            if (session.options) {
+                for (const [_, handle] of this._sessionTypeToHandle) {
+                    if (handle === providerHandle) {
+                        for (const [optionId, value] of Object.entries(session.options)) {
+                            this._chatSessionsService.setSessionOption(sessionResource, optionId, value);
+                        }
+                        break;
+                    }
+                }
+            }
             return session;
         }
         catch (error) {
             session.dispose();
-            this._logService.error(`Error providing chat session content for handle ${providerHandle} and id ${id}:`, error);
+            this._logService.error(`Error providing chat session content for handle ${providerHandle} and resource ${( sessionResource.toString())}:`, error);
             throw error;
         }
     }
     $unregisterChatSessionItemProvider(handle) {
         this._itemProvidersRegistrations.deleteAndDispose(handle);
     }
-    $registerChatSessionContentProvider(handle, chatSessionType) {
+    $registerChatSessionContentProvider(handle, chatSessionScheme) {
         const provider = {
-            provideChatSessionContent: (id, token) => this._provideChatSessionContent(handle, id, token)
+            provideChatSessionContent: (resource, token) => this._provideChatSessionContent(handle, resource, token)
         };
-        this._contentProvidersRegistrations.set(handle, this._chatSessionsService.registerChatSessionContentProvider(chatSessionType, provider));
+        this._sessionTypeToHandle.set(chatSessionScheme, handle);
+        this._contentProvidersRegistrations.set(handle, this._chatSessionsService.registerChatSessionContentProvider(chatSessionScheme, provider));
+        this._proxy.$provideChatSessionProviderOptions(handle, CancellationToken.None).then(options => {
+            if (options?.optionGroups && options.optionGroups.length) {
+                this._chatSessionsService.setOptionGroupsForSessionType(chatSessionScheme, handle, options.optionGroups);
+            }
+        }).catch(err => this._logService.error('Error fetching chat session options', err));
     }
     $unregisterChatSessionContentProvider(handle) {
         this._contentProvidersRegistrations.deleteAndDispose(handle);
+        for (const [sessionType, h] of this._sessionTypeToHandle) {
+            if (h === handle) {
+                this._sessionTypeToHandle.delete(sessionType);
+                break;
+            }
+        }
         for (const [key, session] of this._activeSessions) {
             if (session.providerHandle === handle) {
                 session.dispose();
@@ -348,31 +399,29 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             }
         }
     }
-    async $handleProgressChunk(handle, sessionId, requestId, chunks) {
-        const sessionKey = ObservableChatSession.generateSessionKey(handle, sessionId);
-        const observableSession = this._activeSessions.get(sessionKey);
+    async $handleProgressChunk(handle, sessionResource, requestId, chunks) {
+        const resource = URI.revive(sessionResource);
+        const observableSession = this._activeSessions.get(resource);
+        if (!observableSession) {
+            this._logService.warn(`No session found for progress chunks: handle ${handle}, sessionResource ${resource}, requestId ${requestId}`);
+            return;
+        }
         const chatProgressParts = ( chunks.map(chunk => {
             const [progress] = Array.isArray(chunk) ? chunk : [chunk];
             return revive(progress);
         }));
-        if (observableSession) {
-            observableSession.handleProgressChunk(requestId, chatProgressParts);
-        }
-        else {
-            this._logService.warn(`No session found for progress chunks: handle ${handle}, sessionId ${sessionId}, requestId ${requestId}`);
-        }
+        observableSession.handleProgressChunk(requestId, chatProgressParts);
     }
-    $handleProgressComplete(handle, sessionId, requestId) {
-        const sessionKey = ObservableChatSession.generateSessionKey(handle, sessionId);
-        const observableSession = this._activeSessions.get(sessionKey);
-        if (observableSession) {
-            observableSession.handleProgressComplete(requestId);
-        }
-        else {
-            this._logService.warn(`No session found for progress completion: handle ${handle}, sessionId ${sessionId}, requestId ${requestId}`);
+    $handleProgressComplete(handle, sessionResource, requestId) {
+        const resource = URI.revive(sessionResource);
+        const observableSession = this._activeSessions.get(resource);
+        if (!observableSession) {
+            this._logService.warn(`No session found for progress completion: handle ${handle}, sessionResource ${resource}, requestId ${requestId}`);
+            return;
         }
+        observableSession.handleProgressComplete(requestId);
     }
-    $handleAnchorResolve(handle, sessionId, requestId, requestHandle, anchor) {
+    $handleAnchorResolve(handle, sesssionResource, requestId, requestHandle, anchor) {
     }
     dispose() {
         for (const session of ( this._activeSessions.values())) {
@@ -397,17 +446,12 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         }
         return undefined;
     }
-    async $showChatSession(chatSessionType, sessionId, position) {
-        const sessionUri = ChatSessionUri.forSession(chatSessionType, sessionId);
-        if (typeof position === 'undefined') {
-            const chatPanel = await this._viewsService.openView(ChatViewId);
-            await chatPanel?.loadSession(sessionUri);
+    async notifyOptionsChange(handle, sessionResource, updates) {
+        try {
+            await this._proxy.$provideHandleOptionsChange(handle, sessionResource, updates, CancellationToken.None);
         }
-        else {
-            await this._editorService.openEditor({
-                resource: sessionUri,
-                options: { pinned: true },
-            }, position);
+        catch (error) {
+            this._logService.error(`Error notifying extension about options change for handle ${handle}, sessionResource ${sessionResource}:`, error);
         }
     }
 };
@@ -417,8 +461,7 @@ MainThreadChatSessions = __decorate([
     ( __param(2, IDialogService)),
     ( __param(3, IEditorService)),
     ( __param(4, IEditorGroupsService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IViewsService))
+    ( __param(5, ILogService))
 ], MainThreadChatSessions);
 
 export { MainThreadChatSessions, ObservableChatSession };

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

@@ -1,10 +1,11 @@
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { MainThreadClipboardShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IClipboardService } from "@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 export declare class MainThreadClipboard implements MainThreadClipboardShape {
     private readonly _clipboardService;
     private readonly _logService;
-    constructor(_context: any, _clipboardService: IClipboardService, _logService: ILogService);
+    constructor(_context: IExtHostContext, _clipboardService: IClipboardService, _logService: ILogService);
     dispose(): void;
     $readText(): Promise<string>;
     $writeText(value: string): Promise<void>;

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

@@ -16,6 +16,6 @@ export declare class MainThreadEditorInsets implements MainThreadEditorInsetsSha
     $disposeEditorInset(handle: number): void;
     $setHtml(handle: number, value: string): void;
     $setOptions(handle: number, options: IWebviewContentOptions): void;
-    $postMessage(handle: number, value: any): Promise<boolean>;
+    $postMessage(handle: number, value: unknown): Promise<boolean>;
     private getInset;
 }

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

@@ -15,6 +15,6 @@ export declare class MainThreadCommands implements MainThreadCommandsShape {
     $registerCommand(id: string): void;
     $unregisterCommand(id: string): void;
     $fireCommandActivationEvent(id: string): void;
-    $executeCommand<T>(id: string, args: any[] | SerializableObjectWithBuffers<any[]>, retry: boolean): Promise<T | undefined>;
+    $executeCommand<T>(id: string, args: unknown[] | SerializableObjectWithBuffers<unknown[]>, retry: boolean): Promise<T | undefined>;
     $getCommands(): Promise<string[]>;
 }

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

@@ -10,7 +10,8 @@ import { ICommentController } from "@codingame/monaco-vscode-comments-service-ov
 import { ICommentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/comments/browser/commentService.service";
 import { CommentProviderFeatures, ExtHostCommentsShape, MainThreadCommentsShape, CommentThreadChanges } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
-import { ICellRange } from "@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
+import { MarshalledId } from "@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds";
+import { ICellRange } from "@codingame/monaco-vscode-9d2c06d1-1f89-51a5-9964-aa01fe50c198-common/vscode/vs/workbench/contrib/notebook/common/notebookRange";
 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";
@@ -137,7 +138,10 @@ export declare class MainThreadCommentController extends Disposable implements I
     getAllComments(): MainThreadCommentThread<IRange | ICellRange>[];
     createCommentThreadTemplate(resource: UriComponents, range: IRange | undefined, editorId?: string): Promise<void>;
     updateCommentThreadTemplate(threadHandle: number, range: IRange): Promise<void>;
-    toJSON(): any;
+    toJSON(): {
+        $mid: MarshalledId;
+        handle: number;
+    };
 }
 export declare class MainThreadComments extends Disposable implements MainThreadCommentsShape {
     private readonly _commentService;

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

@@ -424,7 +424,7 @@ class MainThreadCommentController extends Disposable {
         };
     }
 }
-const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2456, 'View icon of the comments view.')));
+const commentsViewIcon = registerIcon('comments-view-icon', Codicon.commentDiscussion, ( localize(2468, '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

@@ -25,16 +25,16 @@ import { ExtHostContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { CustomEditorInput } from '@codingame/monaco-vscode-7f39b6f1-3542-5430-8760-0f404d7a7cee-common/vscode/vs/workbench/contrib/customEditor/browser/customEditorInput';
 import { ICustomEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/customEditor/common/customEditor.service';
 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 { ExtensionKeyedWebviewOriginStore } from '@codingame/monaco-vscode-2a04f0cd-b806-5886-909e-418183d32279-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-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-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-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 { ResourceWorkingCopy } from '@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/services/workingCopy/common/resourceWorkingCopy';
+import { NO_TYPE_ID, WorkingCopyCapabilities } from '@codingame/monaco-vscode-d392702e-4ad7-5904-a915-f6063284cf14-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';
 import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.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(
-                    2457,
+                    2469,
                     "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(2458, "Edit")),
+            label: label ?? ( localize(2470, "Edit")),
             code: 'undoredo.customEditorEdit',
             undo: () => this.undo(),
             redo: () => this.redo(),
@@ -513,6 +513,8 @@ let MainThreadCustomEditorModel = MainThreadCustomEditorModel_1 = class MainThre
         const backupMeta = {
             viewType: this.viewType,
             editorResource: this._editorResource,
+            customTitle: primaryEditor.getWebviewTitle(),
+            iconPath: primaryEditor.iconPath,
             backupId: '',
             extension: primaryEditor.extension ? {
                 id: primaryEditor.extension.id.value,

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

@@ -37,7 +37,7 @@ export declare class MainThreadDebugService implements MainThreadDebugServiceSha
     private getSession;
     $startDebugging(folder: UriComponents | undefined, nameOrConfig: string | IDebugConfiguration, options: IStartDebuggingOptions): Promise<boolean>;
     $setDebugSessionName(sessionId: DebugSessionUUID, name: string): void;
-    $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: any): Promise<any>;
+    $customDebugAdapterRequest(sessionId: DebugSessionUUID, request: string, args: unknown): Promise<unknown>;
     $getDebugProtocolBreakpoint(sessionId: DebugSessionUUID, breakpoinId: string): Promise<DebugProtocol.Breakpoint | undefined>;
     $stopDebugging(sessionId: DebugSessionUUID | undefined): Promise<void>;
     $appendDebugConsole(value: string): void;

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

@@ -25,7 +25,7 @@ export declare class BoundModelReferenceCollection {
     _maxSize?: number);
     dispose(): void;
     remove(uri: URI): void;
-    add(uri: URI, ref: IReference<any>, length?: number): void;
+    add(uri: URI, ref: IReference<unknown>, length?: number): void;
     private _cleanup;
 }
 export declare class MainThreadDocuments extends Disposable implements MainThreadDocumentsShape {

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-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-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(2459, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2471, "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-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-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";