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

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

@@ -1,15 +1,17 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { Sequencer } from 'vscode/vscode/vs/base/common/async';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { Sequencer, timeout } from 'vscode/vscode/vs/base/common/async';
 import { BugIndicatingError } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ResourceMap, ResourceSet } from 'vscode/vscode/vs/base/common/map';
 import { observableValue, transaction } from 'vscode/vscode/vs/base/common/observableInternal/base';
 import 'vscode/vscode/vs/base/common/arrays';
-import 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
 import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
 import 'vscode/vscode/vs/base/common/cancellation';
 import 'vscode/vscode/vs/base/common/observableInternal/utils';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
 import { IBulkEditService } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
 import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
@@ -21,18 +23,55 @@ 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 { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { DiffEditorInput } from 'vscode/vscode/vs/workbench/common/editor/diffEditorInput';
+import { DiffEditorInput } from '@codingame/monaco-vscode-5108c2c9-4ada-52d8-8c4b-fe03b3160e71-common/vscode/vs/workbench/common/editor/diffEditorInput';
 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 { MultiDiffEditorInput } from '@codingame/monaco-vscode-1cc4ea0a-c5b6-54ed-bb60-078a99119b55-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatEditingSessionState, ChatEditingSessionChangeType, WorkingSetEntryState, WorkingSetEntryRemovalReason, ChatEditKind } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatEditingService';
 import { ChatEditingMultiDiffSourceResolver } from './chatEditingService.js';
-import { ChatEditingModifiedFileEntry } from './chatEditingModifiedFileEntry.js';
-import { ChatEditingTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
+import { ChatEditingModifiedFileEntry } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedFileEntry';
+import { ChatEditingTextModelContentProvider } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTextModelContentProviders';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { isEqual, joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { StringSHA1 } from 'vscode/vscode/vs/base/common/hash';
+import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment.service';
+import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
+import { OffsetEdit } from 'vscode/vscode/vs/editor/common/core/offsetEdit';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { ChatEditingModifiedNotebookEntry } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedNotebookEntry';
+import { isNotebookEditorInput } from '@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
 
+const STORAGE_CONTENTS_FOLDER = 'contents';
+const STORAGE_STATE_FILE = 'state.json';
+class ThrottledSequencer extends Sequencer {
+    constructor(_minDuration, _maxOverallDelay) {
+        super();
+        this._minDuration = _minDuration;
+        this._maxOverallDelay = _maxOverallDelay;
+        this._size = 0;
+    }
+    queue(promiseTask) {
+        this._size += 1;
+        const noDelay = this._size * this._minDuration > this._maxOverallDelay;
+        return super.queue(async () => {
+            try {
+                const p1 = promiseTask();
+                const p2 = noDelay
+                    ? Promise.resolve(undefined)
+                    : timeout(this._minDuration);
+                const [result] = await Promise.all([p1, p2]);
+                return result;
+            }
+            finally {
+                this._size -= 1;
+            }
+        });
+    }
+}
 let ChatEditingSession = class ChatEditingSession extends Disposable {
     get entries() {
         this._assertNotDisposed();
@@ -40,9 +79,9 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
     }
     get workingSet() {
         this._assertNotDisposed();
-        const result = ( (new ResourceMap(this._workingSet)));
+        const result = ( new ResourceMap(this._workingSet));
         for (const entry of this._entriesObs.get()) {
-            result.set(entry.modifiedURI, entry.state.get());
+            result.set(entry.modifiedURI, { state: entry.state.get() });
         }
         return result;
     }
@@ -59,12 +98,11 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
     }
     get isVisible() {
         this._assertNotDisposed();
-        return Boolean(this.editorPane && this.editorPane.isVisible());
+        return Boolean(this._editorPane && this._editorPane.isVisible());
     }
-    constructor(chatSessionId, editorPane, editingSessionFileLimitPromise, _instantiationService, _modelService, _languageService, _textModelService, _bulkEditService, _editorGroupsService, _editorService, _chatWidgetService, _workspaceContextService, _fileService, _dialogService, _chatAgentService) {
+    constructor(chatSessionId, editingSessionFileLimitPromise, _instantiationService, _modelService, _languageService, _textModelService, _bulkEditService, _editorGroupsService, _editorService, _workspaceContextService, _fileService, _dialogService, _chatAgentService, _chatService, _notebookService) {
         super();
         this.chatSessionId = chatSessionId;
-        this.editorPane = editorPane;
         this.editingSessionFileLimitPromise = editingSessionFileLimitPromise;
         this._instantiationService = _instantiationService;
         this._modelService = _modelService;
@@ -73,29 +111,30 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         this._bulkEditService = _bulkEditService;
         this._editorGroupsService = _editorGroupsService;
         this._editorService = _editorService;
-        this._chatWidgetService = _chatWidgetService;
         this._workspaceContextService = _workspaceContextService;
         this._fileService = _fileService;
         this._dialogService = _dialogService;
         this._chatAgentService = _chatAgentService;
-        this._state = observableValue(this, 0 );
+        this._chatService = _chatService;
+        this._notebookService = _notebookService;
+        this._state = observableValue(this, ChatEditingSessionState.Initial);
         this._linearHistory = observableValue(this, []);
         this._linearHistoryIndex = observableValue(this, 0);
-        this._initialFileContents = ( (new ResourceMap()));
-        this._snapshots = ( (new Map()));
-        this._filesToSkipCreating = ( (new ResourceSet()));
+        this._initialFileContents = ( new ResourceMap());
+        this._filesToSkipCreating = ( new ResourceSet());
         this._entriesObs = observableValue(this, []);
-        this._sequencer = ( (new Sequencer()));
-        this._workingSet = ( (new ResourceMap()));
+        this._sequencer = ( new ThrottledSequencer(15, 1000));
+        this._workingSet = ( new ResourceMap());
+        this._removedTransientEntries = ( new ResourceSet());
         this.canUndo = derived((r) => {
-            if (this.state.read(r) !== 2 ) {
+            if (this.state.read(r) !== ChatEditingSessionState.Idle) {
                 return false;
             }
             const linearHistoryIndex = this._linearHistoryIndex.read(r);
             return linearHistoryIndex > 0;
         });
         this.canRedo = derived((r) => {
-            if (this.state.read(r) !== 2 ) {
+            if (this.state.read(r) !== ChatEditingSessionState.Idle) {
                 return false;
             }
             const linearHistory = this._linearHistory.read(r);
@@ -105,76 +144,113 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         this.hiddenRequestIds = derived((r) => {
             const linearHistory = this._linearHistory.read(r);
             const linearHistoryIndex = this._linearHistoryIndex.read(r);
-            return ( (linearHistory.slice(linearHistoryIndex).map(s => s.requestId))).filter((r) => !!r);
+            return ( linearHistory.slice(linearHistoryIndex).map(s => s.requestId)).filter((r) => !!r);
         });
-        this._onDidChange = ( (new Emitter()));
-        this._onDidDispose = ( (new Emitter()));
-        const widget = _chatWidgetService.getWidgetBySessionId(chatSessionId);
-        if (!widget) {
-            return;
+        this._onDidChange = ( new Emitter());
+        this._onDidDispose = ( new Emitter());
+    }
+    async init() {
+        const restoredSessionState = await this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId).restoreState();
+        if (restoredSessionState) {
+            for (const uri of restoredSessionState.filesToSkipCreating) {
+                this._filesToSkipCreating.add(uri);
+            }
+            for (const [uri, content] of restoredSessionState.initialFileContents) {
+                this._initialFileContents.set(uri, content);
+            }
+            this._pendingSnapshot = restoredSessionState.pendingSnapshot;
+            await this._restoreSnapshot(restoredSessionState.recentSnapshot);
+            this._linearHistoryIndex.set(restoredSessionState.linearHistoryIndex, undefined);
+            this._linearHistory.set(restoredSessionState.linearHistory, undefined);
+            this._state.set(ChatEditingSessionState.Idle, undefined);
         }
         this._trackCurrentEditorsInWorkingSet();
-        this._register(this._editorService.onDidActiveEditorChange(() => {
+        this._register(this._editorService.onDidVisibleEditorsChange(() => {
             this._trackCurrentEditorsInWorkingSet();
         }));
-        this._register(this._editorService.onDidCloseEditor((e) => {
-            this._trackCurrentEditorsInWorkingSet(e);
+        this._register(autorun(reader => {
+            const entries = this.entries.read(reader);
+            entries.forEach(entry => {
+                entry.state.read(reader);
+            });
+            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         }));
     }
+    getEntry(uri) {
+        return this._entriesObs.get().find(e => isEqual(e.modifiedURI, uri));
+    }
+    readEntry(uri, reader) {
+        return this._entriesObs.read(reader).find(e => isEqual(e.modifiedURI, uri));
+    }
+    storeState() {
+        const storage = this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId);
+        const state = {
+            filesToSkipCreating: [...this._filesToSkipCreating],
+            initialFileContents: this._initialFileContents,
+            pendingSnapshot: this._pendingSnapshot,
+            recentSnapshot: this._createSnapshot(undefined),
+            linearHistoryIndex: this._linearHistoryIndex.get(),
+            linearHistory: this._linearHistory.get(),
+        };
+        return storage.storeState(state);
+    }
     _trackCurrentEditorsInWorkingSet(e) {
-        const widget = this._chatWidgetService.getWidgetBySessionId(this.chatSessionId);
-        const requests = widget?.viewModel?.getItems();
-        if (requests && requests.length > 0) {
-            return;
-        }
-        const closedEditor = e?.editor.resource?.toString();
-        const existingTransientEntries = ( (new ResourceSet()));
-        for (const file of ( (this._workingSet.keys()))) {
-            if (this._workingSet.get(file) === 3 ) {
+        const existingTransientEntries = ( new ResourceSet());
+        for (const file of ( this._workingSet.keys())) {
+            if (this._workingSet.get(file)?.state === WorkingSetEntryState.Transient) {
                 existingTransientEntries.add(file);
             }
         }
-        if (existingTransientEntries.size === 0 && this._workingSet.size > 0) {
-            return;
-        }
-        const activeEditors = ( (new ResourceSet()));
+        const activeEditors = ( new ResourceSet());
         this._editorGroupsService.groups.forEach((group) => {
             if (!group.activeEditorPane) {
                 return;
             }
-            let activeEditorControl = group.activeEditorPane.getControl();
-            if (isDiffEditor(activeEditorControl)) {
-                activeEditorControl = activeEditorControl.getOriginalEditor().hasTextFocus() ? activeEditorControl.getOriginalEditor() : activeEditorControl.getModifiedEditor();
+            let uri;
+            if (isNotebookEditorInput(group.activeEditorPane.input)) {
+                uri = group.activeEditorPane.input.resource;
             }
-            if (isCodeEditor(activeEditorControl) && activeEditorControl.hasModel()) {
-                const uri = activeEditorControl.getModel().uri;
-                if (closedEditor === ( (uri.toString()))) ;
-                else if (( (existingTransientEntries.has(uri)))) {
-                    existingTransientEntries.delete(uri);
+            else {
+                let activeEditorControl = group.activeEditorPane.getControl();
+                if (isDiffEditor(activeEditorControl)) {
+                    activeEditorControl = activeEditorControl.getOriginalEditor().hasTextFocus() ? activeEditorControl.getOriginalEditor() : activeEditorControl.getModifiedEditor();
                 }
-                else {
-                    activeEditors.add(uri);
+                if ((isCodeEditor(activeEditorControl)) && activeEditorControl.hasModel()) {
+                    uri = activeEditorControl.getModel().uri;
                 }
             }
+            if (!uri) {
+                return;
+            }
+            if (( existingTransientEntries.has(uri))) {
+                existingTransientEntries.delete(uri);
+            }
+            else if (!( this._workingSet.has(uri)) && !( this._removedTransientEntries.has(uri))) {
+                activeEditors.add(uri);
+            }
         });
         let didChange = false;
         for (const entry of existingTransientEntries) {
             didChange = this._workingSet.delete(entry) || didChange;
         }
         for (const entry of activeEditors) {
-            this._workingSet.set(entry, 3 );
+            this._workingSet.set(entry, { state: WorkingSetEntryState.Transient, description: ( localize(4386, "Open Editor")) });
             didChange = true;
         }
         if (didChange) {
-            this._onDidChange.fire();
+            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         }
     }
+    _findSnapshot(requestId) {
+        return this._linearHistory.get().find(s => s.requestId === requestId);
+    }
     createSnapshot(requestId) {
         const snapshot = this._createSnapshot(requestId);
         if (requestId) {
-            this._snapshots.set(requestId, snapshot);
-            for (const workingSetItem of ( (this._workingSet.keys()))) {
-                this._workingSet.set(workingSetItem, 5 );
+            for (const [uri, data] of this._workingSet) {
+                if (data.state !== WorkingSetEntryState.Suggested) {
+                    this._workingSet.set(uri, { state: WorkingSetEntryState.Sent });
+                }
             }
             const linearHistory = this._linearHistory.get();
             const linearHistoryIndex = this._linearHistoryIndex.get();
@@ -190,11 +266,11 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         }
     }
     _createSnapshot(requestId) {
-        const workingSet = ( (new ResourceMap()));
+        const workingSet = ( new ResourceMap());
         for (const [file, state] of this._workingSet) {
             workingSet.set(file, state);
         }
-        const entries = ( (new ResourceMap()));
+        const entries = ( new ResourceMap());
         for (const entry of this._entriesObs.get()) {
             entries.set(entry.modifiedURI, entry.createSnapshot(requestId));
         }
@@ -205,131 +281,153 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         };
     }
     async getSnapshotModel(requestId, snapshotUri) {
-        const entries = this._snapshots.get(requestId)?.entries;
+        const entries = this._findSnapshot(requestId)?.entries;
         if (!entries) {
             return null;
         }
-        const snapshotEntry = [...( (entries.values()))].find((e) => ( (e.snapshotUri.toString())) === ( (snapshotUri.toString())));
+        const snapshotEntry = [...( entries.values())].find((e) => isEqual(e.snapshotUri, snapshotUri));
         if (!snapshotEntry) {
             return null;
         }
         return this._modelService.createModel(snapshotEntry.current, this._languageService.createById(snapshotEntry.languageId), snapshotUri, false);
     }
     getSnapshot(requestId, uri) {
-        const snapshot = this._snapshots.get(requestId);
+        const snapshot = this._findSnapshot(requestId);
         const snapshotEntries = snapshot?.entries;
         return snapshotEntries?.get(uri);
     }
+    getSnapshotUri(requestId, uri) {
+        return this.getSnapshot(requestId, uri)?.snapshotUri;
+    }
     async restoreSnapshot(requestId) {
         if (requestId !== undefined) {
-            const snapshot = this._snapshots.get(requestId);
+            const snapshot = this._findSnapshot(requestId);
             if (snapshot) {
+                if (!this._pendingSnapshot) {
+                    this.createSnapshot(undefined);
+                }
                 await this._restoreSnapshot(snapshot);
             }
         }
         else {
-            await this._restoreSnapshot(undefined);
-        }
-    }
-    async _restoreSnapshot(snapshot) {
-        if (!snapshot) {
             if (!this._pendingSnapshot) {
                 return;
             }
-            snapshot = this._pendingSnapshot;
+            const snapshot = this._pendingSnapshot;
             this._pendingSnapshot = undefined;
+            await this._restoreSnapshot(snapshot);
         }
-        else if (!this._pendingSnapshot) {
-            this.createSnapshot(undefined);
-        }
-        this._workingSet = ( (new ResourceMap()));
+    }
+    async _restoreSnapshot(snapshot) {
+        this._workingSet = ( new ResourceMap());
         snapshot.workingSet.forEach((state, uri) => this._workingSet.set(uri, state));
         for (const entry of this._entriesObs.get()) {
             const snapshotEntry = snapshot.entries.get(entry.modifiedURI);
             if (!snapshotEntry) {
-                const initialContents = this._initialFileContents.get(entry.modifiedURI);
-                if (typeof initialContents === 'string') {
-                    entry.resetToInitialValue(initialContents);
-                }
+                entry.resetToInitialValue();
                 entry.dispose();
             }
         }
         const entriesArr = [];
-        for (const snapshotEntry of ( (snapshot.entries.values()))) {
+        for (const snapshotEntry of ( snapshot.entries.values())) {
             const entry = await this._getOrCreateModifiedFileEntry(snapshotEntry.resource, snapshotEntry.telemetryInfo);
             entry.restoreFromSnapshot(snapshotEntry);
             entriesArr.push(entry);
         }
         this._entriesObs.set(entriesArr, undefined);
     }
-    remove(...uris) {
+    remove(reason, ...uris) {
         this._assertNotDisposed();
         let didRemoveUris = false;
         for (const uri of uris) {
-            didRemoveUris = this._workingSet.delete(uri) || didRemoveUris;
+            const entry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, uri));
+            if (entry) {
+                entry.dispose();
+                const newEntries = this._entriesObs.get().filter(e => !isEqual(e.modifiedURI, uri));
+                this._entriesObs.set(newEntries, undefined);
+                didRemoveUris = true;
+            }
+            const state = this._workingSet.get(uri);
+            if (state !== undefined) {
+                didRemoveUris = this._workingSet.delete(uri) || didRemoveUris;
+                if (reason === WorkingSetEntryRemovalReason.User && (state.state === WorkingSetEntryState.Transient || state.state === WorkingSetEntryState.Suggested)) {
+                    this._removedTransientEntries.add(uri);
+                }
+            }
         }
         if (!didRemoveUris) {
             return;
         }
-        this._onDidChange.fire();
+        this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
     }
     _assertNotDisposed() {
-        if (this._state.get() === 3 ) {
-            throw ( (new BugIndicatingError(`Cannot access a disposed editing session`)));
+        if (this._state.get() === ChatEditingSessionState.Disposed) {
+            throw ( new BugIndicatingError(`Cannot access a disposed editing session`));
         }
     }
     async accept(...uris) {
         this._assertNotDisposed();
         if (uris.length === 0) {
-            await Promise.all(( (this._entriesObs.get().map(entry => entry.accept(undefined)))));
+            await Promise.all(( this._entriesObs.get().map(entry => entry.accept(undefined))));
         }
         for (const uri of uris) {
-            const entry = this._entriesObs.get().find(e => ( (e.modifiedURI.toString())) === ( (uri.toString())));
+            const entry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, uri));
             if (entry) {
                 await entry.accept(undefined);
             }
         }
-        this._onDidChange.fire();
+        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
     }
     async reject(...uris) {
         this._assertNotDisposed();
         if (uris.length === 0) {
-            await Promise.all(( (this._entriesObs.get().map(entry => entry.reject(undefined)))));
+            await Promise.all(( this._entriesObs.get().map(entry => entry.reject(undefined))));
         }
         for (const uri of uris) {
-            const entry = this._entriesObs.get().find(e => ( (e.modifiedURI.toString())) === ( (uri.toString())));
+            const entry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, uri));
             if (entry) {
                 await entry.reject(undefined);
             }
         }
-        this._onDidChange.fire();
+        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
     }
     async show() {
         this._assertNotDisposed();
-        if (this.editorPane?.isVisible()) {
-            return;
-        }
-        else if (this.editorPane?.input) {
-            await this._editorGroupsService.activeGroup.openEditor(this.editorPane.input, { pinned: true, activation: EditorActivation.ACTIVATE });
-            return;
+        if (this._editorPane) {
+            if (this._editorPane.isVisible()) {
+                return;
+            }
+            else if (this._editorPane.input) {
+                await this._editorGroupsService.activeGroup.openEditor(this._editorPane.input, { pinned: true, activation: EditorActivation.ACTIVATE });
+                return;
+            }
         }
         const input = MultiDiffEditorInput.fromResourceMultiDiffEditorInput({
             multiDiffSource: ChatEditingMultiDiffSourceResolver.getMultiDiffSourceUri(),
-            label: ( localize(7701, "Suggested Edits"))
+            label: ( localize(4387, "Suggested Edits"))
         }, this._instantiationService);
-        const editorPane = await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
-        this.editorPane = editorPane;
+        this._editorPane = await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
     }
-    async stop() {
-        this._assertNotDisposed();
-        await Promise.allSettled(( (this._editorGroupsService.groups.map(async (g) => {
-            return Promise.allSettled(( (g.editors.map(async (e) => {
-                if (e instanceof MultiDiffEditorInput || e instanceof DiffEditorInput && (e.original.resource?.scheme === ChatEditingModifiedFileEntry.scheme || e.original.resource?.scheme === ChatEditingTextModelContentProvider.scheme)) {
+    async stop(clearState = false) {
+        if (!this.stopPromise) {
+            this.stopPromise = this._performStop();
+        }
+        await this.stopPromise;
+        if (clearState) {
+            await this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId).clearState();
+        }
+    }
+    async _performStop() {
+        const schemes = [ChatEditingModifiedFileEntry.scheme, ChatEditingTextModelContentProvider.scheme];
+        await Promise.allSettled(this._editorGroupsService.groups.flatMap(async (g) => {
+            return ( g.editors.map(async (e) => {
+                if ((e instanceof MultiDiffEditorInput && e.initialResources?.some(r => r.originalUri && schemes.indexOf(r.originalUri.scheme) !== -1))
+                    || (e instanceof DiffEditorInput && e.original.resource && schemes.indexOf(e.original.resource.scheme) !== -1)) {
                     await g.closeEditor(e);
                 }
-            }))));
-        }))));
-        if (this._state.get() !== 3 ) {
+            }));
+        }));
+        if (this._state.get() !== ChatEditingSessionState.Disposed) {
             this.dispose();
         }
     }
@@ -339,84 +437,93 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             entry.dispose();
         }
         super.dispose();
-        this._state.set(3 , undefined);
+        this._state.set(ChatEditingSessionState.Disposed, undefined);
         this._onDidDispose.fire();
     }
     getVirtualModel(documentId) {
         this._assertNotDisposed();
         const entry = this._entriesObs.get().find(e => e.entryId === documentId);
-        return entry?.docSnapshot ?? null;
+        return entry?.originalModel ?? null;
     }
     acceptStreamingEditsStart() {
-        if (this._state.get() === 3 ) {
+        if (this._state.get() === ChatEditingSessionState.Disposed) {
             return;
         }
         this._sequencer.queue(() => this._acceptStreamingEditsStart());
     }
-    acceptTextEdits(resource, textEdits, responseModel) {
-        if (this._state.get() === 3 ) {
+    acceptTextEdits(resource, textEdits, isLastEdits, responseModel) {
+        if (this._state.get() === ChatEditingSessionState.Disposed) {
             return;
         }
-        this._sequencer.queue(() => this._acceptTextEdits(resource, textEdits, responseModel));
+        this._sequencer.queue(() => this._acceptTextEdits(resource, textEdits, isLastEdits, responseModel));
     }
     resolve() {
-        if (this._state.get() === 3 ) {
+        if (this._state.get() === ChatEditingSessionState.Disposed) {
             return;
         }
         this._sequencer.queue(() => this._resolve());
     }
-    addFileToWorkingSet(resource) {
-        if (!( (this._workingSet.has(resource)))) {
-            this._workingSet.set(resource, 4 );
-            for (const file of ( (this._workingSet.keys()))) {
-                if (this._workingSet.get(file) === 3 ) {
-                    this._workingSet.set(file, 4 );
-                }
+    addFileToWorkingSet(resource, description, proposedState) {
+        const state = this._workingSet.get(resource);
+        if (proposedState === WorkingSetEntryState.Suggested) {
+            if (state !== undefined || ( this._removedTransientEntries.has(resource))) {
+                return;
             }
-            this._onDidChange.fire();
+            this._workingSet.set(resource, { description, state: WorkingSetEntryState.Suggested });
+            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
+        }
+        else if (state === undefined || state.state === WorkingSetEntryState.Transient || state.state === WorkingSetEntryState.Suggested) {
+            this._workingSet.set(resource, { description, state: WorkingSetEntryState.Attached });
+            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         }
     }
     async undoInteraction() {
         const linearHistory = this._linearHistory.get();
-        const linearHistoryIndex = this._linearHistoryIndex.get();
-        if (linearHistoryIndex <= 0) {
+        const newIndex = this._linearHistoryIndex.get() - 1;
+        if (newIndex < 0) {
             return;
         }
-        const previousSnapshot = linearHistory[linearHistoryIndex - 1];
+        const previousSnapshot = linearHistory[newIndex];
         await this.restoreSnapshot(previousSnapshot.requestId);
-        this._linearHistoryIndex.set(linearHistoryIndex - 1, undefined);
+        this._linearHistoryIndex.set(newIndex, undefined);
+        this._updateRequestHiddenState();
     }
     async redoInteraction() {
         const linearHistory = this._linearHistory.get();
-        const linearHistoryIndex = this._linearHistoryIndex.get();
-        if (linearHistoryIndex >= linearHistory.length) {
+        const newIndex = this._linearHistoryIndex.get() + 1;
+        if (newIndex > linearHistory.length) {
             return;
         }
-        const nextSnapshot = (linearHistoryIndex + 1 < linearHistory.length ? linearHistory[linearHistoryIndex + 1] : this._pendingSnapshot);
+        const nextSnapshot = newIndex < linearHistory.length ? linearHistory[newIndex] : this._pendingSnapshot;
         if (!nextSnapshot) {
             return;
         }
         await this.restoreSnapshot(nextSnapshot.requestId);
-        this._linearHistoryIndex.set(linearHistoryIndex + 1, undefined);
+        this._linearHistoryIndex.set(newIndex, undefined);
+        this._updateRequestHiddenState();
+    }
+    _updateRequestHiddenState() {
+        const hiddenRequestIds = ( this._linearHistory.get().slice(this._linearHistoryIndex.get()).map(s => s.requestId)).filter((r) => !!r);
+        this._chatService.getSession(this.chatSessionId)?.disableRequests(hiddenRequestIds);
     }
     async _acceptStreamingEditsStart() {
         transaction((tx) => {
-            this._state.set(1 , tx);
+            this._state.set(ChatEditingSessionState.StreamingEdits, tx);
             for (const entry of this._entriesObs.get()) {
                 entry.acceptStreamingEditsStart(tx);
             }
         });
     }
-    async _acceptTextEdits(resource, textEdits, responseModel) {
-        if (( (this._filesToSkipCreating.has(resource)))) {
+    async _acceptTextEdits(resource, textEdits, isLastEdits, responseModel) {
+        if (( this._filesToSkipCreating.has(resource))) {
             return;
         }
-        if (!this._entriesObs.get().find(e => ( (e.resource.toString())) === ( (resource.toString()))) && this._entriesObs.get().length >= (await this.editingSessionFileLimitPromise)) {
+        if (!this._entriesObs.get().find(e => isEqual(e.modifiedURI, resource)) && this._entriesObs.get().length >= (await this.editingSessionFileLimitPromise)) {
             return;
         }
         if (resource.scheme !== Schemas.untitled && !this._workspaceContextService.getWorkspaceFolder(resource) && !(await this._fileService.exists(resource))) {
             const saveLocation = await this._dialogService.showSaveDialog({ title: ( localize(
-                7702,
+                4388,
                 '{0} wants to create a file. Choose where it should be saved.',
                 this._chatAgentService.getDefaultAgent(ChatAgentLocation.EditingSession)?.fullName ?? 'Chat'
             )) });
@@ -434,44 +541,50 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             get result() { return responseModel.result; }
         };
         const entry = await this._getOrCreateModifiedFileEntry(resource, telemetryInfo);
-        entry.acceptAgentEdits(textEdits);
+        entry.acceptAgentEdits(textEdits, isLastEdits);
     }
     async _resolve() {
         transaction((tx) => {
             for (const entry of this._entriesObs.get()) {
                 entry.acceptStreamingEditsEnd(tx);
             }
-            this._state.set(2 , tx);
+            this._state.set(ChatEditingSessionState.Idle, tx);
         });
-        this._onDidChange.fire();
+        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
     }
     async _getOrCreateModifiedFileEntry(resource, responseModel) {
-        const existingEntry = this._entriesObs.get().find(e => ( (e.resource.toString())) === ( (resource.toString())));
+        const existingEntry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, resource));
         if (existingEntry) {
             if (responseModel.requestId !== existingEntry.telemetryInfo.requestId) {
                 existingEntry.updateTelemetryInfo(responseModel);
             }
             return existingEntry;
         }
-        const entry = await this._createModifiedFileEntry(resource, responseModel);
-        if (!( (this._initialFileContents.has(resource)))) {
-            this._initialFileContents.set(resource, entry.modifiedModel.getValue());
+        const initialContent = this._initialFileContents.get(resource);
+        const entry = await this._createModifiedFileEntry(resource, responseModel, false, initialContent);
+        if (!initialContent) {
+            this._initialFileContents.set(resource, entry.initialContent);
         }
         this._register(entry.onDidDelete(() => {
-            const newEntries = this._entriesObs.get().filter(e => ( (e.modifiedURI.toString())) !== ( (entry.modifiedURI.toString())));
+            const newEntries = this._entriesObs.get().filter(e => !isEqual(e.modifiedURI, entry.modifiedURI));
             this._entriesObs.set(newEntries, undefined);
             this._workingSet.delete(entry.modifiedURI);
-            this._onDidChange.fire();
+            this._editorService.closeEditors(this._editorService.findEditors(entry.modifiedURI));
+            entry.dispose();
+            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         }));
         const entriesArr = [...this._entriesObs.get(), entry];
         this._entriesObs.set(entriesArr, undefined);
-        this._onDidChange.fire();
+        this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         return entry;
     }
-    async _createModifiedFileEntry(resource, responseModel, mustExist = false) {
+    async _createModifiedFileEntry(resource, responseModel, mustExist = false, initialContent) {
         try {
             const ref = await this._textModelService.createModelReference(resource);
-            return this._instantiationService.createInstance(ChatEditingModifiedFileEntry, resource, ref, { collapse: (transaction) => this._collapse(resource, transaction) }, responseModel, mustExist ? 0  : 1 );
+            if (this._notebookService.hasSupportedNotebooks(resource)) {
+                return this._instantiationService.createInstance(ChatEditingModifiedNotebookEntry, ref, { collapse: (transaction) => this._collapse(resource, transaction) }, responseModel, mustExist ? ChatEditKind.Created : ChatEditKind.Modified, initialContent);
+            }
+            return this._instantiationService.createInstance(ChatEditingModifiedFileEntry, ref, { collapse: (transaction) => this._collapse(resource, transaction) }, responseModel, mustExist ? ChatEditKind.Created : ChatEditKind.Modified, initialContent);
         }
         catch (err) {
             if (mustExist) {
@@ -479,29 +592,209 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             }
             await this._bulkEditService.apply({ edits: [{ newResource: resource }] });
             this._editorService.openEditor({ resource, options: { inactive: true, preserveFocus: true, pinned: true } });
-            return this._createModifiedFileEntry(resource, responseModel, true);
+            return this._createModifiedFileEntry(resource, responseModel, true, initialContent);
         }
     }
     _collapse(resource, transaction) {
-        const multiDiffItem = this.editorPane?.findDocumentDiffItem(resource);
+        const multiDiffItem = this._editorPane?.findDocumentDiffItem(resource);
         if (multiDiffItem) {
-            this.editorPane?.viewModel?.items.get().find((documentDiffItem) => String(documentDiffItem.originalUri) === String(multiDiffItem.originalUri) && String(documentDiffItem.modifiedUri) === String(multiDiffItem.modifiedUri))?.collapsed.set(true, transaction);
+            this._editorPane?.viewModel?.items.get().find((documentDiffItem) => isEqual(documentDiffItem.originalUri, multiDiffItem.originalUri) &&
+                isEqual(documentDiffItem.modifiedUri, multiDiffItem.modifiedUri))
+                ?.collapsed.set(true, transaction);
+        }
+    }
+};
+ChatEditingSession = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IModelService)),
+    ( __param(4, ILanguageService)),
+    ( __param(5, ITextModelService)),
+    ( __param(6, IBulkEditService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, IWorkspaceContextService)),
+    ( __param(10, IFileService)),
+    ( __param(11, IFileDialogService)),
+    ( __param(12, IChatAgentService)),
+    ( __param(13, IChatService)),
+    ( __param(14, INotebookService))
+], ChatEditingSession));
+let ChatEditingSessionStorage = class ChatEditingSessionStorage {
+    constructor(chatSessionId, _fileService, _environmentService, _logService, _workspaceContextService) {
+        this.chatSessionId = chatSessionId;
+        this._fileService = _fileService;
+        this._environmentService = _environmentService;
+        this._logService = _logService;
+        this._workspaceContextService = _workspaceContextService;
+    }
+    _getStorageLocation() {
+        const workspaceId = this._workspaceContextService.getWorkspace().id;
+        return joinPath(this._environmentService.workspaceStorageHome, workspaceId, 'chatEditingSessions', this.chatSessionId);
+    }
+    async restoreState() {
+        const storageLocation = this._getStorageLocation();
+        const getFileContent = (hash) => {
+            return this._fileService.readFile(joinPath(storageLocation, STORAGE_CONTENTS_FOLDER, hash)).then(content => ( content.value.toString()));
+        };
+        const deserializeResourceMap = (resourceMap, deserialize, result) => {
+            resourceMap.forEach(([resourceURI, value]) => {
+                result.set(( URI.parse(resourceURI)), deserialize(value));
+            });
+            return result;
+        };
+        const deserializeChatEditingSessionSnapshot = async (snapshot) => {
+            const entriesMap = ( new ResourceMap());
+            for (const entryDTO of snapshot.entries) {
+                const entry = await deserializeSnapshotEntry(entryDTO);
+                entriesMap.set(entry.resource, entry);
+            }
+            return ({
+                requestId: snapshot.requestId,
+                workingSet: deserializeResourceMap(snapshot.workingSet, (value) => value, ( new ResourceMap())),
+                entries: entriesMap
+            });
+        };
+        const deserializeSnapshotEntry = async (entry) => {
+            return {
+                resource: ( URI.parse(entry.resource)),
+                languageId: entry.languageId,
+                original: await getFileContent(entry.originalHash),
+                current: await getFileContent(entry.currentHash),
+                originalToCurrentEdit: OffsetEdit.fromJson(entry.originalToCurrentEdit),
+                state: entry.state,
+                snapshotUri: ( URI.parse(entry.snapshotUri)),
+                telemetryInfo: { requestId: entry.telemetryInfo.requestId, agentId: entry.telemetryInfo.agentId, command: entry.telemetryInfo.command, sessionId: this.chatSessionId, result: undefined }
+            };
+        };
+        try {
+            const stateFilePath = joinPath(storageLocation, STORAGE_STATE_FILE);
+            if (!(await this._fileService.exists(stateFilePath))) {
+                this._logService.debug(`chatEditingSession: No editing session state found at ${( stateFilePath.toString())}`);
+                return undefined;
+            }
+            this._logService.debug(`chatEditingSession: Restoring editing session at ${( stateFilePath.toString())}`);
+            const stateFileContent = await this._fileService.readFile(stateFilePath);
+            const data = JSON.parse(( stateFileContent.value.toString()));
+            if (data.version !== STORAGE_VERSION) {
+                return undefined;
+            }
+            const linearHistory = await Promise.all(( data.linearHistory.map(deserializeChatEditingSessionSnapshot)));
+            const filesToSkipCreating = ( data.filesToSkipCreating.map((uriStr) => ( URI.parse(uriStr))));
+            const initialFileContents = ( new ResourceMap());
+            for (const fileContentDTO of data.initialFileContents) {
+                initialFileContents.set(( URI.parse(fileContentDTO[0])), await getFileContent(fileContentDTO[1]));
+            }
+            const pendingSnapshot = data.pendingSnapshot ? await deserializeChatEditingSessionSnapshot(data.pendingSnapshot) : undefined;
+            const recentSnapshot = await deserializeChatEditingSessionSnapshot(data.recentSnapshot);
+            return {
+                filesToSkipCreating,
+                initialFileContents,
+                pendingSnapshot,
+                recentSnapshot,
+                linearHistoryIndex: data.linearHistoryIndex,
+                linearHistory
+            };
+        }
+        catch (e) {
+            this._logService.error(`Error restoring chat editing session from ${( storageLocation.toString())}`, e);
+        }
+        return undefined;
+    }
+    async storeState(state) {
+        const storageFolder = this._getStorageLocation();
+        const contentsFolder = URI.joinPath(storageFolder, STORAGE_CONTENTS_FOLDER);
+        const existingContents = ( new Set());
+        try {
+            const stat = await this._fileService.resolve(contentsFolder);
+            stat.children?.forEach(child => {
+                if (child.isDirectory) {
+                    existingContents.add(child.name);
+                }
+            });
+        }
+        catch (e) {
+            try {
+                await this._fileService.createFolder(contentsFolder);
+            }
+            catch (e) {
+                this._logService.error(`Error creating chat editing session content folder ${( contentsFolder.toString())}`, e);
+                return;
+            }
+        }
+        const fileContents = ( new Map());
+        const addFileContent = (content) => {
+            const shaComputer = ( new StringSHA1());
+            shaComputer.update(content);
+            const sha = shaComputer.digest().substring(0, 7);
+            if (!( existingContents.has(sha))) {
+                fileContents.set(sha, content);
+            }
+            return sha;
+        };
+        const serializeResourceMap = (resourceMap, serialize) => {
+            return ( Array.from(resourceMap.entries()).map(([resourceURI, value]) => [( resourceURI.toString()), serialize(value)]));
+        };
+        const serializeChatEditingSessionSnapshot = (snapshot) => {
+            return ({
+                requestId: snapshot.requestId,
+                workingSet: serializeResourceMap(snapshot.workingSet, value => value),
+                entries: ( Array.from(( snapshot.entries.values())).map(serializeSnapshotEntry))
+            });
+        };
+        const serializeSnapshotEntry = (entry) => {
+            return {
+                resource: ( entry.resource.toString()),
+                languageId: entry.languageId,
+                originalHash: addFileContent(entry.original),
+                currentHash: addFileContent(entry.current),
+                originalToCurrentEdit: ( entry.originalToCurrentEdit.edits.map(
+                    edit => ({ pos: edit.replaceRange.start, len: edit.replaceRange.length, txt: edit.newText })
+                )),
+                state: entry.state,
+                snapshotUri: ( entry.snapshotUri.toString()),
+                telemetryInfo: { requestId: entry.telemetryInfo.requestId, agentId: entry.telemetryInfo.agentId, command: entry.telemetryInfo.command }
+            };
+        };
+        try {
+            const data = {
+                version: STORAGE_VERSION,
+                sessionId: this.chatSessionId,
+                linearHistory: ( state.linearHistory.map(serializeChatEditingSessionSnapshot)),
+                linearHistoryIndex: state.linearHistoryIndex,
+                initialFileContents: serializeResourceMap(state.initialFileContents, value => addFileContent(value)),
+                pendingSnapshot: state.pendingSnapshot ? serializeChatEditingSessionSnapshot(state.pendingSnapshot) : undefined,
+                recentSnapshot: serializeChatEditingSessionSnapshot(state.recentSnapshot),
+                filesToSkipCreating: ( state.filesToSkipCreating.map(uri => ( uri.toString()))),
+            };
+            this._logService.debug(`chatEditingSession: Storing editing session at ${( storageFolder.toString())}: ${fileContents.size} files`);
+            for (const [hash, content] of fileContents) {
+                await this._fileService.writeFile(joinPath(contentsFolder, hash), VSBuffer.fromString(content));
+            }
+            await this._fileService.writeFile(joinPath(storageFolder, STORAGE_STATE_FILE), VSBuffer.fromString(JSON.stringify(data, undefined, 2)));
+        }
+        catch (e) {
+            this._logService.debug(`Error storing chat editing session to ${( storageFolder.toString())}`, e);
+        }
+    }
+    async clearState() {
+        const storageFolder = this._getStorageLocation();
+        if (await this._fileService.exists(storageFolder)) {
+            this._logService.debug(`chatEditingSession: Clearing editing session at ${( storageFolder.toString())}`);
+            try {
+                await this._fileService.del(storageFolder, { recursive: true });
+            }
+            catch (e) {
+                this._logService.debug(`Error clearing chat editing session from ${( storageFolder.toString())}`, e);
+            }
         }
     }
 };
-ChatEditingSession = ( (__decorate([
-    ( (__param(3, IInstantiationService))),
-    ( (__param(4, IModelService))),
-    ( (__param(5, ILanguageService))),
-    ( (__param(6, ITextModelService))),
-    ( (__param(7, IBulkEditService))),
-    ( (__param(8, IEditorGroupsService))),
-    ( (__param(9, IEditorService))),
-    ( (__param(10, IChatWidgetService))),
-    ( (__param(11, IWorkspaceContextService))),
-    ( (__param(12, IFileService))),
-    ( (__param(13, IFileDialogService))),
-    ( (__param(14, IChatAgentService)))
-], ChatEditingSession)));
+ChatEditingSessionStorage = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, IEnvironmentService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IWorkspaceContextService))
+], ChatEditingSessionStorage));
+const STORAGE_VERSION = 1;
 
 export { ChatEditingSession };