@codingame/monaco-vscode-chat-service-override 10.1.3 → 11.0.0

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

@@ -0,0 +1,507 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Sequencer } 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 { 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 { 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';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { localize } from 'vscode/vscode/vs/nls';
+import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs.service';
+import { EditorActivation } from 'vscode/vscode/vs/platform/editor/common/editor';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { DiffEditorInput } from 'vscode/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 { 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 { ChatEditingMultiDiffSourceResolver } from './chatEditingService.js';
+import { ChatEditingModifiedFileEntry } from './chatEditingModifiedFileEntry.js';
+import { ChatEditingTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+
+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, 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 isVisible() {
+        this._assertNotDisposed();
+        return Boolean(this.editorPane && this.editorPane.isVisible());
+    }
+    constructor(chatSessionId, editorPane, editingSessionFileLimitPromise, _instantiationService, _modelService, _languageService, _textModelService, _bulkEditService, _editorGroupsService, _editorService, _chatWidgetService, _workspaceContextService, _fileService, _dialogService, _chatAgentService) {
+        super();
+        this.chatSessionId = chatSessionId;
+        this.editorPane = editorPane;
+        this.editingSessionFileLimitPromise = editingSessionFileLimitPromise;
+        this._instantiationService = _instantiationService;
+        this._modelService = _modelService;
+        this._languageService = _languageService;
+        this._textModelService = _textModelService;
+        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._linearHistory = observableValue(this, []);
+        this._linearHistoryIndex = observableValue(this, 0);
+        this._initialFileContents = ( (new ResourceMap()));
+        this._snapshots = ( (new Map()));
+        this._filesToSkipCreating = ( (new ResourceSet()));
+        this._entriesObs = observableValue(this, []);
+        this._sequencer = ( (new Sequencer()));
+        this._workingSet = ( (new ResourceMap()));
+        this.canUndo = derived((r) => {
+            if (this.state.read(r) !== 2 ) {
+                return false;
+            }
+            const linearHistoryIndex = this._linearHistoryIndex.read(r);
+            return linearHistoryIndex > 0;
+        });
+        this.canRedo = derived((r) => {
+            if (this.state.read(r) !== 2 ) {
+                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 = ( (new Emitter()));
+        this._onDidDispose = ( (new Emitter()));
+        const widget = _chatWidgetService.getWidgetBySessionId(chatSessionId);
+        if (!widget) {
+            return;
+        }
+        this._trackCurrentEditorsInWorkingSet();
+        this._register(this._editorService.onDidActiveEditorChange(() => {
+            this._trackCurrentEditorsInWorkingSet();
+        }));
+        this._register(this._editorService.onDidCloseEditor((e) => {
+            this._trackCurrentEditorsInWorkingSet(e);
+        }));
+    }
+    _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 ) {
+                existingTransientEntries.add(file);
+            }
+        }
+        if (existingTransientEntries.size === 0 && this._workingSet.size > 0) {
+            return;
+        }
+        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();
+            }
+            if (isCodeEditor(activeEditorControl) && activeEditorControl.hasModel()) {
+                const uri = activeEditorControl.getModel().uri;
+                if (closedEditor === ( (uri.toString()))) ;
+                else if (( (existingTransientEntries.has(uri)))) {
+                    existingTransientEntries.delete(uri);
+                }
+                else {
+                    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 );
+            didChange = true;
+        }
+        if (didChange) {
+            this._onDidChange.fire();
+        }
+    }
+    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 );
+            }
+            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._snapshots.get(requestId)?.entries;
+        if (!entries) {
+            return null;
+        }
+        const snapshotEntry = [...( (entries.values()))].find((e) => ( (e.snapshotUri.toString())) === ( (snapshotUri.toString())));
+        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 snapshotEntries = snapshot?.entries;
+        return snapshotEntries?.get(uri);
+    }
+    async restoreSnapshot(requestId) {
+        if (requestId !== undefined) {
+            const snapshot = this._snapshots.get(requestId);
+            if (snapshot) {
+                await this._restoreSnapshot(snapshot);
+            }
+        }
+        else {
+            await this._restoreSnapshot(undefined);
+        }
+    }
+    async _restoreSnapshot(snapshot) {
+        if (!snapshot) {
+            if (!this._pendingSnapshot) {
+                return;
+            }
+            snapshot = this._pendingSnapshot;
+            this._pendingSnapshot = undefined;
+        }
+        else if (!this._pendingSnapshot) {
+            this.createSnapshot(undefined);
+        }
+        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.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(...uris) {
+        this._assertNotDisposed();
+        let didRemoveUris = false;
+        for (const uri of uris) {
+            didRemoveUris = this._workingSet.delete(uri) || didRemoveUris;
+        }
+        if (!didRemoveUris) {
+            return;
+        }
+        this._onDidChange.fire();
+    }
+    _assertNotDisposed() {
+        if (this._state.get() === 3 ) {
+            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 => ( (e.modifiedURI.toString())) === ( (uri.toString())));
+            if (entry) {
+                await entry.accept(undefined);
+            }
+        }
+        this._onDidChange.fire();
+    }
+    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 => ( (e.modifiedURI.toString())) === ( (uri.toString())));
+            if (entry) {
+                await entry.reject(undefined);
+            }
+        }
+        this._onDidChange.fire();
+    }
+    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;
+        }
+        const input = MultiDiffEditorInput.fromResourceMultiDiffEditorInput({
+            multiDiffSource: ChatEditingMultiDiffSourceResolver.getMultiDiffSourceUri(),
+            label: ( localize(7665, "Suggested Edits"))
+        }, this._instantiationService);
+        const editorPane = await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
+        this.editorPane = editorPane;
+    }
+    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)) {
+                    await g.closeEditor(e);
+                }
+            }))));
+        }))));
+        if (this._state.get() !== 3 ) {
+            this.dispose();
+        }
+    }
+    dispose() {
+        this._assertNotDisposed();
+        for (const entry of this._entriesObs.get()) {
+            entry.dispose();
+        }
+        super.dispose();
+        this._state.set(3 , undefined);
+        this._onDidDispose.fire();
+    }
+    getVirtualModel(documentId) {
+        this._assertNotDisposed();
+        const entry = this._entriesObs.get().find(e => e.entryId === documentId);
+        return entry?.docSnapshot ?? null;
+    }
+    acceptStreamingEditsStart() {
+        if (this._state.get() === 3 ) {
+            return;
+        }
+        this._sequencer.queue(() => this._acceptStreamingEditsStart());
+    }
+    acceptTextEdits(resource, textEdits, responseModel) {
+        if (this._state.get() === 3 ) {
+            return;
+        }
+        this._sequencer.queue(() => this._acceptTextEdits(resource, textEdits, responseModel));
+    }
+    resolve() {
+        if (this._state.get() === 3 ) {
+            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 );
+                }
+            }
+            this._onDidChange.fire();
+        }
+    }
+    async undoInteraction() {
+        const linearHistory = this._linearHistory.get();
+        const linearHistoryIndex = this._linearHistoryIndex.get();
+        if (linearHistoryIndex <= 0) {
+            return;
+        }
+        const previousSnapshot = linearHistory[linearHistoryIndex - 1];
+        await this.restoreSnapshot(previousSnapshot.requestId);
+        this._linearHistoryIndex.set(linearHistoryIndex - 1, undefined);
+    }
+    async redoInteraction() {
+        const linearHistory = this._linearHistory.get();
+        const linearHistoryIndex = this._linearHistoryIndex.get();
+        if (linearHistoryIndex >= linearHistory.length) {
+            return;
+        }
+        const nextSnapshot = (linearHistoryIndex + 1 < linearHistory.length ? linearHistory[linearHistoryIndex + 1] : this._pendingSnapshot);
+        if (!nextSnapshot) {
+            return;
+        }
+        await this.restoreSnapshot(nextSnapshot.requestId);
+        this._linearHistoryIndex.set(linearHistoryIndex + 1, undefined);
+    }
+    async _acceptStreamingEditsStart() {
+        transaction((tx) => {
+            this._state.set(1 , tx);
+            for (const entry of this._entriesObs.get()) {
+                entry.acceptStreamingEditsStart(tx);
+            }
+        });
+    }
+    async _acceptTextEdits(resource, textEdits, 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)) {
+            return;
+        }
+        if (resource.scheme !== Schemas.untitled && !this._workspaceContextService.getWorkspaceFolder(resource) && !(await this._fileService.exists(resource))) {
+            const saveLocation = await this._dialogService.showSaveDialog({ title: ( localize(
+                7666,
+                '{0} wants to create a file. Choose where it should be saved.',
+                this._chatAgentService.getDefaultAgent(ChatAgentLocation.EditingSession)?.fullName ?? 'Chat'
+            )) });
+            if (!saveLocation) {
+                this._filesToSkipCreating.add(resource);
+                return;
+            }
+            resource = saveLocation;
+        }
+        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);
+    }
+    async _resolve() {
+        transaction((tx) => {
+            for (const entry of this._entriesObs.get()) {
+                entry.acceptStreamingEditsEnd(tx);
+            }
+            this._state.set(2 , tx);
+        });
+        this._onDidChange.fire();
+    }
+    async _getOrCreateModifiedFileEntry(resource, responseModel) {
+        const existingEntry = this._entriesObs.get().find(e => ( (e.resource.toString())) === ( (resource.toString())));
+        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());
+        }
+        this._register(entry.onDidDelete(() => {
+            const newEntries = this._entriesObs.get().filter(e => ( (e.modifiedURI.toString())) !== ( (entry.modifiedURI.toString())));
+            this._entriesObs.set(newEntries, undefined);
+            this._workingSet.delete(entry.modifiedURI);
+            this._onDidChange.fire();
+        }));
+        const entriesArr = [...this._entriesObs.get(), entry];
+        this._entriesObs.set(entriesArr, undefined);
+        this._onDidChange.fire();
+        return entry;
+    }
+    async _createModifiedFileEntry(resource, responseModel, mustExist = false) {
+        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 );
+        }
+        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);
+        }
+    }
+    _collapse(resource, transaction) {
+        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);
+        }
+    }
+};
+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)));
+
+export { ChatEditingSession };

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

@@ -0,0 +1,76 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+
+var ChatEditingTextModelContentProvider_1, ChatEditingSnapshotTextModelContentProvider_1;
+let ChatEditingTextModelContentProvider = class ChatEditingTextModelContentProvider {
+    static { ChatEditingTextModelContentProvider_1 = this; }
+    static { this.scheme = 'chat-editing-text-model'; }
+    static getEmptyFileURI() {
+        return ( URI.from({
+            scheme: ChatEditingTextModelContentProvider_1.scheme,
+            query: JSON.stringify({ kind: 'empty' }),
+        }));
+    }
+    static getFileURI(documentId, path) {
+        return ( URI.from({
+            scheme: ChatEditingTextModelContentProvider_1.scheme,
+            path,
+            query: JSON.stringify({ kind: 'doc', documentId }),
+        }));
+    }
+    constructor(_currentSessionObs, _modelService) {
+        this._currentSessionObs = _currentSessionObs;
+        this._modelService = _modelService;
+    }
+    async provideTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing && !existing.isDisposed()) {
+            return existing;
+        }
+        const data = JSON.parse(resource.query);
+        if (data.kind === 'empty') {
+            return this._modelService.createModel('', null, resource, false);
+        }
+        const session = this._currentSessionObs.get();
+        if (!session) {
+            return null;
+        }
+        return session.getVirtualModel(data.documentId);
+    }
+};
+ChatEditingTextModelContentProvider = ChatEditingTextModelContentProvider_1 = ( __decorate([
+    ( __param(1, IModelService))
+], ChatEditingTextModelContentProvider));
+let ChatEditingSnapshotTextModelContentProvider = class ChatEditingSnapshotTextModelContentProvider {
+    static { ChatEditingSnapshotTextModelContentProvider_1 = this; }
+    static { this.scheme = 'chat-editing-snapshot-text-model'; }
+    static getSnapshotFileURI(requestId, path) {
+        return ( URI.from({
+            scheme: ChatEditingSnapshotTextModelContentProvider_1.scheme,
+            path,
+            query: JSON.stringify({ requestId: requestId ?? '' }),
+        }));
+    }
+    constructor(_currentSessionObs, _modelService) {
+        this._currentSessionObs = _currentSessionObs;
+        this._modelService = _modelService;
+    }
+    async provideTextContent(resource) {
+        const existing = this._modelService.getModel(resource);
+        if (existing && !existing.isDisposed()) {
+            return existing;
+        }
+        const data = JSON.parse(resource.query);
+        const session = this._currentSessionObs.get();
+        if (!session || !data.requestId) {
+            return null;
+        }
+        return session.getSnapshotModel(data.requestId, resource);
+    }
+};
+ChatEditingSnapshotTextModelContentProvider = ChatEditingSnapshotTextModelContentProvider_1 = ( __decorate([
+    ( __param(1, IModelService))
+], ChatEditingSnapshotTextModelContentProvider));
+
+export { ChatEditingSnapshotTextModelContentProvider, ChatEditingTextModelContentProvider };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditor.js

@@ -18,11 +18,11 @@ import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
 import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
 import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
-import { clearChatEditor } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatClear';
-import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
-import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
+import { clearChatEditor } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/browser/actions/chatClear';
+import { ChatEditorInput } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { ChatWidget } from '@codingame/monaco-vscode-chat-extensions-notebook-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { CHAT_PROVIDER_ID } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
+import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
 import { EDITOR_DRAG_AND_DROP_BACKGROUND } from 'vscode/vscode/vs/workbench/common/theme';
 
 let ChatEditor = class ChatEditor extends EditorPane {