@codingame/monaco-vscode-chat-service-override 14.0.6 → 15.0.0

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

@@ -1,871 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Sequencer, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
-import { Disposable, DisposableMap, dispose, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { observableValue, transaction, asyncTransaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { autorun, autorunDelta, autorunIterableDelta } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
-import { isEqual, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { isDiffEditor, isCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
-import { IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService';
-import { OffsetEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/offsetEdit';
-import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language';
-import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model';
-import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
-import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.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 { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
-import { DiffEditorInput } from '@codingame/monaco-vscode-4a28f637-7c3c-5e48-a77c-1b7538b38850-common/vscode/vs/workbench/common/editor/diffEditorInput';
-import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
-import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
-import { MultiDiffEditorInput } from '@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
-import { isNotebookEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
-import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { ChatEditingSessionState, ChatEditingSessionChangeType, WorkingSetEntryState, WorkingSetEntryRemovalReason, getMultiDiffSourceUri, ChatEditKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { ChatEditingModifiedFileEntry } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedFileEntry';
-import { ChatEditingModifiedNotebookEntry } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedNotebookEntry';
-import { ChatEditingTextModelContentProvider } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTextModelContentProviders';
-
-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();
-        return this._entriesObs;
-    }
-    get workingSet() {
-        this._assertNotDisposed();
-        const result = ( new ResourceMap(this._workingSet));
-        for (const entry of this._entriesObs.get()) {
-            result.set(entry.modifiedURI, { state: entry.state.get() });
-        }
-        return result;
-    }
-    get state() {
-        return this._state;
-    }
-    get onDidChange() {
-        this._assertNotDisposed();
-        return this._onDidChange.event;
-    }
-    get onDidDispose() {
-        this._assertNotDisposed();
-        return this._onDidDispose.event;
-    }
-    get isToolsAgentSession() {
-        return this._isToolsAgentSession;
-    }
-    constructor(chatSessionId, isGlobalEditingSession, editingSessionFileLimitPromise, _lookupExternalEntry, _instantiationService, _modelService, _languageService, _textModelService, _bulkEditService, _editorGroupsService, _editorService, _chatService, _notebookService, _textFileService, _chatAgentService) {
-        super();
-        this.chatSessionId = chatSessionId;
-        this.isGlobalEditingSession = isGlobalEditingSession;
-        this.editingSessionFileLimitPromise = editingSessionFileLimitPromise;
-        this._lookupExternalEntry = _lookupExternalEntry;
-        this._instantiationService = _instantiationService;
-        this._modelService = _modelService;
-        this._languageService = _languageService;
-        this._textModelService = _textModelService;
-        this._bulkEditService = _bulkEditService;
-        this._editorGroupsService = _editorGroupsService;
-        this._editorService = _editorService;
-        this._chatService = _chatService;
-        this._notebookService = _notebookService;
-        this._textFileService = _textFileService;
-        this._chatAgentService = _chatAgentService;
-        this._state = observableValue(this, ChatEditingSessionState.Initial);
-        this._linearHistory = observableValue(this, []);
-        this._linearHistoryIndex = observableValue(this, 0);
-        this._initialFileContents = ( new ResourceMap());
-        this._entriesObs = observableValue(this, []);
-        this._sequencer = ( new ThrottledSequencer(15, 1000));
-        this._workingSet = ( new ResourceMap());
-        this._removedTransientEntries = ( new ResourceSet());
-        this.canUndo = derived((r) => {
-            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) !== ChatEditingSessionState.Idle) {
-                return false;
-            }
-            const linearHistory = this._linearHistory.read(r);
-            const linearHistoryIndex = this._linearHistoryIndex.read(r);
-            return linearHistoryIndex < linearHistory.length;
-        });
-        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);
-        });
-        this._onDidChange = this._register(( new Emitter()));
-        this._onDidDispose = ( new Emitter());
-        this._isToolsAgentSession = false;
-    }
-    async init() {
-        const restoredSessionState = await this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId).restoreState();
-        if (restoredSessionState) {
-            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._triggerSaveParticipantsOnAccept();
-        this._register(this._editorService.onDidVisibleEditorsChange(() => {
-            this._trackCurrentEditorsInWorkingSet();
-        }));
-        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 = {
-            initialFileContents: this._initialFileContents,
-            pendingSnapshot: this._pendingSnapshot,
-            recentSnapshot: this._createSnapshot(undefined),
-            linearHistoryIndex: this._linearHistoryIndex.get(),
-            linearHistory: this._linearHistory.get(),
-        };
-        return storage.storeState(state);
-    }
-    _triggerSaveParticipantsOnAccept() {
-        const im = this._register(( new DisposableMap()));
-        const attachToEntry = (entry) => {
-            return autorunDelta(entry.state, ({ lastValue, newValue }) => {
-                if (newValue === WorkingSetEntryState.Accepted && lastValue === WorkingSetEntryState.Modified) {
-                    if (!this._textFileService.isDirty(entry.modifiedURI)) {
-                        this._textFileService.save(entry.modifiedURI, {
-                            reason: SaveReason.EXPLICIT,
-                            force: true,
-                            ignoreErrorHandler: true,
-                        }).catch(() => {
-                        });
-                    }
-                }
-            });
-        };
-        this._register(autorunIterableDelta(reader => this._entriesObs.read(reader), ({ addedValues, removedValues }) => {
-            for (const entry of addedValues) {
-                im.set(entry, attachToEntry(entry));
-            }
-            for (const entry of removedValues) {
-                im.deleteAndDispose(entry);
-            }
-        }));
-    }
-    _trackCurrentEditorsInWorkingSet(e) {
-        const existingTransientEntries = ( new ResourceSet());
-        for (const file of ( this._workingSet.keys())) {
-            if (this._workingSet.get(file)?.state === WorkingSetEntryState.Transient) {
-                existingTransientEntries.add(file);
-            }
-        }
-        const activeEditors = ( new ResourceSet());
-        this._editorGroupsService.groups.forEach((group) => {
-            if (!group.activeEditorPane) {
-                return;
-            }
-            let uri;
-            if (isNotebookEditorInput(group.activeEditorPane.input)) {
-                uri = group.activeEditorPane.input.resource;
-            }
-            else {
-                let activeEditorControl = group.activeEditorPane.getControl();
-                if (isDiffEditor(activeEditorControl)) {
-                    activeEditorControl = activeEditorControl.getOriginalEditor().hasTextFocus() ? activeEditorControl.getOriginalEditor() : activeEditorControl.getModifiedEditor();
-                }
-                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._workingSet.get(uri)?.state === WorkingSetEntryState.Suggested) && !( 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, { state: WorkingSetEntryState.Transient, description: ( localize(4504, "Open Editor")) });
-            didChange = true;
-        }
-        if (didChange) {
-            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) {
-            for (const [uri, data] of this._workingSet) {
-                if (data.state !== WorkingSetEntryState.Suggested) {
-                    this._workingSet.set(uri, { state: WorkingSetEntryState.Sent, isMarkedReadonly: data.isMarkedReadonly });
-                }
-            }
-            const linearHistory = this._linearHistory.get();
-            const linearHistoryIndex = this._linearHistoryIndex.get();
-            const newLinearHistory = linearHistory.slice(0, linearHistoryIndex);
-            newLinearHistory.push(snapshot);
-            transaction((tx) => {
-                this._linearHistory.set(newLinearHistory, tx);
-                this._linearHistoryIndex.set(newLinearHistory.length, tx);
-            });
-        }
-        else {
-            this._pendingSnapshot = snapshot;
-        }
-    }
-    _createSnapshot(requestId) {
-        const workingSet = ( new ResourceMap());
-        for (const [file, state] of this._workingSet) {
-            workingSet.set(file, state);
-        }
-        const entries = ( new ResourceMap());
-        for (const entry of this._entriesObs.get()) {
-            entries.set(entry.modifiedURI, entry.createSnapshot(requestId));
-        }
-        return {
-            requestId,
-            workingSet,
-            entries
-        };
-    }
-    async getSnapshotModel(requestId, snapshotUri) {
-        const entries = this._findSnapshot(requestId)?.entries;
-        if (!entries) {
-            return null;
-        }
-        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._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._findSnapshot(requestId);
-            if (snapshot) {
-                if (!this._pendingSnapshot) {
-                    this.createSnapshot(undefined);
-                }
-                await this._restoreSnapshot(snapshot);
-            }
-        }
-        else {
-            if (!this._pendingSnapshot) {
-                return;
-            }
-            const snapshot = this._pendingSnapshot;
-            this._pendingSnapshot = undefined;
-            await this._restoreSnapshot(snapshot);
-        }
-    }
-    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) {
-                entry.resetToInitialValue();
-                entry.dispose();
-            }
-        }
-        const entriesArr = [];
-        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(reason, ...uris) {
-        this._assertNotDisposed();
-        let didRemoveUris = false;
-        for (const uri of uris) {
-            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(ChatEditingSessionChangeType.WorkingSet);
-    }
-    markIsReadonly(resource, isReadonly) {
-        const entry = this._workingSet.get(resource);
-        if (entry) {
-            if (entry.state === WorkingSetEntryState.Transient || entry.state === WorkingSetEntryState.Suggested) {
-                entry.state = WorkingSetEntryState.Attached;
-            }
-            entry.isMarkedReadonly = isReadonly ?? !entry.isMarkedReadonly;
-        }
-        else {
-            this._workingSet.set(resource, {
-                state: WorkingSetEntryState.Attached,
-                isMarkedReadonly: isReadonly ?? true
-            });
-        }
-        this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
-    }
-    _assertNotDisposed() {
-        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))));
-        }
-        for (const uri of uris) {
-            const entry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, uri));
-            if (entry) {
-                await entry.accept(undefined);
-            }
-        }
-        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))));
-        }
-        for (const uri of uris) {
-            const entry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, uri));
-            if (entry) {
-                await entry.reject(undefined);
-            }
-        }
-        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
-    }
-    async show() {
-        this._assertNotDisposed();
-        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: getMultiDiffSourceUri(),
-            label: ( localize(4505, "Suggested Edits"))
-        }, this._instantiationService);
-        this._editorPane = await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
-    }
-    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() !== ChatEditingSessionState.Disposed) {
-            this.dispose();
-        }
-    }
-    dispose() {
-        this._assertNotDisposed();
-        this._chatService.cancelCurrentRequestForSession(this.chatSessionId);
-        dispose(this._entriesObs.get());
-        super.dispose();
-        this._state.set(ChatEditingSessionState.Disposed, undefined);
-        this._onDidDispose.fire();
-        this._onDidDispose.dispose();
-    }
-    getVirtualModel(documentId) {
-        this._assertNotDisposed();
-        const entry = this._entriesObs.get().find(e => e.entryId === documentId);
-        return entry?.originalModel ?? null;
-    }
-    acceptStreamingEditsStart() {
-        if (this._state.get() === ChatEditingSessionState.Disposed) {
-            return;
-        }
-        this._sequencer.queue(() => this._acceptStreamingEditsStart());
-    }
-    acceptTextEdits(resource, textEdits, isLastEdits, responseModel) {
-        if (this._state.get() === ChatEditingSessionState.Disposed) {
-            return;
-        }
-        this._isToolsAgentSession = !!responseModel.agent?.isToolsAgent;
-        this._sequencer.queue(() => this._acceptTextEdits(resource, textEdits, isLastEdits, responseModel));
-    }
-    resolve() {
-        if (this._state.get() === ChatEditingSessionState.Disposed) {
-            return;
-        }
-        this._sequencer.queue(() => this._resolve());
-    }
-    _trackUntitledWorkingSetEntry(resource) {
-        if (resource.scheme !== Schemas.untitled) {
-            return;
-        }
-        const untitled = this._textFileService.untitled.get(resource);
-        if (!untitled) {
-            return;
-        }
-        const store = ( new DisposableStore());
-        store.add(this.onDidChange(e => {
-            if (e === ChatEditingSessionChangeType.WorkingSet && !this._workingSet.get(resource)) {
-                store.dispose();
-            }
-        }));
-        store.add(this._textFileService.untitled.onDidSave(e => {
-            const existing = this._workingSet.get(resource);
-            if (isEqual(e.source, resource) && existing) {
-                this._workingSet.delete(resource);
-                this._workingSet.set(e.target, existing);
-                store.dispose();
-                this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
-            }
-        }));
-        store.add(this._editorService.onDidCloseEditor((e) => {
-            if (isEqual(e.editor.resource, resource)) {
-                this._workingSet.delete(resource);
-                store.dispose();
-                this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
-            }
-        }));
-        this._store.add(store);
-    }
-    addFileToWorkingSet(resource, description, proposedState) {
-        const state = this._workingSet.get(resource);
-        if (proposedState === WorkingSetEntryState.Suggested) {
-            if (state !== undefined || ( this._removedTransientEntries.has(resource))) {
-                return;
-            }
-            this._workingSet.set(resource, { description, state: WorkingSetEntryState.Suggested });
-            this._trackUntitledWorkingSetEntry(resource);
-            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._trackUntitledWorkingSetEntry(resource);
-            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
-        }
-    }
-    async undoInteraction() {
-        const linearHistory = this._linearHistory.get();
-        const newIndex = this._linearHistoryIndex.get() - 1;
-        if (newIndex < 0) {
-            return;
-        }
-        const previousSnapshot = linearHistory[newIndex];
-        await this.restoreSnapshot(previousSnapshot.requestId);
-        this._linearHistoryIndex.set(newIndex, undefined);
-        this._updateRequestHiddenState();
-    }
-    async redoInteraction() {
-        const linearHistory = this._linearHistory.get();
-        const newIndex = this._linearHistoryIndex.get() + 1;
-        if (newIndex > linearHistory.length) {
-            return;
-        }
-        const nextSnapshot = newIndex < linearHistory.length ? linearHistory[newIndex] : this._pendingSnapshot;
-        if (!nextSnapshot) {
-            return;
-        }
-        await this.restoreSnapshot(nextSnapshot.requestId);
-        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(ChatEditingSessionState.StreamingEdits, tx);
-            for (const entry of this._entriesObs.get()) {
-                entry.acceptStreamingEditsStart(tx);
-            }
-        });
-    }
-    async _acceptTextEdits(resource, textEdits, isLastEdits, responseModel) {
-        if (!this._chatAgentService.toolsAgentModeEnabled && !this._entriesObs.get().find(e => isEqual(e.modifiedURI, resource)) && this._entriesObs.get().length >= (await this.editingSessionFileLimitPromise)) {
-            return;
-        }
-        const telemetryInfo = new class {
-            get agentId() { return responseModel.agent?.id; }
-            get command() { return responseModel.slashCommand?.name; }
-            get sessionId() { return responseModel.session.sessionId; }
-            get requestId() { return responseModel.requestId; }
-            get result() { return responseModel.result; }
-        };
-        const entry = await this._getOrCreateModifiedFileEntry(resource, telemetryInfo);
-        entry.acceptAgentEdits(textEdits, isLastEdits);
-    }
-    async _resolve() {
-        await asyncTransaction(async (tx) => {
-            const entriesWithoutChange = ( new ResourceMap());
-            for (const entry of this._entriesObs.get()) {
-                await entry.acceptStreamingEditsEnd(tx);
-                if (entry.diffInfo.get().identical) {
-                    entriesWithoutChange.set(entry.modifiedURI, entry);
-                }
-            }
-            if (entriesWithoutChange.size > 0) {
-                const newEntries = this._entriesObs.get().filter(e => !( entriesWithoutChange.has(e.modifiedURI)));
-                this._entriesObs.set(newEntries, tx);
-                dispose(( entriesWithoutChange.values()));
-            }
-            this._state.set(ChatEditingSessionState.Idle, tx);
-        });
-        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
-    }
-    async _getOrCreateModifiedFileEntry(resource, responseModel) {
-        const existingEntry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, resource));
-        if (existingEntry) {
-            if (responseModel.requestId !== existingEntry.telemetryInfo.requestId) {
-                existingEntry.updateTelemetryInfo(responseModel);
-            }
-            return existingEntry;
-        }
-        let entry;
-        const existingExternalEntry = this._lookupExternalEntry(resource);
-        if (existingExternalEntry) {
-            entry = existingExternalEntry;
-        }
-        else {
-            const initialContent = this._initialFileContents.get(resource);
-            entry = await this._createModifiedFileEntry(resource, responseModel, false, initialContent);
-            if (!initialContent) {
-                this._initialFileContents.set(resource, entry.initialContent);
-            }
-        }
-        const listener = entry.onDidDelete(() => {
-            const newEntries = this._entriesObs.get().filter(e => !isEqual(e.modifiedURI, entry.modifiedURI));
-            this._entriesObs.set(newEntries, undefined);
-            this._workingSet.delete(entry.modifiedURI);
-            this._editorService.closeEditors(this._editorService.findEditors(entry.modifiedURI));
-            if (!existingExternalEntry) {
-                entry.dispose();
-            }
-            this._store.delete(listener);
-            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
-        });
-        this._store.add(listener);
-        const entriesArr = [...this._entriesObs.get(), entry];
-        this._entriesObs.set(entriesArr, undefined);
-        this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
-        return entry;
-    }
-    async _createModifiedFileEntry(resource, responseModel, mustExist = false, initialContent) {
-        try {
-            const ref = await this._textModelService.createModelReference(resource);
-            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) {
-                throw err;
-            }
-            await this._bulkEditService.apply({ edits: [{ newResource: resource }] });
-            this._editorService.openEditor({ resource, options: { inactive: true, preserveFocus: true, pinned: true } });
-            return this._createModifiedFileEntry(resource, responseModel, true, initialContent);
-        }
-    }
-    _collapse(resource, transaction) {
-        const multiDiffItem = this._editorPane?.findDocumentDiffItem(resource);
-        if (multiDiffItem) {
-            this._editorPane?.viewModel?.items.get().find((documentDiffItem) => isEqual(documentDiffItem.originalUri, multiDiffItem.originalUri) &&
-                isEqual(documentDiffItem.modifiedUri, multiDiffItem.modifiedUri))
-                ?.collapsed.set(true, transaction);
-        }
-    }
-};
-ChatEditingSession = ( __decorate([
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IModelService)),
-    ( __param(6, ILanguageService)),
-    ( __param(7, ITextModelService)),
-    ( __param(8, IBulkEditService)),
-    ( __param(9, IEditorGroupsService)),
-    ( __param(10, IEditorService)),
-    ( __param(11, IChatService)),
-    ( __param(12, INotebookService)),
-    ( __param(13, ITextFileService)),
-    ( __param(14, IChatAgentService))
-], 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 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 {
-                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),
-            };
-            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);
-            }
-        }
-    }
-};
-ChatEditingSessionStorage = ( __decorate([
-    ( __param(1, IFileService)),
-    ( __param(2, IEnvironmentService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IWorkspaceContextService))
-], ChatEditingSessionStorage));
-const STORAGE_VERSION = 1;
-
-export { ChatEditingSession };