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

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

@@ -1,505 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { coalesce, delta, compareBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { AsyncIterableSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { BugIndicatingError, ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { LinkedList } from '@codingame/monaco-vscode-api/vscode/vs/base/common/linkedList';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import { observableValueOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/api';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
-import { runOnChange, ValueWithChangeEventFromObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
-import { compare } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
-import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
-import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.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 { bindContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
-import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
-import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
-import { IDecorationsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/decorations/common/decorations.service';
-import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
-import { MultiDiffEditorItem } from '@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
-import { IMultiDiffSourceResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service';
-import { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { defaultChatEditingMaxFileLimit, applyingChatEditsFailedContextKey, decidedChatEditingResourceContextKey, WorkingSetEntryState, hasUndecidedChatEditingResourceContextKey, hasAppliedChatEditsContextKey, inChatEditingSessionContextKey, applyingChatEditsContextKey, chatEditingAgentSupportsReadonlyReferencesContextKey, chatEditingMaxFileAssignmentName, ChatEditingSessionState, CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, chatEditingResourceContextKey } 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 { ChatEditingSession } from './chatEditingSession.js';
-import { ChatEditingTextModelContentProvider, ChatEditingSnapshotTextModelContentProvider } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTextModelContentProviders';
-
-const STORAGE_KEY_EDITING_SESSION = 'chat.editingSession';
-let ChatEditingService = class ChatEditingService extends Disposable {
-    get currentAutoApplyOperation() {
-        return this._currentAutoApplyOperationObs.get();
-    }
-    get currentEditingSession() {
-        return this._currentSessionObs.get();
-    }
-    get currentEditingSessionObs() {
-        return this._currentSessionObs;
-    }
-    get editingSessionFileLimit() {
-        if (this._chatAgentService.toolsAgentModeEnabled) {
-            return Number.MAX_SAFE_INTEGER;
-        }
-        return this._editingSessionFileLimit ?? defaultChatEditingMaxFileLimit;
-    }
-    constructor(_instantiationService, multiDiffSourceResolverService, textModelService, contextKeyService, _chatService, _editorService, decorationsService, _fileService, lifecycleService, _workbenchAssignmentService, _chatAgentService, storageService, logService, extensionService, productService) {
-        super();
-        this._instantiationService = _instantiationService;
-        this._chatService = _chatService;
-        this._editorService = _editorService;
-        this._fileService = _fileService;
-        this.lifecycleService = lifecycleService;
-        this._workbenchAssignmentService = _workbenchAssignmentService;
-        this._chatAgentService = _chatAgentService;
-        this._currentSessionObs = observableValue(this, null);
-        this._currentSessionDisposables = this._register(( new DisposableStore()));
-        this._adhocSessionsObs = observableValueOpts({ equalsFn: (a, b) => false }, ( new LinkedList()));
-        this.editingSessionsObs = derived(r => {
-            const result = Array.from(this._adhocSessionsObs.read(r));
-            const globalSession = this._currentSessionObs.read(r);
-            if (globalSession) {
-                result.push(globalSession);
-            }
-            return result;
-        });
-        this._currentAutoApplyOperationObs = observableValue(this, null);
-        this._chatRelatedFilesProviders = ( new Map());
-        this._applyingChatEditsFailedContextKey = applyingChatEditsFailedContextKey.bindTo(contextKeyService);
-        this._applyingChatEditsFailedContextKey.set(false);
-        this._register(decorationsService.registerDecorationsProvider(_instantiationService.createInstance(ChatDecorationsProvider, this._currentSessionObs)));
-        this._register(multiDiffSourceResolverService.registerResolver(_instantiationService.createInstance(ChatEditingMultiDiffSourceResolver, this._currentSessionObs)));
-        this._register(textModelService.registerTextModelContentProvider(ChatEditingTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingTextModelContentProvider, this._currentSessionObs)));
-        this._register(textModelService.registerTextModelContentProvider(ChatEditingSnapshotTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingSnapshotTextModelContentProvider, this._currentSessionObs)));
-        this._register(bindContextKey(decidedChatEditingResourceContextKey, contextKeyService, (reader) => {
-            const currentSession = this._currentSessionObs.read(reader);
-            if (!currentSession) {
-                return;
-            }
-            const entries = currentSession.entries.read(reader);
-            const decidedEntries = entries.filter(entry => entry.state.read(reader) !== WorkingSetEntryState.Modified);
-            return ( decidedEntries.map(entry => entry.entryId));
-        }));
-        this._register(bindContextKey(hasUndecidedChatEditingResourceContextKey, contextKeyService, (reader) => {
-            for (const session of this.editingSessionsObs.read(reader)) {
-                const entries = session.entries.read(reader);
-                const decidedEntries = entries.filter(entry => entry.state.read(reader) === WorkingSetEntryState.Modified);
-                return decidedEntries.length > 0;
-            }
-            return false;
-        }));
-        this._register(bindContextKey(hasAppliedChatEditsContextKey, contextKeyService, (reader) => {
-            const currentSession = this._currentSessionObs.read(reader);
-            if (!currentSession) {
-                return false;
-            }
-            const entries = currentSession.entries.read(reader);
-            return entries.length > 0;
-        }));
-        this._register(bindContextKey(inChatEditingSessionContextKey, contextKeyService, (reader) => {
-            return this._currentSessionObs.read(reader) !== null;
-        }));
-        this._register(bindContextKey(applyingChatEditsContextKey, contextKeyService, (reader) => {
-            return this._currentAutoApplyOperationObs.read(reader) !== null;
-        }));
-        this._register(bindContextKey(ChatContextKeys.chatEditingCanUndo, contextKeyService, (r) => {
-            return this._currentSessionObs.read(r)?.canUndo.read(r) || false;
-        }));
-        this._register(bindContextKey(ChatContextKeys.chatEditingCanRedo, contextKeyService, (r) => {
-            return this._currentSessionObs.read(r)?.canRedo.read(r) || false;
-        }));
-        this._register(this._chatService.onDidDisposeSession((e) => {
-            if (e.reason === 'cleared' && this._currentSessionObs.get()?.chatSessionId === e.sessionId) {
-                this._applyingChatEditsFailedContextKey.set(false);
-                void this._currentSessionObs.get()?.stop();
-            }
-        }));
-        const readonlyEnabledContextKey = chatEditingAgentSupportsReadonlyReferencesContextKey.bindTo(contextKeyService);
-        const setReadonlyFilesEnabled = () => {
-            const enabled = productService.quality !== 'stable' && ( extensionService.extensions.some(e => e.enabledApiProposals?.includes('chatReadonlyPromptReference')));
-            readonlyEnabledContextKey.set(enabled);
-        };
-        setReadonlyFilesEnabled();
-        this._register(extensionService.onDidRegisterExtensions(setReadonlyFilesEnabled));
-        this._register(extensionService.onDidChangeExtensions(setReadonlyFilesEnabled));
-        this._register(this.lifecycleService.onWillShutdown((e) => {
-            const session = this._currentSessionObs.get();
-            if (session) {
-                storageService.store(STORAGE_KEY_EDITING_SESSION, session.chatSessionId, StorageScope.WORKSPACE, StorageTarget.MACHINE);
-                e.join(session.storeState(), { id: 'join.chatEditingSession', label: ( localize(4500, "Saving chat edits history")) });
-            }
-        }));
-        this._editingSessionFileLimitPromise = this._workbenchAssignmentService.getTreatment(chatEditingMaxFileAssignmentName).then(value => {
-            this._editingSessionFileLimit = value ?? defaultChatEditingMaxFileLimit;
-            return this._editingSessionFileLimit;
-        });
-        const sessionIdToRestore = storageService.get(STORAGE_KEY_EDITING_SESSION, StorageScope.WORKSPACE);
-        if (isString(sessionIdToRestore)) {
-            if (this._chatService.getOrRestoreSession(sessionIdToRestore)) {
-                this._restoringEditingSession = this.startOrContinueEditingSession(sessionIdToRestore);
-                this._restoringEditingSession.finally(() => {
-                    this._restoringEditingSession = undefined;
-                });
-            }
-            else {
-                logService.error(`Edit session session to restore is a non-existing chat session: ${sessionIdToRestore}`);
-            }
-            storageService.remove(STORAGE_KEY_EDITING_SESSION, StorageScope.WORKSPACE);
-        }
-    }
-    async getOrRestoreEditingSession() {
-        if (this._restoringEditingSession) {
-            await this._restoringEditingSession;
-        }
-        return this.currentEditingSessionObs.get();
-    }
-    dispose() {
-        this._currentSessionObs.get()?.dispose();
-        super.dispose();
-    }
-    async startOrContinueEditingSession(chatSessionId) {
-        await this._restoringEditingSession;
-        const session = this._currentSessionObs.get();
-        if (session) {
-            if (session.chatSessionId === chatSessionId) {
-                return session;
-            }
-            else if (session.chatSessionId !== chatSessionId) {
-                await session.stop(true);
-            }
-        }
-        return this._createEditingSession(chatSessionId);
-    }
-    _lookupEntry(uri) {
-        for (const item of Iterable.concat(this.editingSessionsObs.get())) {
-            const candidate = item.getEntry(uri);
-            if (candidate instanceof ChatEditingModifiedFileEntry) {
-                return candidate.acquire();
-            }
-        }
-        return undefined;
-    }
-    async _createEditingSession(chatSessionId) {
-        if (this._currentSessionObs.get()) {
-            throw ( new BugIndicatingError('Cannot have more than one active editing session'));
-        }
-        this._currentSessionDisposables.clear();
-        const session = this._instantiationService.createInstance(ChatEditingSession, chatSessionId, true, this._editingSessionFileLimitPromise, this._lookupEntry.bind(this));
-        await session.init();
-        this._currentSessionDisposables.add(this.installAutoApplyObserver(session));
-        this._currentSessionDisposables.add(session.onDidDispose(() => {
-            this._currentSessionDisposables.clear();
-            this._currentSessionObs.set(null, undefined);
-        }));
-        this._currentSessionObs.set(session, undefined);
-        return session;
-    }
-    async createAdhocEditingSession(chatSessionId) {
-        const session = this._instantiationService.createInstance(ChatEditingSession, chatSessionId, false, this._editingSessionFileLimitPromise, this._lookupEntry.bind(this));
-        await session.init();
-        const list = this._adhocSessionsObs.get();
-        const removeSession = list.unshift(session);
-        const store = ( new DisposableStore());
-        this._store.add(store);
-        store.add(this.installAutoApplyObserver(session));
-        store.add(session.onDidDispose(e => {
-            removeSession();
-            this._adhocSessionsObs.set(list, undefined);
-            this._store.deleteAndLeak(store);
-            store.dispose();
-        }));
-        this._adhocSessionsObs.set(list, undefined);
-        return session;
-    }
-    installAutoApplyObserver(session) {
-        const chatModel = this._chatService.getOrRestoreSession(session.chatSessionId);
-        if (!chatModel) {
-            throw ( new ErrorNoTelemetry(
-                `Edit session was created for a non-existing chat session: ${session.chatSessionId}`
-            ));
-        }
-        const observerDisposables = ( new DisposableStore());
-        let editsSource;
-        let editsPromise;
-        const editsSeen = ( new ResourceMap());
-        const editedFilesExist = ( new ResourceMap());
-        const onResponseComplete = (responseModel) => {
-            if (responseModel.result?.errorDetails && !responseModel.result.errorDetails.responseIsIncomplete) {
-                session.restoreSnapshot(responseModel.requestId);
-                this._applyingChatEditsFailedContextKey.set(true);
-            }
-            editsSource?.resolve();
-            editsSource = undefined;
-            editsSeen.clear();
-            editedFilesExist.clear();
-        };
-        const handleResponseParts = async (responseModel) => {
-            for (const part of responseModel.response.value) {
-                if (part.kind === 'codeblockUri' || part.kind === 'textEditGroup') {
-                    if (!editedFilesExist.get(part.uri)) {
-                        const uri = part.uri.scheme === Schemas.vscodeNotebookCell ? CellUri.parse(part.uri)?.notebook ?? part.uri : part.uri;
-                        editedFilesExist.set(part.uri, this._fileService.exists(uri).then((e) => {
-                            if (e) {
-                                this._editorService.openEditor({ resource: uri, options: { inactive: true, preserveFocus: true, pinned: true } });
-                            }
-                            return e;
-                        }));
-                    }
-                    const first = editsSeen.size === 0;
-                    let entry = editsSeen.get(part.uri);
-                    if (!entry) {
-                        entry = { seen: 0 };
-                        editsSeen.set(part.uri, entry);
-                    }
-                    const allEdits = part.kind === 'textEditGroup' ? part.edits : [];
-                    const newEdits = allEdits.slice(entry.seen);
-                    entry.seen += newEdits.length;
-                    if (newEdits.length > 0 || entry.seen === 0) {
-                        editsSource ??= ( new AsyncIterableSource());
-                        editsSource.emitOne({ uri: part.uri, edits: newEdits, kind: 'textEditGroup', done: part.kind === 'textEditGroup' && part.done });
-                    }
-                    if (first) {
-                        await editsPromise;
-                        editsPromise = this._continueEditingSession(session, async (builder, token) => {
-                            for await (const item of editsSource.asyncIterable) {
-                                if (responseModel.isCanceled) {
-                                    break;
-                                }
-                                if (token.isCancellationRequested) {
-                                    break;
-                                }
-                                if (item.edits.length === 0) {
-                                    builder.textEdits(item.uri, [], item.done ?? false, responseModel);
-                                    continue;
-                                }
-                                for (let i = 0; i < item.edits.length; i++) {
-                                    const group = item.edits[i];
-                                    const isLastGroup = i === item.edits.length - 1;
-                                    builder.textEdits(item.uri, group, isLastGroup && (item.done ?? false), responseModel);
-                                }
-                            }
-                        }).finally(() => {
-                            editsPromise = undefined;
-                        });
-                    }
-                }
-            }
-        };
-        observerDisposables.add(chatModel.onDidChange(async (e) => {
-            if (e.kind === 'addRequest') {
-                session.createSnapshot(e.request.id);
-                this._applyingChatEditsFailedContextKey.set(false);
-                const responseModel = e.request.response;
-                if (responseModel) {
-                    if (responseModel.isComplete) {
-                        await handleResponseParts(responseModel);
-                        onResponseComplete(responseModel);
-                    }
-                    else {
-                        const disposable = responseModel.onDidChange(async () => {
-                            await handleResponseParts(responseModel);
-                            if (responseModel.isComplete) {
-                                onResponseComplete(responseModel);
-                                disposable.dispose();
-                            }
-                        });
-                    }
-                }
-            }
-        }));
-        observerDisposables.add(chatModel.onDidDispose(() => observerDisposables.dispose()));
-        return observerDisposables;
-    }
-    async _continueEditingSession(session, builder) {
-        if (session.state.get() === ChatEditingSessionState.StreamingEdits) {
-            throw ( new BugIndicatingError('Cannot continue session that is still streaming'));
-        }
-        const stream = {
-            textEdits: (resource, textEdits, isDone, responseModel) => {
-                session.acceptTextEdits(resource, textEdits, isDone, responseModel);
-            }
-        };
-        session.acceptStreamingEditsStart();
-        const cancellationTokenSource = ( new CancellationTokenSource());
-        this._currentAutoApplyOperationObs.set(cancellationTokenSource, undefined);
-        try {
-            await builder(stream, cancellationTokenSource.token);
-        }
-        finally {
-            cancellationTokenSource.dispose();
-            this._currentAutoApplyOperationObs.set(null, undefined);
-            session.resolve();
-        }
-    }
-    hasRelatedFilesProviders() {
-        return this._chatRelatedFilesProviders.size > 0;
-    }
-    registerRelatedFilesProvider(handle, provider) {
-        this._chatRelatedFilesProviders.set(handle, provider);
-        return toDisposable(() => {
-            this._chatRelatedFilesProviders.delete(handle);
-        });
-    }
-    async getRelatedFiles(chatSessionId, prompt, token) {
-        const currentSession = this._currentSessionObs.get();
-        if (!currentSession || chatSessionId !== currentSession.chatSessionId) {
-            return undefined;
-        }
-        const userAddedWorkingSetEntries = [];
-        for (const [uri, metadata] of currentSession.workingSet) {
-            if (metadata.state !== WorkingSetEntryState.Suggested) {
-                userAddedWorkingSetEntries.push(uri);
-            }
-        }
-        const providers = Array.from(( this._chatRelatedFilesProviders.values()));
-        const result = await Promise.all(( providers.map(async (provider) => {
-            try {
-                const relatedFiles = await provider.provideRelatedFiles({ prompt, files: userAddedWorkingSetEntries }, token);
-                if (relatedFiles?.length) {
-                    return { group: provider.description, files: relatedFiles };
-                }
-                return undefined;
-            }
-            catch (e) {
-                return undefined;
-            }
-        })));
-        return coalesce(result);
-    }
-};
-ChatEditingService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IMultiDiffSourceResolverService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IChatService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IDecorationsService)),
-    ( __param(7, IFileService)),
-    ( __param(8, ILifecycleService)),
-    ( __param(9, IWorkbenchAssignmentService)),
-    ( __param(10, IChatAgentService)),
-    ( __param(11, IStorageService)),
-    ( __param(12, ILogService)),
-    ( __param(13, IExtensionService)),
-    ( __param(14, IProductService))
-], ChatEditingService));
-function observeArrayChanges(obs, compare, store) {
-    const emitter = store.add(( new Emitter()));
-    store.add(runOnChange(obs, (newArr, oldArr) => {
-        const change = delta(oldArr || [], newArr, compare);
-        const changedElements = [].concat(change.added).concat(change.removed);
-        emitter.fire(changedElements);
-    }));
-    return emitter.event;
-}
-let ChatDecorationsProvider = class ChatDecorationsProvider extends Disposable {
-    constructor(_session, _chatAgentService) {
-        super();
-        this._session = _session;
-        this._chatAgentService = _chatAgentService;
-        this.label = ( localize(4501, "Chat Editing"));
-        this._currentEntries = derived(this, (r) => {
-            const session = this._session.read(r);
-            if (!session) {
-                return [];
-            }
-            const state = session.state.read(r);
-            if (state === ChatEditingSessionState.Disposed) {
-                return [];
-            }
-            return session.entries.read(r);
-        });
-        this._currentlyEditingUris = derived(this, (r) => {
-            const uri = this._currentEntries.read(r);
-            return ( uri.filter(entry => entry.isCurrentlyBeingModified.read(r)).map(entry => entry.modifiedURI));
-        });
-        this._modifiedUris = derived(this, (r) => {
-            const uri = this._currentEntries.read(r);
-            return ( uri.filter(entry => !entry.isCurrentlyBeingModified.read(r) && entry.state.read(r) === WorkingSetEntryState.Modified).map(entry => entry.modifiedURI));
-        });
-        this.onDidChange = Event.any(observeArrayChanges(this._currentlyEditingUris, compareBy(uri => ( uri.toString()), compare), this._store), observeArrayChanges(this._modifiedUris, compareBy(uri => ( uri.toString()), compare), this._store));
-    }
-    provideDecorations(uri, _token) {
-        const isCurrentlyBeingModified = ( this._currentlyEditingUris.get().some(e => ( e.toString()) === ( uri.toString())));
-        if (isCurrentlyBeingModified) {
-            return {
-                weight: 1000,
-                letter: ThemeIcon.modify(Codicon.loading, 'spin'),
-                bubble: false
-            };
-        }
-        const isModified = ( this._modifiedUris.get().some(e => ( e.toString()) === ( uri.toString())));
-        if (isModified) {
-            const defaultAgentName = this._chatAgentService.getDefaultAgent(ChatAgentLocation.EditingSession)?.fullName;
-            return {
-                weight: 1000,
-                letter: Codicon.diffModified,
-                tooltip: defaultAgentName ? ( localize(4502, "Pending changes from {0}", defaultAgentName)) : ( localize(4503, "Pending changes from chat")),
-                bubble: true
-            };
-        }
-        return undefined;
-    }
-};
-ChatDecorationsProvider = ( __decorate([
-    ( __param(1, IChatAgentService))
-], ChatDecorationsProvider));
-let ChatEditingMultiDiffSourceResolver = class ChatEditingMultiDiffSourceResolver {
-    constructor(_currentSession, _instantiationService) {
-        this._currentSession = _currentSession;
-        this._instantiationService = _instantiationService;
-    }
-    canHandleUri(uri) {
-        return uri.scheme === CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME;
-    }
-    async resolveDiffSource(uri) {
-        return this._instantiationService.createInstance(ChatEditingMultiDiffSource, this._currentSession);
-    }
-};
-ChatEditingMultiDiffSourceResolver = ( __decorate([
-    ( __param(1, IInstantiationService))
-], ChatEditingMultiDiffSourceResolver));
-class ChatEditingMultiDiffSource {
-    constructor(_currentSession) {
-        this._currentSession = _currentSession;
-        this._resources = derived(this, (reader) => {
-            const currentSession = this._currentSession.read(reader);
-            if (!currentSession) {
-                return [];
-            }
-            const entries = currentSession.entries.read(reader);
-            return ( entries.map((entry) => {
-                return ( new MultiDiffEditorItem(entry.originalURI, entry.modifiedURI, undefined, {
-                    [chatEditingResourceContextKey.key]: entry.entryId,
-                }));
-            }));
-        });
-        this.resources = ( new ValueWithChangeEventFromObservable(this._resources));
-        this.contextKeys = {
-            [inChatEditingSessionContextKey.key]: true
-        };
-    }
-}
-
-export { ChatEditingMultiDiffSourceResolver, ChatEditingService };

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

@@ -1,104 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ResourceMap } from "@codingame/monaco-vscode-api/vscode/vs/base/common/map";
-import { IObservable, IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IBulkEditService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService";
-import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
-import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-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 { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-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 { 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 { ChatEditingSessionChangeType, ChatEditingSessionState, IChatEditingSession, IModifiedFileEntry, WorkingSetDisplayMetadata, WorkingSetEntryRemovalReason, WorkingSetEntryState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
-import { IChatResponseModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
-import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
-import { ChatEditingModifiedFileEntry, ISnapshotEntry } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedFileEntry";
-export declare class ChatEditingSession extends Disposable implements IChatEditingSession {
-    readonly chatSessionId: string;
-    readonly isGlobalEditingSession: boolean;
-    private editingSessionFileLimitPromise;
-    private _lookupExternalEntry;
-    private readonly _instantiationService;
-    private readonly _modelService;
-    private readonly _languageService;
-    private readonly _textModelService;
-    readonly _bulkEditService: IBulkEditService;
-    private readonly _editorGroupsService;
-    private readonly _editorService;
-    private readonly _chatService;
-    private readonly _notebookService;
-    private readonly _textFileService;
-    private readonly _chatAgentService;
-    private readonly _state;
-    private readonly _linearHistory;
-    private readonly _linearHistoryIndex;
-    private readonly _initialFileContents;
-    private readonly _entriesObs;
-    get entries(): IObservable<readonly ChatEditingModifiedFileEntry[]>;
-    private readonly _sequencer;
-    private _workingSet;
-    get workingSet(): ResourceMap<WorkingSetDisplayMetadata>;
-    private _removedTransientEntries;
-    private _editorPane;
-    get state(): IObservable<ChatEditingSessionState>;
-    readonly canUndo: IObservable<boolean>;
-    readonly canRedo: IObservable<boolean>;
-    hiddenRequestIds: IObservable<string[]>;
-    private readonly _onDidChange;
-    get onDidChange(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ChatEditingSessionChangeType>;
-    private readonly _onDidDispose;
-    get onDidDispose(): import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
-    private _isToolsAgentSession;
-    get isToolsAgentSession(): boolean;
-    constructor(chatSessionId: string, isGlobalEditingSession: boolean, editingSessionFileLimitPromise: Promise<number>, _lookupExternalEntry: (uri: URI) => ChatEditingModifiedFileEntry | undefined, _instantiationService: IInstantiationService, _modelService: IModelService, _languageService: ILanguageService, _textModelService: ITextModelService, _bulkEditService: IBulkEditService, _editorGroupsService: IEditorGroupsService, _editorService: IEditorService, _chatService: IChatService, _notebookService: INotebookService, _textFileService: ITextFileService, _chatAgentService: IChatAgentService);
-    init(): Promise<void>;
-    getEntry(uri: URI): IModifiedFileEntry | undefined;
-    readEntry(uri: URI, reader: IReader | undefined): IModifiedFileEntry | undefined;
-    storeState(): Promise<void>;
-    private _triggerSaveParticipantsOnAccept;
-    private _trackCurrentEditorsInWorkingSet;
-    private _findSnapshot;
-    createSnapshot(requestId: string | undefined): void;
-    private _createSnapshot;
-    getSnapshotModel(requestId: string, snapshotUri: URI): Promise<ITextModel | null>;
-    getSnapshot(requestId: string, uri: URI): ISnapshotEntry | undefined;
-    getSnapshotUri(requestId: string, uri: URI): URI | undefined;
-    private _pendingSnapshot;
-    restoreSnapshot(requestId: string | undefined): Promise<void>;
-    private _restoreSnapshot;
-    remove(reason: WorkingSetEntryRemovalReason, ...uris: URI[]): void;
-    markIsReadonly(resource: URI, isReadonly?: boolean): void;
-    private _assertNotDisposed;
-    accept(...uris: URI[]): Promise<void>;
-    reject(...uris: URI[]): Promise<void>;
-    show(): Promise<void>;
-    private stopPromise;
-    stop(clearState?: boolean): Promise<void>;
-    _performStop(): Promise<void>;
-    dispose(): void;
-    getVirtualModel(documentId: string): ITextModel | null;
-    acceptStreamingEditsStart(): void;
-    acceptTextEdits(resource: URI, textEdits: TextEdit[], isLastEdits: boolean, responseModel: IChatResponseModel): void;
-    resolve(): void;
-    private _trackUntitledWorkingSetEntry;
-    addFileToWorkingSet(resource: URI, description?: string, proposedState?: WorkingSetEntryState.Suggested): void;
-    undoInteraction(): Promise<void>;
-    redoInteraction(): Promise<void>;
-    private _updateRequestHiddenState;
-    private _acceptStreamingEditsStart;
-    private _acceptTextEdits;
-    private _resolve;
-    private _getOrCreateModifiedFileEntry;
-    private _createModifiedFileEntry;
-    private _collapse;
-}
-export interface IChatEditingSessionSnapshot {
-    readonly requestId: string | undefined;
-    readonly workingSet: ResourceMap<WorkingSetDisplayMetadata>;
-    readonly entries: ResourceMap<ISnapshotEntry>;
-}