@codingame/monaco-vscode-extensions-service-override 26.2.2 → 27.0.0

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

@@ -0,0 +1,15 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IChatDebugEventDto, MainThreadChatDebugShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadChatDebug extends Disposable implements MainThreadChatDebugShape {
+    private readonly _chatDebugService;
+    private readonly _proxy;
+    private readonly _providerDisposables;
+    private readonly _activeSessionResources;
+    constructor(extHostContext: IExtHostContext, _chatDebugService: IChatDebugService);
+    $registerChatDebugLogProvider(handle: number): void;
+    $unregisterChatDebugLogProvider(handle: number): void;
+    $acceptChatDebugEvent(handle: number, dto: IChatDebugEventDto): void;
+    private _reviveEvent;
+}

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

@@ -0,0 +1,114 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IChatDebugService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+let MainThreadChatDebug = class MainThreadChatDebug extends Disposable {
+    constructor(extHostContext, _chatDebugService) {
+        super();
+        this._chatDebugService = _chatDebugService;
+        this._providerDisposables = ( new Map());
+        this._activeSessionResources = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatDebug));
+    }
+    $registerChatDebugLogProvider(handle) {
+        const disposables = ( new DisposableStore());
+        this._providerDisposables.set(handle, disposables);
+        disposables.add(this._chatDebugService.registerProvider({
+            provideChatDebugLog: async (sessionResource, token) => {
+                this._activeSessionResources.set(handle, sessionResource);
+                const dtos = await this._proxy.$provideChatDebugLog(handle, sessionResource, token);
+                return dtos?.map(dto => this._reviveEvent(dto, sessionResource));
+            },
+            resolveChatDebugLogEvent: async (eventId, token) => {
+                return this._proxy.$resolveChatDebugLogEvent(handle, eventId, token);
+            }
+        }));
+    }
+    $unregisterChatDebugLogProvider(handle) {
+        const disposables = this._providerDisposables.get(handle);
+        disposables?.dispose();
+        this._providerDisposables.delete(handle);
+        this._activeSessionResources.delete(handle);
+    }
+    $acceptChatDebugEvent(handle, dto) {
+        const sessionResource = (dto.sessionResource ? URI.revive(dto.sessionResource) : undefined) ?? this._activeSessionResources.get(handle) ?? this._chatDebugService.activeSessionResource;
+        if (!sessionResource) {
+            return;
+        }
+        const revived = this._reviveEvent(dto, sessionResource);
+        this._chatDebugService.addProviderEvent(revived);
+    }
+    _reviveEvent(dto, sessionResource) {
+        const base = {
+            id: dto.id,
+            sessionResource,
+            created: ( new Date(dto.created)),
+            parentEventId: dto.parentEventId
+        };
+        switch (dto.kind) {
+        case "toolCall":
+            return {
+                ...base,
+                kind: "toolCall",
+                toolName: dto.toolName,
+                toolCallId: dto.toolCallId,
+                input: dto.input,
+                output: dto.output,
+                result: dto.result,
+                durationInMillis: dto.durationInMillis
+            };
+        case "modelTurn":
+            return {
+                ...base,
+                kind: "modelTurn",
+                model: dto.model,
+                requestName: dto.requestName,
+                inputTokens: dto.inputTokens,
+                outputTokens: dto.outputTokens,
+                totalTokens: dto.totalTokens,
+                durationInMillis: dto.durationInMillis
+            };
+        case "generic":
+            return {
+                ...base,
+                kind: "generic",
+                name: dto.name,
+                details: dto.details,
+                level: dto.level,
+                category: dto.category
+            };
+        case "subagentInvocation":
+            return {
+                ...base,
+                kind: "subagentInvocation",
+                agentName: dto.agentName,
+                description: dto.description,
+                status: dto.status,
+                durationInMillis: dto.durationInMillis,
+                toolCallCount: dto.toolCallCount,
+                modelTurnCount: dto.modelTurnCount
+            };
+        case "userMessage":
+            return {
+                ...base,
+                kind: "userMessage",
+                message: dto.message,
+                sections: dto.sections
+            };
+        case "agentResponse":
+            return {
+                ...base,
+                kind: "agentResponse",
+                message: dto.message,
+                sections: dto.sections
+            };
+        }
+    }
+};
+MainThreadChatDebug = __decorate([extHostNamedCustomer(MainContext.MainThreadChatDebug), ( __param(1, IChatDebugService))], MainThreadChatDebug);
+
+export { MainThreadChatDebug };

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

@@ -1,5 +1,4 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI, UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
@@ -9,24 +8,26 @@ import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/wo
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
 import { IChatContentInlineReference, IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
-import { IChatSession, IChatSessionHistoryItem, IChatSessionProviderOptionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSession, IChatSessionHistoryItem, IChatSessionItem, IChatSessionProviderOptionItem } 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 { IChatAgentRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
+import { IChatTodoListService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { Dto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
-import { ExtHostChatSessionsShape, IChatProgressDto, MainThreadChatSessionsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { ExtHostChatSessionsShape, IChatProgressDto, IChatSessionItemsChange, MainThreadChatSessionsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 export declare class ObservableChatSession extends Disposable implements IChatSession {
     readonly sessionResource: URI;
     readonly providerHandle: number;
     readonly history: Array<IChatSessionHistoryItem>;
+    title?: string;
     private _options?;
     get options(): Record<string, string | IChatSessionProviderOptionItem> | undefined;
     private readonly _progressObservable;
     private readonly _isCompleteObservable;
     private readonly _onWillDispose;
-    readonly onWillDispose: Event<void>;
+    readonly onWillDispose: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
     private readonly _pendingProgressChunks;
     private _isInitialized;
     private _interruptionWasCanceled;
@@ -62,29 +63,33 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     private readonly _chatSessionsService;
     private readonly _chatService;
     private readonly _chatWidgetService;
+    private readonly _chatTodoListService;
     private readonly _dialogService;
     private readonly _editorService;
     private readonly editorGroupService;
     private readonly _logService;
-    private readonly _itemProvidersRegistrations;
+    private readonly _itemControllerRegistrations;
     private readonly _contentProvidersRegistrations;
     private readonly _sessionTypeToHandle;
     private readonly _activeSessions;
     private readonly _sessionDisposables;
     private readonly _proxy;
-    constructor(_extHostContext: IExtHostContext, _agentSessionsService: IAgentSessionsService, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService);
+    constructor(_extHostContext: IExtHostContext, _agentSessionsService: IAgentSessionsService, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _chatTodoListService: IChatTodoListService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService);
     private _getHandleForSessionType;
-    $registerChatSessionItemProvider(handle: number, chatSessionType: string): void;
+    $registerChatSessionItemController(handle: number, chatSessionType: string): void;
+    private getController;
     $onDidChangeChatSessionItems(handle: number): void;
+    private _resolveSessionItem;
+    $updateChatSessionItems(controllerHandle: number, change: IChatSessionItemsChange): Promise<void>;
+    $addOrUpdateChatSessionItem(controllerHandle: number, item: Dto<IChatSessionItem>): Promise<void>;
     $onDidChangeChatSessionOptions(handle: number, sessionResourceComponents: UriComponents, updates: ReadonlyArray<{
         optionId: string;
         value: string;
     }>): void;
     $onDidCommitChatSessionItem(handle: number, originalComponents: UriComponents, modifiedCompoennts: UriComponents): Promise<void>;
-    private _provideChatSessionItems;
     private handleSessionModelOverrides;
     private _provideChatSessionContent;
-    $unregisterChatSessionItemProvider(handle: number): void;
+    $unregisterChatSessionItemController(handle: number): void;
     $registerChatSessionContentProvider(handle: number, chatSessionScheme: string): void;
     $unregisterChatSessionContentProvider(handle: number): void;
     $handleProgressChunk(handle: number, sessionResource: UriComponents, requestId: string, chunks: (IChatProgressDto | [

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

@@ -2,7 +2,7 @@
 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 { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+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';
@@ -15,7 +15,7 @@ import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { hasValidDiff } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
 import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
-import { isIChatViewViewContext, ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { isIChatViewViewContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
 import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
@@ -24,6 +24,7 @@ import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IChatTodoListService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
@@ -72,6 +73,7 @@ class ObservableChatSession extends Disposable {
                 token
             );
             this._options = sessionContent.options;
+            this.title = sessionContent.title;
             this.history.length = 0;
             this.history.push(...( sessionContent.history.map(turn => {
                 if (turn.type === "request") {
@@ -90,7 +92,8 @@ class ObservableChatSession extends Disposable {
                         variableData: variables ? {
                             variables
                         } : undefined,
-                        id: turn.id
+                        id: turn.id,
+                        modelId: turn.modelId
                     };
                 }
                 return {
@@ -113,7 +116,7 @@ class ObservableChatSession extends Disposable {
                         return confirmInterrupt();
                     }
                     return this._dialogService.confirm({
-                        message: ( localize(2501, "Are you sure you want to interrupt the active session?"))
+                        message: ( localize(2541, "Are you sure you want to interrupt the active session?"))
                     }).then(confirmed => {
                         if (confirmed.confirmed) {
                             return confirmInterrupt();
@@ -236,6 +239,52 @@ class ObservableChatSession extends Disposable {
         super.dispose();
     }
 }
+class MainThreadChatSessionItemController extends Disposable {
+    constructor(proxy, handle) {
+        super();
+        this._onDidChangeChatSessionItems = this._register(( new Emitter()));
+        this.onDidChangeChatSessionItems = this._onDidChangeChatSessionItems.event;
+        this._items = ( new ResourceMap());
+        this._proxy = proxy;
+        this._handle = handle;
+    }
+    get items() {
+        return Array.from(( this._items.values()));
+    }
+    refresh(token) {
+        return this._proxy.$refreshChatSessionItems(this._handle, token);
+    }
+    async newChatSessionItem(request, token) {
+        const dto = await raceCancellationError(this._proxy.$newChatSessionItem(this._handle, request, token), token);
+        if (!dto) {
+            return undefined;
+        }
+        const item = {
+            ...dto,
+            resource: URI.revive(dto.resource),
+            changes: revive(dto.changes)
+        };
+        this._items.set(item.resource, item);
+        this._onDidChangeChatSessionItems.fire();
+        return item;
+    }
+    acceptChange(change) {
+        for (const item of change.addedOrUpdated) {
+            this._items.set(item.resource, item);
+        }
+        for (const uri of change.removed) {
+            this._items.delete(uri);
+        }
+        this._onDidChangeChatSessionItems.fire();
+    }
+    addOrUpdateItem(item) {
+        this._items.set(item.resource, item);
+        this._onDidChangeChatSessionItems.fire();
+    }
+    fireOnDidChangeChatSessionItems() {
+        this._onDidChangeChatSessionItems.fire();
+    }
+}
 let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     constructor(
         _extHostContext,
@@ -243,6 +292,7 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         _chatSessionsService,
         _chatService,
         _chatWidgetService,
+        _chatTodoListService,
         _dialogService,
         _editorService,
         editorGroupService,
@@ -254,11 +304,12 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._chatSessionsService = _chatSessionsService;
         this._chatService = _chatService;
         this._chatWidgetService = _chatWidgetService;
+        this._chatTodoListService = _chatTodoListService;
         this._dialogService = _dialogService;
         this._editorService = _editorService;
         this.editorGroupService = editorGroupService;
         this._logService = _logService;
-        this._itemProvidersRegistrations = this._register(( new DisposableMap()));
+        this._itemControllerRegistrations = this._register(( new DisposableMap()));
         this._contentProvidersRegistrations = this._register(( new DisposableMap()));
         this._sessionTypeToHandle = ( new Map());
         this._activeSessions = ( new ResourceMap());
@@ -286,9 +337,9 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._register(
             this._agentSessionsService.model.onDidChangeSessionArchivedState(session => {
                 for (const [handle, {
-                    provider
-                }] of this._itemProvidersRegistrations) {
-                    if (provider.chatSessionType === session.providerType) {
+                    chatSessionType
+                }] of this._itemControllerRegistrations) {
+                    if (chatSessionType === session.providerType) {
                         this._proxy.$onDidChangeChatSessionItemState(handle, session.resource, session.isArchived());
                     }
                 }
@@ -298,26 +349,72 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     _getHandleForSessionType(chatSessionType) {
         return this._sessionTypeToHandle.get(chatSessionType);
     }
-    $registerChatSessionItemProvider(handle, chatSessionType) {
+    $registerChatSessionItemController(handle, chatSessionType) {
         const disposables = ( new DisposableStore());
-        const changeEmitter = disposables.add(( new Emitter()));
-        const provider = {
-            chatSessionType,
-            onDidChangeChatSessionItems: Event.debounce(changeEmitter.event, (_, e) => e, 200),
-            provideChatSessionItems: token => this._provideChatSessionItems(handle, token)
-        };
-        disposables.add(this._chatSessionsService.registerChatSessionItemProvider(provider));
-        this._itemProvidersRegistrations.set(handle, {
-            dispose: () => disposables.dispose(),
-            provider,
-            onDidChangeItems: changeEmitter
-        });
+        const controller = disposables.add(( new MainThreadChatSessionItemController(this._proxy, handle)));
         disposables.add(
-            this._chatSessionsService.registerChatModelChangeListeners(this._chatService, chatSessionType, () => changeEmitter.fire())
+            this._chatSessionsService.registerChatSessionItemController(chatSessionType, controller)
         );
+        this._itemControllerRegistrations.set(handle, {
+            chatSessionType,
+            controller,
+            dispose: () => disposables.dispose()
+        });
+        disposables.add(this._chatSessionsService.registerChatModelChangeListeners(
+            this._chatService,
+            chatSessionType,
+            () => controller.fireOnDidChangeChatSessionItems()
+        ));
+    }
+    getController(handle) {
+        const registration = this._itemControllerRegistrations.get(handle);
+        if (!registration) {
+            throw ( new Error(`No chat session controller registered for handle ${handle}`));
+        }
+        return registration.controller;
     }
     $onDidChangeChatSessionItems(handle) {
-        this._itemProvidersRegistrations.get(handle)?.onDidChangeItems.fire();
+        const controller = this.getController(handle);
+        controller.fireOnDidChangeChatSessionItems();
+    }
+    async _resolveSessionItem(item) {
+        const uri = URI.revive(item.resource);
+        const model = this._chatService.getSession(uri);
+        if (model) {
+            item = await this.handleSessionModelOverrides(model, item);
+        }
+        if (!item.changes || !model) {
+            const stats = (await this._chatService.getMetadataForSession(uri))?.stats;
+            const diffs = {
+                files: stats?.fileCount || 0,
+                insertions: stats?.added || 0,
+                deletions: stats?.removed || 0
+            };
+            if (hasValidDiff(diffs)) {
+                item.changes = diffs;
+            }
+        }
+        return {
+            ...item,
+            changes: revive(item.changes),
+            resource: uri,
+            iconPath: item.iconPath,
+            tooltip: item.tooltip ? this._reviveTooltip(item.tooltip) : undefined,
+            archived: item.archived
+        };
+    }
+    async $updateChatSessionItems(controllerHandle, change) {
+        const controller = this.getController(controllerHandle);
+        const resolvedItems = await Promise.all(( change.addedOrUpdated.map(item => this._resolveSessionItem(item))));
+        controller.acceptChange({
+            addedOrUpdated: resolvedItems,
+            removed: ( change.removed.map(uri => URI.revive(uri)))
+        });
+    }
+    async $addOrUpdateChatSessionItem(controllerHandle, item) {
+        const controller = this.getController(controllerHandle);
+        const resolvedItem = await this._resolveSessionItem(item);
+        controller.addOrUpdateItem(resolvedItem);
     }
     $onDidChangeChatSessionOptions(handle, sessionResourceComponents, updates) {
         const sessionResource = URI.revive(sessionResourceComponents);
@@ -329,27 +426,28 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._logService.trace(
             `$onDidCommitChatSessionItem: handle(${handle}), original(${originalResource}), modified(${modifiedResource})`
         );
-        const chatSessionType = this._itemProvidersRegistrations.get(handle)?.provider.chatSessionType;
+        const chatSessionType = this._itemControllerRegistrations.get(handle)?.chatSessionType;
         if (!chatSessionType) {
             this._logService.error(`No chat session type found for provider handle ${handle}`);
             return;
         }
         const originalEditor = this._editorService.editors.find(editor => editor.resource?.toString() === ( originalResource.toString()));
-        const originalModel = this._chatService.getActiveSessionReference(originalResource);
+        const originalModel = this._chatService.acquireExistingSession(originalResource);
         const contribution = this._chatSessionsService.getAllChatSessionContributions().find(c => c.type === chatSessionType);
         try {
+            this._chatTodoListService.migrateTodos(originalResource, modifiedResource);
             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(2502, "{0}", contribution?.displayName))
+                    fallback: ( localize(2542, "{0}", contribution?.displayName))
                 }
             };
             const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
             if (originalEditor) {
                 newSession.transferredState = originalEditor instanceof ChatEditorInput ? {
                     editingSession: originalEditor.transferOutEditingSession(),
-                    inputState: originalModel?.object.inputModel.toJSON()
+                    inputState: originalModel?.object?.inputModel.toJSON()
                 } : undefined;
                 await this._editorService.replaceEditors([{
                     editor: originalEditor,
@@ -368,51 +466,17 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             }
             const chatViewWidget = this._chatWidgetService.getWidgetBySessionResource(originalResource);
             if (chatViewWidget && isIChatViewViewContext(chatViewWidget.viewContext)) {
-                await this._chatWidgetService.openSession(modifiedResource, ChatViewPaneTarget, {
+                await this._chatWidgetService.openSession(modifiedResource, undefined, {
                     preserveFocus: true
                 });
             } else {
-                const ref = await this._chatService.loadSessionForResource(modifiedResource, ChatAgentLocation.Chat, CancellationToken.None);
+                const ref = await this._chatService.acquireOrLoadSession(modifiedResource, ChatAgentLocation.Chat, CancellationToken.None);
                 ref?.dispose();
             }
         } finally {
             originalModel?.dispose();
         }
     }
-    async _provideChatSessionItems(handle, token) {
-        try {
-            const sessions = await this._proxy.$provideChatSessionItems(handle, token);
-            return Promise.all(( sessions.map(async session => {
-                const uri = URI.revive(session.resource);
-                const model = this._chatService.getSession(uri);
-                if (model) {
-                    session = await this.handleSessionModelOverrides(model, session);
-                }
-                if (!session.changes || !model) {
-                    const stats = (await this._chatService.getMetadataForSession(uri))?.stats;
-                    const diffs = {
-                        files: stats?.fileCount || 0,
-                        insertions: stats?.added || 0,
-                        deletions: stats?.removed || 0
-                    };
-                    if (hasValidDiff(diffs)) {
-                        session.changes = diffs;
-                    }
-                }
-                return {
-                    ...session,
-                    changes: revive(session.changes),
-                    resource: uri,
-                    iconPath: session.iconPath,
-                    tooltip: session.tooltip ? this._reviveTooltip(session.tooltip) : undefined,
-                    archived: session.archived
-                };
-            })));
-        } catch (error) {
-            this._logService.error("Error providing chat sessions:", error);
-        }
-        return [];
-    }
     async handleSessionModelOverrides(model, session) {
         const inProgress = model.getRequests().filter(r => r.response && !r.response.isComplete);
         if (inProgress.length) {
@@ -473,8 +537,8 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             throw error;
         }
     }
-    $unregisterChatSessionItemProvider(handle) {
-        this._itemProvidersRegistrations.deleteAndDispose(handle);
+    $unregisterChatSessionItemController(handle) {
+        this._itemControllerRegistrations.deleteAndDispose(handle);
     }
     $registerChatSessionContentProvider(handle, chatSessionScheme) {
         const provider = {
@@ -556,6 +620,9 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 })));
                 this._chatSessionsService.setOptionGroupsForSessionType(chatSessionScheme, handle, groupsWithCallbacks);
             }
+            if (options?.newSessionOptions) {
+                this._chatSessionsService.setNewSessionOptionsForSessionType(chatSessionScheme, options.newSessionOptions);
+            }
         }).catch(err => this._logService.error("Error fetching chat session options", err));
     }
     dispose() {
@@ -598,6 +665,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, IDialogService)), ( __param(6, IEditorService)), ( __param(7, IEditorGroupsService)), ( __param(8, ILogService))], MainThreadChatSessions);
+MainThreadChatSessions = __decorate([extHostNamedCustomer(MainContext.MainThreadChatSessions), ( __param(1, IAgentSessionsService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetService)), ( __param(5, IChatTodoListService)), ( __param(6, IDialogService)), ( __param(7, IEditorService)), ( __param(8, IEditorGroupsService)), ( __param(9, ILogService))], MainThreadChatSessions);
 
 export { MainThreadChatSessions, ObservableChatSession };

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

@@ -195,10 +195,13 @@ class MainThreadCommentThread {
     dispose() {
         this._isDisposed = true;
         this._onDidChangeCollapsibleState.dispose();
+        this._onDidChangeInitialCollapsibleState.dispose();
         this._onDidChangeComments.dispose();
         this._onDidChangeInput.dispose();
         this._onDidChangeLabel.dispose();
+        this._onDidChangeCanReply.dispose();
         this._onDidChangeState.dispose();
+        this._onDidChangeApplicability.dispose();
     }
     toJSON() {
         return {
@@ -453,7 +456,7 @@ class MainThreadCommentController extends Disposable {
         };
     }
 }
-const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2503, "View icon of the comments view.")));
+const commentsViewIcon = registerIcon("comments-view-icon", Codicon.commentDiscussion, ( localize(2543, "View icon of the comments view.")));
 let MainThreadComments = class MainThreadComments extends Disposable {
     constructor(
         extHostContext,

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

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

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(2506, "Aborted onWillCreateEditSessionIdentity-event after 10000ms"))))), this.timeout);
+            setTimeout(() => reject(( new Error(( localize(2546, "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/mainThreadEditor.js

@@ -142,6 +142,7 @@ class MainThreadTextEditor {
     }
     dispose() {
         this._modelListeners.dispose();
+        this._onPropertiesChanged.dispose();
         this._codeEditor = null;
         this._codeEditorListeners.dispose();
     }