@codingame/monaco-vscode-chat-service-override 11.1.2 → 12.0.1

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

@@ -1,11 +1,12 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { delta, compareBy } from 'vscode/vscode/vs/base/common/arrays';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { coalesce, delta, compareBy } from 'vscode/vscode/vs/base/common/arrays';
 import { AsyncIterableSource } from 'vscode/vscode/vs/base/common/async';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { BugIndicatingError } from 'vscode/vscode/vs/base/common/errors';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
 import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
 import 'vscode/vscode/vs/base/common/observableInternal/autorun';
@@ -13,30 +14,34 @@ import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived
 import { runOnChange, ValueWithChangeEventFromObservable } from 'vscode/vscode/vs/base/common/observableInternal/utils';
 import { compare } from 'vscode/vscode/vs/base/common/strings';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { isString } from 'vscode/vscode/vs/base/common/types';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
 import { localize, localize2 } from 'vscode/vscode/vs/nls';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
-import { EditorActivation } from 'vscode/vscode/vs/platform/editor/common/editor';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { bindContextKey } from 'vscode/vscode/vs/platform/observable/common/platformObservableUtils';
+import { ProgressLocation } from 'vscode/vscode/vs/platform/progress/common/progress';
 import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { IWorkbenchAssignmentService } from 'vscode/vscode/vs/workbench/services/assignment/common/assignmentService.service';
 import { IDecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/common/decorations.service';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
-import { MultiDiffEditorInput } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
-import { MultiDiffEditorItem } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { MultiDiffEditorItem } from '@codingame/monaco-vscode-9d05a43d-c330-5ff1-937e-fde4a3852931-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
 import { IMultiDiffSourceResolverService } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service';
-import { ICodeMapperService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatCodeMapperService.service';
-import { CONTEXT_CHAT_EDITING_CAN_UNDO, CONTEXT_CHAT_EDITING_CAN_REDO } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { defaultChatEditingMaxFileLimit, applyingChatEditsFailedContextKey, decidedChatEditingResourceContextKey, hasUndecidedChatEditingResourceContextKey, hasAppliedChatEditsContextKey, inChatEditingSessionContextKey, applyingChatEditsContextKey, chatEditingMaxFileAssignmentName, CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, chatEditingResourceContextKey } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-search-terminal-common/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatContextKeys } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { defaultChatEditingMaxFileLimit, applyingChatEditsFailedContextKey, decidedChatEditingResourceContextKey, WorkingSetEntryState, hasUndecidedChatEditingResourceContextKey, hasAppliedChatEditsContextKey, inChatEditingSessionContextKey, applyingChatEditsContextKey, chatEditingMaxFileAssignmentName, ChatEditingSessionState, CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, chatEditingResourceContextKey } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatEditingService';
 import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
 import { ChatEditingSession } from './chatEditingSession.js';
-import { ChatEditingTextModelContentProvider, ChatEditingSnapshotTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
+import { ChatEditingTextModelContentProvider, ChatEditingSnapshotTextModelContentProvider } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTextModelContentProviders';
 
 var ChatEditingMultiDiffSourceResolver_1;
+const STORAGE_KEY_EDITING_SESSION = 'chat.editingSession';
 let ChatEditingService = class ChatEditingService extends Disposable {
     get currentAutoApplyOperation() {
         return this._currentAutoApplyOperationObs.get();
@@ -53,25 +58,25 @@ let ChatEditingService = class ChatEditingService extends Disposable {
     get editingSessionFileLimit() {
         return this._editingSessionFileLimit ?? defaultChatEditingMaxFileLimit;
     }
-    constructor(_editorGroupsService, _instantiationService, multiDiffSourceResolverService, textModelService, contextKeyService, _chatService, _progressService, _codeMapperService, _editorService, decorationsService, _fileService, _workbenchAssignmentService) {
+    constructor(_instantiationService, multiDiffSourceResolverService, textModelService, contextKeyService, _chatService, _progressService, _editorService, decorationsService, _fileService, lifecycleService, _workbenchAssignmentService, storageService) {
         super();
-        this._editorGroupsService = _editorGroupsService;
         this._instantiationService = _instantiationService;
         this._chatService = _chatService;
         this._progressService = _progressService;
-        this._codeMapperService = _codeMapperService;
         this._editorService = _editorService;
         this._fileService = _fileService;
+        this.lifecycleService = lifecycleService;
         this._workbenchAssignmentService = _workbenchAssignmentService;
         this._currentSessionObs = observableValue(this, null);
-        this._currentSessionDisposables = this._register(( (new DisposableStore())));
+        this._currentSessionDisposables = this._register(( new DisposableStore()));
         this._currentAutoApplyOperationObs = observableValue(this, null);
-        this._onDidCreateEditingSession = this._register(( (new Emitter())));
-        this._onDidChangeEditingSession = this._register(( (new Emitter())));
+        this._onDidCreateEditingSession = this._register(( new Emitter()));
+        this._onDidChangeEditingSession = this._register(( new Emitter()));
         this.onDidChangeEditingSession = this._onDidChangeEditingSession.event;
+        this._chatRelatedFilesProviders = ( new Map());
         this._applyingChatEditsFailedContextKey = applyingChatEditsFailedContextKey.bindTo(contextKeyService);
         this._applyingChatEditsFailedContextKey.set(false);
-        this._register(decorationsService.registerDecorationsProvider(( (new ChatDecorationsProvider(this._currentSessionObs)))));
+        this._register(decorationsService.registerDecorationsProvider(_instantiationService.createInstance(ChatDecorationsProvider, this._currentSessionObs)));
         this._register(multiDiffSourceResolverService.registerResolver(_instantiationService.createInstance(ChatEditingMultiDiffSourceResolver, this._currentSessionObs)));
         textModelService.registerTextModelContentProvider(ChatEditingTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingTextModelContentProvider, this._currentSessionObs));
         textModelService.registerTextModelContentProvider(ChatEditingSnapshotTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingSnapshotTextModelContentProvider, this._currentSessionObs));
@@ -81,10 +86,8 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                 return;
             }
             const entries = currentSession.entries.read(reader);
-            const decidedEntries = entries.filter(entry => entry.state.read(reader) !== 0 );
-            return (
-                 (decidedEntries.map(entry => entry.entryId))
-            );
+            const decidedEntries = entries.filter(entry => entry.state.read(reader) !== WorkingSetEntryState.Modified);
+            return ( decidedEntries.map(entry => entry.entryId));
         }));
         this._register(bindContextKey(hasUndecidedChatEditingResourceContextKey, contextKeyService, (reader) => {
             const currentSession = this._currentSessionObs.read(reader);
@@ -92,7 +95,7 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                 return;
             }
             const entries = currentSession.entries.read(reader);
-            const decidedEntries = entries.filter(entry => entry.state.read(reader) === 0 );
+            const decidedEntries = entries.filter(entry => entry.state.read(reader) === WorkingSetEntryState.Modified);
             return decidedEntries.length > 0;
         }));
         this._register(bindContextKey(hasAppliedChatEditsContextKey, contextKeyService, (reader) => {
@@ -109,10 +112,10 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         this._register(bindContextKey(applyingChatEditsContextKey, contextKeyService, (reader) => {
             return this._currentAutoApplyOperationObs.read(reader) !== null;
         }));
-        this._register(bindContextKey(CONTEXT_CHAT_EDITING_CAN_UNDO, contextKeyService, (r) => {
+        this._register(bindContextKey(ChatContextKeys.chatEditingCanUndo, contextKeyService, (r) => {
             return this._currentSessionObs.read(r)?.canUndo.read(r) || false;
         }));
-        this._register(bindContextKey(CONTEXT_CHAT_EDITING_CAN_REDO, contextKeyService, (r) => {
+        this._register(bindContextKey(ChatContextKeys.chatEditingCanRedo, contextKeyService, (r) => {
             return this._currentSessionObs.read(r)?.canRedo.read(r) || false;
         }));
         this._register(this._chatService.onDidDisposeSession((e) => {
@@ -121,56 +124,56 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                 void this._currentSessionObs.get()?.stop();
             }
         }));
+        this._register(this.lifecycleService.onWillShutdown((e) => {
+            const session = this._currentSessionObs.get();
+            if (session) {
+                storageService.store(STORAGE_KEY_EDITING_SESSION, session.chatSessionId, StorageScope.WORKSPACE, StorageTarget.MACHINE);
+                e.join(session.storeState(), { id: 'join.chatEditingSession', label: ( localize(4381, "Saving chat edits history")) });
+            }
+        }));
         this._editingSessionFileLimitPromise = this._workbenchAssignmentService.getTreatment(chatEditingMaxFileAssignmentName).then(value => {
             this._editingSessionFileLimit = value ?? defaultChatEditingMaxFileLimit;
             return this._editingSessionFileLimit;
         });
-    }
-    getSnapshotUri(id, uri) {
-        const session = this._currentSessionObs.get();
-        if (!session) {
-            return undefined;
+        const sessionIdToRestore = storageService.get(STORAGE_KEY_EDITING_SESSION, StorageScope.WORKSPACE);
+        if (isString(sessionIdToRestore) && this._chatService.getOrRestoreSession(sessionIdToRestore)) {
+            this._restoringEditingSession = this.startOrContinueEditingSession(sessionIdToRestore);
+            this._restoringEditingSession.finally(() => {
+                this._restoringEditingSession = undefined;
+            });
         }
-        return session.getSnapshot(id, uri)?.snapshotUri;
     }
-    getEditingSession(resource) {
-        const session = this.currentEditingSession;
-        if (!session) {
-            return null;
+    async getOrRestoreEditingSession() {
+        if (this._restoringEditingSession) {
+            await this._restoringEditingSession;
         }
-        const entries = session.entries.get();
-        for (const entry of entries) {
-            if (( (entry.modifiedURI.toString())) === ( (resource.toString()))) {
-                return session;
-            }
-        }
-        return null;
+        return this.currentEditingSessionObs.get();
     }
     dispose() {
         this._currentSessionObs.get()?.dispose();
         super.dispose();
     }
-    async startOrContinueEditingSession(chatSessionId, options) {
+    async startOrContinueEditingSession(chatSessionId) {
+        await this._restoringEditingSession;
         const session = this._currentSessionObs.get();
         if (session) {
-            if (session.chatSessionId !== chatSessionId) {
-                throw ( (new BugIndicatingError('Cannot start new session while another session is active')));
+            if (session.chatSessionId === chatSessionId) {
+                return session;
+            }
+            else if (session.chatSessionId !== chatSessionId) {
+                await session.stop(true);
             }
         }
-        return this._createEditingSession(chatSessionId, options);
+        return this._createEditingSession(chatSessionId);
     }
-    async _createEditingSession(chatSessionId, options) {
+    async _createEditingSession(chatSessionId) {
         if (this._currentSessionObs.get()) {
-            throw ( (new BugIndicatingError('Cannot have more than one active editing session')));
+            throw ( new BugIndicatingError('Cannot have more than one active editing session'));
         }
         this._currentSessionDisposables.clear();
-        this._currentSessionDisposables.add(this.installAutoApplyObserver(chatSessionId));
-        const input = MultiDiffEditorInput.fromResourceMultiDiffEditorInput({
-            multiDiffSource: ChatEditingMultiDiffSourceResolver.getMultiDiffSourceUri(),
-            label: ( localize(3216, "Suggested Edits"))
-        }, this._instantiationService);
-        const editorPane = options?.silent ? undefined : await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
-        const session = this._instantiationService.createInstance(ChatEditingSession, chatSessionId, editorPane, this._editingSessionFileLimitPromise);
+        const session = this._instantiationService.createInstance(ChatEditingSession, chatSessionId, this._editingSessionFileLimitPromise);
+        await session.init();
+        this._currentSessionDisposables.add(this.installAutoApplyObserver(session));
         this._currentSessionDisposables.add(session.onDidDispose(() => {
             this._currentSessionDisposables.clear();
             this._currentSessionObs.set(null, undefined);
@@ -184,43 +187,29 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         this._onDidChangeEditingSession.fire();
         return session;
     }
-    triggerEditComputation(responseModel) {
-        return this._continueEditingSession(async (builder, token) => {
-            const codeMapperResponse = {
-                textEdit: (resource, edits) => builder.textEdits(resource, edits, responseModel),
-            };
-            await this._codeMapperService.mapCodeFromResponse(responseModel, codeMapperResponse, token);
-        }, { silent: true });
-    }
-    createSnapshot(requestId) {
-        this._currentSessionObs.get()?.createSnapshot(requestId);
-    }
-    async restoreSnapshot(requestId) {
-        await this._currentSessionObs.get()?.restoreSnapshot(requestId);
-    }
-    installAutoApplyObserver(sessionId) {
-        const chatModel = this._chatService.getSession(sessionId);
+    installAutoApplyObserver(session) {
+        const chatModel = this._chatService.getOrRestoreSession(session.chatSessionId);
         if (!chatModel) {
-            throw ( (new Error(`Edit session was created for a non-existing chat session: ${sessionId}`)));
+            throw ( new Error(
+                `Edit session was created for a non-existing chat session: ${session.chatSessionId}`
+            ));
         }
-        const observerDisposables = ( (new DisposableStore()));
+        const observerDisposables = ( new DisposableStore());
         let editsSource;
-        const editsSeen = ( (new ResourceMap()));
-        const editedFilesExist = ( (new ResourceMap()));
+        let editsPromise;
+        const editsSeen = ( new ResourceMap());
+        const editedFilesExist = ( new ResourceMap());
         const onResponseComplete = (responseModel) => {
-            if (responseModel.result?.errorDetails) {
-                this.restoreSnapshot(responseModel.requestId);
+            if (responseModel.result?.errorDetails && !responseModel.result.errorDetails.responseIsIncomplete) {
+                session.restoreSnapshot(responseModel.requestId);
                 this._applyingChatEditsFailedContextKey.set(true);
             }
-            else if (responseModel.result?.metadata?.autoApplyEdits) {
-                this.triggerEditComputation(responseModel);
-            }
             editsSource?.resolve();
             editsSource = undefined;
             editsSeen.clear();
             editedFilesExist.clear();
         };
-        const handleResponseParts = (responseModel) => {
+        const handleResponseParts = async (responseModel) => {
             for (const part of responseModel.response.value) {
                 if (part.kind === 'codeblockUri' || part.kind === 'textEditGroup') {
                     if (!editedFilesExist.get(part.uri)) {
@@ -240,35 +229,47 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                     const allEdits = part.kind === 'textEditGroup' ? part.edits : [];
                     const newEdits = allEdits.slice(entry.seen);
                     entry.seen += newEdits.length;
-                    editsSource ??= ( (new AsyncIterableSource()));
-                    editsSource.emitOne({ uri: part.uri, edits: newEdits, kind: 'textEditGroup' });
+                    if (newEdits.length > 0 || entry.seen === 0) {
+                        editsSource ??= ( new AsyncIterableSource());
+                        editsSource.emitOne({ uri: part.uri, edits: newEdits, kind: 'textEditGroup', done: part.kind === 'textEditGroup' && part.done });
+                    }
                     if (first) {
-                        this._continueEditingSession(async (builder, token) => {
+                        await editsPromise;
+                        editsPromise = this._continueEditingSession(session, async (builder, token) => {
                             for await (const item of editsSource.asyncIterable) {
                                 if (token.isCancellationRequested) {
                                     break;
                                 }
-                                for (const group of item.edits) {
-                                    builder.textEdits(item.uri, group, responseModel);
+                                if (item.edits.length === 0) {
+                                    builder.textEdits(item.uri, [], item.done ?? false, responseModel);
+                                    continue;
+                                }
+                                for (let i = 0; i < item.edits.length; i++) {
+                                    const group = item.edits[i];
+                                    const isLastGroup = i === item.edits.length - 1;
+                                    builder.textEdits(item.uri, group, isLastGroup && (item.done ?? false), responseModel);
                                 }
                             }
-                        }, { silent: true });
+                        }).finally(() => {
+                            editsPromise = undefined;
+                        });
                     }
                 }
             }
         };
-        observerDisposables.add(chatModel.onDidChange(e => {
+        observerDisposables.add(chatModel.onDidChange(async (e) => {
             if (e.kind === 'addRequest') {
+                session.createSnapshot(e.request.id);
                 this._applyingChatEditsFailedContextKey.set(false);
                 const responseModel = e.request.response;
                 if (responseModel) {
                     if (responseModel.isComplete) {
-                        handleResponseParts(responseModel);
+                        await handleResponseParts(responseModel);
                         onResponseComplete(responseModel);
                     }
                     else {
-                        const disposable = responseModel.onDidChange(() => {
-                            handleResponseParts(responseModel);
+                        const disposable = responseModel.onDidChange(async () => {
+                            await handleResponseParts(responseModel);
                             if (responseModel.isComplete) {
                                 onResponseComplete(responseModel);
                                 disposable.dispose();
@@ -284,43 +285,25 @@ let ChatEditingService = class ChatEditingService extends Disposable {
         observerDisposables.add(chatModel.onDidDispose(() => observerDisposables.dispose()));
         return observerDisposables;
     }
-    async _continueEditingSession(builder, options) {
-        const session = this._currentSessionObs.get();
-        if (!session) {
-            throw ( (new BugIndicatingError('Cannot continue missing session')));
-        }
-        if (session.state.get() === 1 ) {
-            throw ( (new BugIndicatingError('Cannot continue session that is still streaming')));
-        }
-        let editorPane;
-        if (!options?.silent && session.isVisible) {
-            const groupedEditors = this._findGroupedEditors();
-            if (groupedEditors.length !== 1) {
-                throw ( (new Error(`Unexpected number of editors: ${groupedEditors.length}`)));
-            }
-            const [group, editor] = groupedEditors[0];
-            editorPane = await group.openEditor(editor, { pinned: true, activation: EditorActivation.ACTIVATE });
+    async _continueEditingSession(session, builder) {
+        if (session.state.get() === ChatEditingSessionState.StreamingEdits) {
+            throw ( new BugIndicatingError('Cannot continue session that is still streaming'));
         }
         const stream = {
-            textEdits: (resource, textEdits, responseModel) => {
-                session.acceptTextEdits(resource, textEdits, responseModel);
+            textEdits: (resource, textEdits, isDone, responseModel) => {
+                session.acceptTextEdits(resource, textEdits, isDone, responseModel);
             }
         };
         session.acceptStreamingEditsStart();
-        const cancellationTokenSource = ( (new CancellationTokenSource()));
+        const cancellationTokenSource = ( new CancellationTokenSource());
         this._currentAutoApplyOperationObs.set(cancellationTokenSource, undefined);
         try {
-            if (editorPane) {
-                await editorPane?.showWhile(builder(stream, cancellationTokenSource.token));
-            }
-            else {
-                await this._progressService.withProgress({
-                    location: 10 ,
-                    title: ( localize2(3217, 'Generating edits...')).value,
-                }, async () => {
-                    await builder(stream, cancellationTokenSource.token);
-                }, () => cancellationTokenSource.cancel());
-            }
+            await this._progressService.withProgress({
+                location: ProgressLocation.Window,
+                title: ( localize2(4382, 'Generating edits...')).value,
+            }, async () => {
+                await builder(stream, cancellationTokenSource.token);
+            }, () => cancellationTokenSource.cancel());
         }
         finally {
             cancellationTokenSource.dispose();
@@ -328,34 +311,58 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             session.resolve();
         }
     }
-    _findGroupedEditors() {
-        const editors = [];
-        for (const group of this._editorGroupsService.groups) {
-            for (const editor of group.editors) {
-                if (editor.resource?.scheme === ChatEditingMultiDiffSourceResolver.scheme) {
-                    editors.push([group, editor]);
-                }
+    hasRelatedFilesProviders() {
+        return this._chatRelatedFilesProviders.size > 0;
+    }
+    registerRelatedFilesProvider(handle, provider) {
+        this._chatRelatedFilesProviders.set(handle, provider);
+        return toDisposable(() => {
+            this._chatRelatedFilesProviders.delete(handle);
+        });
+    }
+    async getRelatedFiles(chatSessionId, prompt, token) {
+        const currentSession = this._currentSessionObs.get();
+        if (!currentSession || chatSessionId !== currentSession.chatSessionId) {
+            return undefined;
+        }
+        const userAddedWorkingSetEntries = [];
+        for (const [uri, metadata] of currentSession.workingSet) {
+            if (metadata.state !== WorkingSetEntryState.Suggested) {
+                userAddedWorkingSetEntries.push(uri);
             }
         }
-        return editors;
+        const providers = Array.from(( this._chatRelatedFilesProviders.values()));
+        const result = await Promise.all(( providers.map(async (provider) => {
+            try {
+                const relatedFiles = await provider.provideRelatedFiles({ prompt, files: userAddedWorkingSetEntries }, token);
+                if (relatedFiles?.length) {
+                    return { group: provider.description, files: relatedFiles };
+                }
+                return undefined;
+            }
+            catch (e) {
+                return undefined;
+            }
+        })));
+        return coalesce(result);
     }
 };
-ChatEditingService = ( (__decorate([
-    ( (__param(0, IEditorGroupsService))),
-    ( (__param(1, IInstantiationService))),
-    ( (__param(2, IMultiDiffSourceResolverService))),
-    ( (__param(3, ITextModelService))),
-    ( (__param(4, IContextKeyService))),
-    ( (__param(5, IChatService))),
-    ( (__param(6, IProgressService))),
-    ( (__param(7, ICodeMapperService))),
-    ( (__param(8, IEditorService))),
-    ( (__param(9, IDecorationsService))),
-    ( (__param(10, IFileService))),
-    ( (__param(11, IWorkbenchAssignmentService)))
-], ChatEditingService)));
+ChatEditingService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IMultiDiffSourceResolverService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IChatService)),
+    ( __param(5, IProgressService)),
+    ( __param(6, IEditorService)),
+    ( __param(7, IDecorationsService)),
+    ( __param(8, IFileService)),
+    ( __param(9, ILifecycleService)),
+    ( __param(10, IWorkbenchAssignmentService)),
+    ( __param(11, IStorageService))
+], ChatEditingService));
 function observeArrayChanges(obs, compare, store) {
-    const emitter = store.add(( (new Emitter())));
+    const emitter = store.add(( new Emitter()));
     store.add(runOnChange(obs, (newArr, oldArr) => {
         const change = delta(oldArr || [], newArr, compare);
         const changedElements = [].concat(change.added).concat(change.removed);
@@ -363,48 +370,66 @@ function observeArrayChanges(obs, compare, store) {
     }));
     return emitter.event;
 }
-class ChatDecorationsProvider extends Disposable {
-    constructor(_session) {
+let ChatDecorationsProvider = class ChatDecorationsProvider extends Disposable {
+    constructor(_session, _chatAgentService) {
         super();
         this._session = _session;
-        this.label = ( localize(3218, "Chat Editing"));
-        this._currentlyEditingUris = derived(this, (r) => {
+        this._chatAgentService = _chatAgentService;
+        this.label = ( localize(4383, "Chat Editing"));
+        this._currentEntries = derived(this, (r) => {
             const session = this._session.read(r);
             if (!session) {
                 return [];
             }
             const state = session.state.read(r);
-            if (state === 3 ) {
+            if (state === ChatEditingSessionState.Disposed) {
                 return [];
             }
-            return (
-                 (session.entries.read(r).filter(entry => entry.isCurrentlyBeingModified.read(r)).map(entry => entry.modifiedURI))
-            );
+            return session.entries.read(r);
         });
-        this.onDidChange = observeArrayChanges(this._currentlyEditingUris, compareBy(uri => ( (uri.toString())), compare), this._store);
+        this._currentlyEditingUris = derived(this, (r) => {
+            const uri = this._currentEntries.read(r);
+            return ( uri.filter(entry => entry.isCurrentlyBeingModified.read(r)).map(entry => entry.modifiedURI));
+        });
+        this._modifiedUris = derived(this, (r) => {
+            const uri = this._currentEntries.read(r);
+            return ( uri.filter(entry => !entry.isCurrentlyBeingModified.read(r) && entry.state.read(r) === WorkingSetEntryState.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));
     }
     provideDecorations(uri, _token) {
-        const isCurrentlyBeingModified = ( (this._currentlyEditingUris.get().some(e => ( (e.toString())) === ( (uri.toString())))));
-        if (!isCurrentlyBeingModified) {
-            return undefined;
+        const isCurrentlyBeingModified = ( this._currentlyEditingUris.get().some(e => ( e.toString()) === ( uri.toString())));
+        if (isCurrentlyBeingModified) {
+            return {
+                weight: 1000,
+                letter: ThemeIcon.modify(Codicon.loading, 'spin'),
+                bubble: false
+            };
         }
-        return {
-            weight: 1000,
-            letter: ThemeIcon.modify(Codicon.loading, 'spin'),
-            bubble: false
-        };
+        const isModified = ( this._modifiedUris.get().some(e => ( e.toString()) === ( uri.toString())));
+        if (isModified) {
+            const defaultAgentName = this._chatAgentService.getDefaultAgent(ChatAgentLocation.EditingSession)?.fullName;
+            return {
+                weight: 1000,
+                letter: Codicon.diffModified,
+                tooltip: defaultAgentName ? ( localize(4384, "Pending changes from {0}", defaultAgentName)) : ( localize(4385, "Pending changes from chat")),
+                bubble: true
+            };
+        }
+        return undefined;
     }
-}
+};
+ChatDecorationsProvider = ( __decorate([
+    ( __param(1, IChatAgentService))
+], ChatDecorationsProvider));
 let ChatEditingMultiDiffSourceResolver = class ChatEditingMultiDiffSourceResolver {
     static { ChatEditingMultiDiffSourceResolver_1 = this; }
     static { this.scheme = CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME; }
     static getMultiDiffSourceUri() {
-        return (
-             (URI.from({
-                scheme: ChatEditingMultiDiffSourceResolver_1.scheme,
-                path: '',
-            }))
-        );
+        return ( URI.from({
+            scheme: ChatEditingMultiDiffSourceResolver_1.scheme,
+            path: '',
+        }));
     }
     constructor(_currentSession, _instantiationService) {
         this._currentSession = _currentSession;
@@ -417,9 +442,9 @@ let ChatEditingMultiDiffSourceResolver = class ChatEditingMultiDiffSourceResolve
         return this._instantiationService.createInstance(ChatEditingMultiDiffSource, this._currentSession);
     }
 };
-ChatEditingMultiDiffSourceResolver = ChatEditingMultiDiffSourceResolver_1 = ( (__decorate([
-    ( (__param(1, IInstantiationService)))
-], ChatEditingMultiDiffSourceResolver)));
+ChatEditingMultiDiffSourceResolver = ChatEditingMultiDiffSourceResolver_1 = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ChatEditingMultiDiffSourceResolver));
 class ChatEditingMultiDiffSource {
     constructor(_currentSession) {
         this._currentSession = _currentSession;
@@ -429,17 +454,13 @@ class ChatEditingMultiDiffSource {
                 return [];
             }
             const entries = currentSession.entries.read(reader);
-            return (
-                 (entries.map((entry) => {
-                    return (
-                         (new MultiDiffEditorItem(entry.originalURI, entry.modifiedURI, undefined, {
-                            [chatEditingResourceContextKey.key]: entry.entryId,
-                        }))
-                    );
-                }))
-            );
+            return ( entries.map((entry) => {
+                return ( new MultiDiffEditorItem(entry.originalURI, entry.modifiedURI, undefined, {
+                    [chatEditingResourceContextKey.key]: entry.entryId,
+                }));
+            }));
         });
-        this.resources = ( (new ValueWithChangeEventFromObservable(this._resources)));
+        this.resources = ( new ValueWithChangeEventFromObservable(this._resources));
         this.contextKeys = {
             [inChatEditingSessionContextKey.key]: true
         };