@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingOperations.js

@@ -3,7 +3,7 @@ import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/h
 import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 
 var FileOperationType;
-(function (FileOperationType) {
+(function(FileOperationType) {
     FileOperationType["Create"] = "create";
     FileOperationType["Delete"] = "delete";
     FileOperationType["Rename"] = "rename";

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingServiceImpl.d.ts

@@ -1,5 +1,4 @@
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
@@ -17,7 +16,7 @@ import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbe
 import { IMultiDiffSourceResolver, IResolvedMultiDiffSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService";
 import { IMultiDiffSourceResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service";
 import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
-import { IChatEditingSession, IChatRelatedFile, IChatRelatedFilesProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
+import { IChatEditingSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
 import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service";
 import { ChatModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
@@ -32,7 +31,6 @@ export declare class ChatEditingService extends Disposable implements IChatEditi
     _serviceBrand: undefined;
     private readonly _sessionsObs;
     readonly editingSessionsObs: IObservable<readonly IChatEditingSession[]>;
-    private _chatRelatedFilesProviders;
     constructor(_instantiationService: IInstantiationService, multiDiffSourceResolverService: IMultiDiffSourceResolverService, textModelService: ITextModelService, contextKeyService: IContextKeyService, _chatService: IChatService, _editorService: IEditorService, decorationsService: IDecorationsService, _fileService: IFileService, lifecycleService: ILifecycleService, storageService: IStorageService, logService: ILogService, extensionService: IExtensionService, productService: IProductService, notebookService: INotebookService, _configurationService: IConfigurationService);
     dispose(): void;
     startOrContinueGlobalEditingSession(chatModel: ChatModel): IChatEditingSession;
@@ -43,12 +41,6 @@ export declare class ChatEditingService extends Disposable implements IChatEditi
     private _createEditingSession;
     private installAutoApplyObserver;
     private observerEditsInResponse;
-    hasRelatedFilesProviders(): boolean;
-    registerRelatedFilesProvider(handle: number, provider: IChatRelatedFilesProvider): IDisposable;
-    getRelatedFiles(chatSessionResource: URI, prompt: string, files: URI[], token: CancellationToken): Promise<{
-        group: string;
-        files: IChatRelatedFile[];
-    }[] | undefined>;
 }
 export declare class ChatEditingMultiDiffSourceResolver implements IMultiDiffSourceResolver {
     private readonly _editingSessionsObs;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingServiceImpl.js

@@ -1,12 +1,12 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { coalesce, delta, compareBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { delta, compareBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { groupBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
 import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Disposable, dispose, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, dispose, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { LinkedList } from '@codingame/monaco-vscode-api/vscode/vs/base/common/linkedList';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
@@ -46,7 +46,23 @@ import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { ValueWithChangeEventFromObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/valueWithChangeEvent';
 
 let ChatEditingService = class ChatEditingService extends Disposable {
-    constructor(_instantiationService, multiDiffSourceResolverService, textModelService, contextKeyService, _chatService, _editorService, decorationsService, _fileService, lifecycleService, storageService, logService, extensionService, productService, notebookService, _configurationService) {
+    constructor(
+        _instantiationService,
+        multiDiffSourceResolverService,
+        textModelService,
+        contextKeyService,
+        _chatService,
+        _editorService,
+        decorationsService,
+        _fileService,
+        lifecycleService,
+        storageService,
+        logService,
+        extensionService,
+        productService,
+        notebookService,
+        _configurationService
+    ) {
         super();
         this._instantiationService = _instantiationService;
         this._chatService = _chatService;
@@ -55,18 +71,29 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         this.lifecycleService = lifecycleService;
         this.notebookService = notebookService;
         this._configurationService = _configurationService;
-        this._sessionsObs = observableValueOpts({ equalsFn: (a, b) => false }, ( new LinkedList()));
+        this._sessionsObs = observableValueOpts({
+            equalsFn: (a, b) => false
+        }, ( new LinkedList()));
         this.editingSessionsObs = derived(r => {
             const result = Array.from(this._sessionsObs.read(r));
             return result;
         });
-        this._chatRelatedFilesProviders = ( new Map());
-        this._register(decorationsService.registerDecorationsProvider(_instantiationService.createInstance(ChatDecorationsProvider, this.editingSessionsObs)));
-        this._register(multiDiffSourceResolverService.registerResolver(_instantiationService.createInstance(ChatEditingMultiDiffSourceResolver, this.editingSessionsObs)));
-        this._register(textModelService.registerTextModelContentProvider(ChatEditingTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingTextModelContentProvider, this)));
-        this._register(textModelService.registerTextModelContentProvider(Schemas.chatEditingSnapshotScheme, _instantiationService.createInstance(ChatEditingSnapshotTextModelContentProvider, this)));
-        this._register(this._chatService.onDidDisposeSession((e) => {
-            if (e.reason === 'cleared') {
+        this._register(decorationsService.registerDecorationsProvider(
+            _instantiationService.createInstance(ChatDecorationsProvider, this.editingSessionsObs)
+        ));
+        this._register(multiDiffSourceResolverService.registerResolver(
+            _instantiationService.createInstance(ChatEditingMultiDiffSourceResolver, this.editingSessionsObs)
+        ));
+        this._register(textModelService.registerTextModelContentProvider(
+            ChatEditingTextModelContentProvider.scheme,
+            _instantiationService.createInstance(ChatEditingTextModelContentProvider, this)
+        ));
+        this._register(textModelService.registerTextModelContentProvider(
+            Schemas.chatEditingSnapshotScheme,
+            _instantiationService.createInstance(ChatEditingSnapshotTextModelContentProvider, this)
+        ));
+        this._register(this._chatService.onDidDisposeSession(e => {
+            if (e.reason === "cleared") {
                 for (const resource of e.sessionResource) {
                     this.getEditingSession(resource)?.stop();
                 }
@@ -74,7 +101,7 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         }));
         const readonlyEnabledContextKey = chatEditingAgentSupportsReadonlyReferencesContextKey.bindTo(contextKeyService);
         const setReadonlyFilesEnabled = () => {
-            const enabled = productService.quality !== 'stable' && ( extensionService.extensions.some(e => e.enabledApiProposals?.includes('chatReadonlyPromptReference')));
+            const enabled = productService.quality !== "stable" && ( extensionService.extensions.some(e => e.enabledApiProposals?.includes("chatReadonlyPromptReference")));
             readonlyEnabledContextKey.set(enabled);
         };
         setReadonlyFilesEnabled();
@@ -89,17 +116,15 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                 }
                 tasks.push(session.storeState());
             }
-            storageTask = Promise.resolve(storageTask)
-                .then(() => Promise.all(tasks))
-                .finally(() => storageTask = undefined);
+            storageTask = Promise.resolve(storageTask).then(() => Promise.all(tasks)).finally(() => storageTask = undefined);
         }));
         this._register(this.lifecycleService.onWillShutdown(e => {
             if (!storageTask) {
                 return;
             }
             e.join(storageTask, {
-                id: 'join.chatEditingSession',
-                label: ( localize(5172, "Saving chat edits history"))
+                id: "join.chatEditingSession",
+                label: ( localize(5343, "Saving chat edits history"))
             });
         }));
     }
@@ -120,8 +145,7 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         return undefined;
     }
     getEditingSession(chatSessionResource) {
-        return this.editingSessionsObs.get()
-            .find(candidate => isEqual(candidate.chatSessionResource, chatSessionResource));
+        return this.editingSessionsObs.get().find(candidate => isEqual(candidate.chatSessionResource, chatSessionResource));
     }
     createEditingSession(chatModel, global = false) {
         return this._createEditingSession(chatModel, global, undefined);
@@ -130,8 +154,17 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         return this._createEditingSession(chatModel, session.isGlobalEditingSession, session);
     }
     _createEditingSession(chatModel, global, initFrom) {
-        assertType(this.getEditingSession(chatModel.sessionResource) === undefined, 'CANNOT have more than one editing session per chat session');
-        const session = this._instantiationService.createInstance(ChatEditingSession, chatModel.sessionResource, global, this._lookupEntry.bind(this), initFrom);
+        assertType(
+            this.getEditingSession(chatModel.sessionResource) === undefined,
+            "CANNOT have more than one editing session per chat session"
+        );
+        const session = this._instantiationService.createInstance(
+            ChatEditingSession,
+            chatModel.sessionResource,
+            global,
+            this._lookupEntry.bind(this),
+            initFrom
+        );
         const list = this._sessionsObs.get();
         const removeSession = list.unshift(session);
         const store = ( new DisposableStore());
@@ -152,8 +185,8 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             ));
         }
         const observerDisposables = ( new DisposableStore());
-        observerDisposables.add(chatModel.onDidChange(async (e) => {
-            if (e.kind !== 'addRequest') {
+        observerDisposables.add(chatModel.onDidChange(async e => {
+            if (e.kind !== "addRequest") {
                 return;
             }
             session.createSnapshot(e.request.id, undefined);
@@ -166,14 +199,19 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         return observerDisposables;
     }
     observerEditsInResponse(requestId, responseModel, session, observerDisposables) {
+        let K;
+        (function(K) {
+            K[K["Stream"] = 0] = "Stream";
+            K[K["Workspace"] = 1] = "Workspace";
+        })(K || (K = {}));
         const editsSeen = [];
         let editorDidChange = false;
         const editorListener = Event.once(this._editorService.onDidActiveEditorChange)(() => {
             editorDidChange = true;
         });
         const editorOpenPromises = ( new ResourceMap());
-        const openChatEditedFiles = this._configurationService.getValue('accessibility.openChatEditedFiles');
-        const ensureEditorOpen = (partUri) => {
+        const openChatEditedFiles = this._configurationService.getValue("accessibility.openChatEditedFiles");
+        const ensureEditorOpen = partUri => {
             const uri = CellUri.parse(partUri)?.notebook ?? partUri;
             if (( editorOpenPromises.has(uri))) {
                 return;
@@ -181,16 +219,28 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             editorOpenPromises.set(uri, (async () => {
                 if (this.notebookService.getNotebookTextModel(uri) || uri.scheme === Schemas.untitled || (await this._fileService.exists(uri).catch(() => false))) {
                     const activeUri = this._editorService.activeEditorPane?.input.resource;
-                    const inactive = editorDidChange
-                        || this._editorService.activeEditorPane?.input instanceof ChatEditorInput && isEqual(this._editorService.activeEditorPane.input.sessionResource, session.chatSessionResource)
-                        || Boolean(activeUri && session.entries.get().find(entry => isEqual(activeUri, entry.modifiedURI)));
-                    this._editorService.openEditor({ resource: uri, options: { inactive, preserveFocus: true, pinned: true } });
+                    const inactive = editorDidChange || this._editorService.activeEditorPane?.input instanceof ChatEditorInput && isEqual(
+                        this._editorService.activeEditorPane.input.sessionResource,
+                        session.chatSessionResource
+                    ) || Boolean(
+                        activeUri && session.entries.get().find(entry => isEqual(activeUri, entry.modifiedURI))
+                    );
+                    this._editorService.openEditor({
+                        resource: uri,
+                        options: {
+                            inactive,
+                            preserveFocus: true,
+                            pinned: true
+                        }
+                    });
                 }
             })());
         };
         const onResponseComplete = () => {
             for (const remaining of editsSeen) {
-                remaining?.streaming.complete();
+                if (remaining?.kind === K.Stream) {
+                    remaining.stream.complete();
+                }
             }
             editsSeen.length = 0;
             editorOpenPromises.clear();
@@ -203,11 +253,20 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             let undoStop;
             for (let i = 0; i < responseModel.response.value.length; i++) {
                 const part = responseModel.response.value[i];
-                if (part.kind === 'undoStop') {
+                if (part.kind === "undoStop") {
                     undoStop = part.id;
                     continue;
                 }
-                if (part.kind !== 'textEditGroup' && part.kind !== 'notebookEditGroup') {
+                if (part.kind === "workspaceEdit") {
+                    if (!editsSeen[i]) {
+                        editsSeen[i] = {
+                            kind: K.Workspace
+                        };
+                        session.applyWorkspaceEdit(part, responseModel, undoStop ?? responseModel.requestId);
+                    }
+                    continue;
+                }
+                if (part.kind !== "textEditGroup" && part.kind !== "notebookEditGroup") {
                     continue;
                 }
                 if (part.isExternalEdit) {
@@ -218,9 +277,16 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                 }
                 let entry = editsSeen[i];
                 if (!entry) {
-                    entry = { seen: 0, streaming: session.startStreamingEdits(CellUri.parse(part.uri)?.notebook ?? part.uri, responseModel, undoStop) };
+                    entry = {
+                        kind: K.Stream,
+                        seen: 0,
+                        stream: session.startStreamingEdits(CellUri.parse(part.uri)?.notebook ?? part.uri, responseModel, undoStop)
+                    };
                     editsSeen[i] = entry;
                 }
+                if (entry.kind !== K.Stream) {
+                    continue;
+                }
                 const isFirst = entry.seen === 0;
                 const newEdits = part.edits.slice(entry.seen);
                 entry.seen = part.edits.length;
@@ -229,22 +295,20 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                         const edit = newEdits[i];
                         const done = part.done ? i === newEdits.length - 1 : false;
                         if (isTextEditOperationArray(edit)) {
-                            entry.streaming.pushText(edit, done);
-                        }
-                        else if (isCellTextEditOperationArray(edit)) {
+                            entry.stream.pushText(edit, done);
+                        } else if (isCellTextEditOperationArray(edit)) {
                             for (const edits of ( Object.values(groupBy(edit, e => ( e.uri.toString()))))) {
                                 if (edits) {
-                                    entry.streaming.pushNotebookCellText(edits[0].uri, ( edits.map(e => e.edit)), done);
+                                    entry.stream.pushNotebookCellText(edits[0].uri, ( edits.map(e => e.edit)), done);
                                 }
                             }
-                        }
-                        else {
-                            entry.streaming.pushNotebook(edit, done);
+                        } else {
+                            entry.stream.pushNotebook(edit, done);
                         }
                     }
                 }
                 if (part.done) {
-                    entry.streaming.complete();
+                    entry.stream.complete();
                 }
             }
         };
@@ -252,13 +316,11 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             handleResponseParts().then(() => {
                 onResponseComplete();
             });
-        }
-        else {
+        } else {
             const disposable = observerDisposables.add(responseModel.onDidChange(e2 => {
-                if (e2.reason === 'undoStop') {
+                if (e2.reason === "undoStop") {
                     session.createSnapshot(requestId, e2.id);
-                }
-                else {
+                } else {
                     handleResponseParts().then(() => {
                         if (responseModel.isComplete) {
                             onResponseComplete();
@@ -269,49 +331,8 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             }));
         }
     }
-    hasRelatedFilesProviders() {
-        return this._chatRelatedFilesProviders.size > 0;
-    }
-    registerRelatedFilesProvider(handle, provider) {
-        this._chatRelatedFilesProviders.set(handle, provider);
-        return toDisposable(() => {
-            this._chatRelatedFilesProviders.delete(handle);
-        });
-    }
-    async getRelatedFiles(chatSessionResource, prompt, files, token) {
-        const providers = Array.from(( this._chatRelatedFilesProviders.values()));
-        const result = await Promise.all(( providers.map(async (provider) => {
-            try {
-                const relatedFiles = await provider.provideRelatedFiles({ prompt, files }, token);
-                if (relatedFiles?.length) {
-                    return { group: provider.description, files: relatedFiles };
-                }
-                return undefined;
-            }
-            catch (e) {
-                return undefined;
-            }
-        })));
-        return coalesce(result);
-    }
 };
-ChatEditingService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IMultiDiffSourceResolverService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IChatService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IDecorationsService)),
-    ( __param(7, IFileService)),
-    ( __param(8, ILifecycleService)),
-    ( __param(9, IStorageService)),
-    ( __param(10, ILogService)),
-    ( __param(11, IExtensionService)),
-    ( __param(12, IProductService)),
-    ( __param(13, INotebookService)),
-    ( __param(14, IConfigurationService))
-], ChatEditingService));
+ChatEditingService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IMultiDiffSourceResolverService)), ( __param(2, ITextModelService)), ( __param(3, IContextKeyService)), ( __param(4, IChatService)), ( __param(5, IEditorService)), ( __param(6, IDecorationsService)), ( __param(7, IFileService)), ( __param(8, ILifecycleService)), ( __param(9, IStorageService)), ( __param(10, ILogService)), ( __param(11, IExtensionService)), ( __param(12, IProductService)), ( __param(13, INotebookService)), ( __param(14, IConfigurationService))], ChatEditingService));
 function observeArrayChanges(obs, compare, store) {
     const emitter = store.add(( new Emitter()));
     store.add(runOnChange(obs, (newArr, oldArr) => {
@@ -325,8 +346,8 @@ class ChatDecorationsProvider extends Disposable {
     constructor(_sessions) {
         super();
         this._sessions = _sessions;
-        this.label = ( localize(5173, "Chat Editing"));
-        this._currentEntries = derived(this, (r) => {
+        this.label = ( localize(5344, "Chat Editing"));
+        this._currentEntries = derived(this, r => {
             const sessions = this._sessions.read(r);
             if (!sessions) {
                 return [];
@@ -340,22 +361,27 @@ class ChatDecorationsProvider extends Disposable {
             }
             return result;
         });
-        this._currentlyEditingUris = derived(this, (r) => {
+        this._currentlyEditingUris = derived(this, r => {
             const uri = this._currentEntries.read(r);
             return ( uri.filter(entry => entry.isCurrentlyBeingModifiedBy.read(r)).map(entry => entry.modifiedURI));
         });
-        this._modifiedUris = derived(this, (r) => {
+        this._modifiedUris = derived(this, r => {
             const uri = this._currentEntries.read(r);
-            return ( uri.filter(entry => !entry.isCurrentlyBeingModifiedBy.read(r) && entry.state.read(r) === ModifiedFileEntryState.Modified).map(entry => entry.modifiedURI));
+            return ( uri.filter(
+                entry => !entry.isCurrentlyBeingModifiedBy.read(r) && entry.state.read(r) === ModifiedFileEntryState.Modified
+            ).map(entry => entry.modifiedURI));
         });
-        this.onDidChange = Event.any(observeArrayChanges(this._currentlyEditingUris, compareBy(uri => ( uri.toString()), compare), this._store), observeArrayChanges(this._modifiedUris, compareBy(uri => ( uri.toString()), compare), this._store));
+        this.onDidChange = Event.any(
+            observeArrayChanges(this._currentlyEditingUris, compareBy(uri => ( uri.toString()), compare), this._store),
+            observeArrayChanges(this._modifiedUris, compareBy(uri => ( uri.toString()), compare), this._store)
+        );
     }
     provideDecorations(uri, _token) {
         const isCurrentlyBeingModified = ( this._currentlyEditingUris.get().some(e => ( e.toString()) === ( uri.toString())));
         if (isCurrentlyBeingModified) {
             return {
                 weight: 1000,
-                letter: ThemeIcon.modify(Codicon.loading, 'spin'),
+                letter: ThemeIcon.modify(Codicon.loading, "spin"),
                 bubble: false
             };
         }
@@ -364,7 +390,7 @@ class ChatDecorationsProvider extends Disposable {
             return {
                 weight: 1000,
                 letter: Codicon.diffModified,
-                tooltip: ( localize(5174, "Pending changes from chat")),
+                tooltip: ( localize(5345, "Pending changes from chat")),
                 bubble: true
             };
         }
@@ -382,36 +408,36 @@ let ChatEditingMultiDiffSourceResolver = class ChatEditingMultiDiffSourceResolve
     async resolveDiffSource(uri) {
         const parsed = parseChatMultiDiffUri(uri);
         const thisSession = derived(this, r => {
-            return this._editingSessionsObs.read(r).find(candidate => isEqual(candidate.chatSessionResource, parsed.chatSessionResource));
+            return this._editingSessionsObs.read(r).find(
+                candidate => isEqual(candidate.chatSessionResource, parsed.chatSessionResource)
+            );
         });
         return this._instantiationService.createInstance(ChatEditingMultiDiffSource, thisSession, parsed.showPreviousChanges);
     }
 };
-ChatEditingMultiDiffSourceResolver = ( __decorate([
-    ( __param(1, IInstantiationService))
-], ChatEditingMultiDiffSourceResolver));
+ChatEditingMultiDiffSourceResolver = ( __decorate([( __param(1, IInstantiationService))], ChatEditingMultiDiffSourceResolver));
 class ChatEditingMultiDiffSource {
     constructor(_currentSession, _showPreviousChanges) {
         this._currentSession = _currentSession;
         this._showPreviousChanges = _showPreviousChanges;
-        this._resources = derived(this, (reader) => {
+        this._resources = derived(this, reader => {
             const currentSession = this._currentSession.read(reader);
             if (!currentSession) {
                 return [];
             }
             const entries = currentSession.entries.read(reader);
-            return ( entries.map((entry) => {
+            return ( entries.map(entry => {
                 if (this._showPreviousChanges) {
                     const entryDiffObs = currentSession.getEntryDiffBetweenStops(entry.modifiedURI, undefined, undefined);
                     const entryDiff = entryDiffObs?.read(reader);
                     if (entryDiff) {
                         return ( new MultiDiffEditorItem(entryDiff.originalURI, entryDiff.modifiedURI, undefined, undefined, {
-                            [chatEditingResourceContextKey.key]: entry.entryId,
+                            [chatEditingResourceContextKey.key]: entry.entryId
                         }));
                     }
                 }
                 return ( new MultiDiffEditorItem(entry.originalURI, entry.modifiedURI, undefined, undefined, {
-                    [chatEditingResourceContextKey.key]: entry.entryId,
+                    [chatEditingResourceContextKey.key]: entry.entryId
                 }));
             }));
         });

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingSession.d.ts

@@ -9,6 +9,7 @@ import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/com
 import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
 import { IAccessibilitySignalService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
@@ -16,8 +17,9 @@ import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench
 import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
 import { ChatEditingSessionState, IChatEditingSession, IEditSessionEntryDiff, IModifiedFileEntry, IStreamingEdits } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
 import { IChatResponseModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
-import { IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatProgress, IChatWorkspaceEdit } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { AbstractChatEditingModifiedFileEntry } from "./chatEditingModifiedFileEntry.js";
+import { IChatEditingExplanationModelManager } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingExplanationModelManager.service";
 export declare class ChatEditingSession extends Disposable implements IChatEditingSession {
     readonly chatSessionResource: URI;
     readonly isGlobalEditingSession: boolean;
@@ -33,6 +35,8 @@ export declare class ChatEditingSession extends Disposable implements IChatEditi
     private readonly _accessibilitySignalService;
     private readonly _logService;
     private readonly configurationService;
+    private readonly _fileService;
+    private readonly _explanationModelManager;
     private readonly _state;
     private readonly _timeline;
     /**
@@ -49,13 +53,14 @@ export declare class ChatEditingSession extends Disposable implements IChatEditi
     private readonly _entriesObs;
     readonly entries: IObservable<readonly IModifiedFileEntry[]>;
     private _editorPane;
+    private _explanationHandle;
     get state(): IObservable<ChatEditingSessionState>;
     readonly canUndo: IObservable<boolean>;
     readonly canRedo: IObservable<boolean>;
     get requestDisablement(): IObservable<import("@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel").IChatRequestDisablement[]>;
     private readonly _onDidDispose;
     get onDidDispose(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
-    constructor(chatSessionResource: URI, isGlobalEditingSession: boolean, _lookupExternalEntry: (uri: URI) => AbstractChatEditingModifiedFileEntry | undefined, transferFrom: IChatEditingSession | undefined, _instantiationService: IInstantiationService, _modelService: IModelService, _languageService: ILanguageService, _textModelService: ITextModelService, _bulkEditService: IBulkEditService, _editorGroupsService: IEditorGroupsService, _editorService: IEditorService, _notebookService: INotebookService, _accessibilitySignalService: IAccessibilitySignalService, _logService: ILogService, configurationService: IConfigurationService);
+    constructor(chatSessionResource: URI, isGlobalEditingSession: boolean, _lookupExternalEntry: (uri: URI) => AbstractChatEditingModifiedFileEntry | undefined, transferFrom: IChatEditingSession | undefined, _instantiationService: IInstantiationService, _modelService: IModelService, _languageService: ILanguageService, _textModelService: ITextModelService, _bulkEditService: IBulkEditService, _editorGroupsService: IEditorGroupsService, _editorService: IEditorService, _notebookService: INotebookService, _accessibilitySignalService: IAccessibilitySignalService, _logService: ILogService, configurationService: IConfigurationService, _fileService: IFileService, _explanationModelManager: IChatEditingExplanationModelManager);
     private _getTimelineDelegate;
     private _init;
     private _getEntry;
@@ -85,10 +90,15 @@ export declare class ChatEditingSession extends Disposable implements IChatEditi
     dispose(): void;
     private get isDisposed();
     startStreamingEdits(resource: URI, responseModel: IChatResponseModel, inUndoStop: string | undefined): IStreamingEdits;
+    startDeletion(resource: URI, responseModel: IChatResponseModel, undoStopId: string): void;
+    applyWorkspaceEdit(edit: IChatWorkspaceEdit, responseModel: IChatResponseModel, undoStopId: string): void;
     startExternalEdits(responseModel: IChatResponseModel, operationId: number, resources: URI[], undoStopId: string): Promise<IChatProgress[]>;
     stopExternalEdits(responseModel: IChatResponseModel, operationId: number): Promise<IChatProgress[]>;
     undoInteraction(): Promise<void>;
     redoInteraction(): Promise<void>;
+    triggerExplanationGeneration(): Promise<void>;
+    clearExplanations(): void;
+    hasExplanations(): boolean;
     private _recordEditOperations;
     private _getCurrentTextOrNotebookSnapshot;
     private _acceptStreamingEditsStart;