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

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

@@ -0,0 +1,423 @@
+
+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 { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { 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, dispose, 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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+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, assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { TextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+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 { 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 { 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-1bb39316-6fbf-572e-ab6a-818a2496c14f-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 { chatEditingSnapshotScheme, chatEditingAgentSupportsReadonlyReferencesContextKey, ChatEditingSessionState, WorkingSetEntryState, CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, chatEditingResourceContextKey, inChatEditingSessionContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { isCellTextEditOperation } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { AbstractChatEditingModifiedFileEntry } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedFileEntry';
+import { ChatEditingSession } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingSession';
+import { ChatEditingTextModelContentProvider, ChatEditingSnapshotTextModelContentProvider } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTextModelContentProviders';
+import { observableValueOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/api';
+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';
+
+const STORAGE_KEY_EDITING_SESSION = 'chat.editingSession';
+let ChatEditingService = class ChatEditingService extends Disposable {
+    constructor(_instantiationService, multiDiffSourceResolverService, textModelService, contextKeyService, _chatService, _editorService, decorationsService, _fileService, lifecycleService, storageService, logService, extensionService, productService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._chatService = _chatService;
+        this._editorService = _editorService;
+        this._fileService = _fileService;
+        this.lifecycleService = lifecycleService;
+        this._sessionsObs = observableValueOpts({ equalsFn: (a, b) => false }, ( new LinkedList()));
+        this.editingSessionsObs = derived(r => {
+            const result = Array.from(this._sessionsObs.read(r));
+            return result;
+        });
+        this._chatRelatedFilesProviders = ( new Map());
+        this._register(decorationsService.registerDecorationsProvider(_instantiationService.createInstance(ChatDecorationsProvider, this.editingSessionsObs)));
+        this._register(multiDiffSourceResolverService.registerResolver(_instantiationService.createInstance(ChatEditingMultiDiffSourceResolver, this.editingSessionsObs)));
+        this._register(textModelService.registerTextModelContentProvider(ChatEditingTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingTextModelContentProvider, this)));
+        this._register(textModelService.registerTextModelContentProvider(chatEditingSnapshotScheme, _instantiationService.createInstance(ChatEditingSnapshotTextModelContentProvider, this)));
+        this._register(this._chatService.onDidDisposeSession((e) => {
+            if (e.reason === 'cleared') {
+                this.getEditingSession(e.sessionId)?.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));
+        let storageTask;
+        this._register(storageService.onWillSaveState(() => {
+            const sessionIds = [];
+            const tasks = [];
+            for (const session of this.editingSessionsObs.get()) {
+                if (!session.isGlobalEditingSession) {
+                    continue;
+                }
+                sessionIds.push(session.chatSessionId);
+                tasks.push(session.storeState());
+            }
+            if (sessionIds.length) {
+                storageService.store(STORAGE_KEY_EDITING_SESSION, sessionIds.join(), StorageScope.WORKSPACE, StorageTarget.MACHINE);
+            }
+            storageTask = Promise.resolve(storageTask)
+                .then(() => Promise.all(tasks))
+                .finally(() => storageTask = undefined);
+        }));
+        this._register(this.lifecycleService.onWillShutdown(e => {
+            if (!storageTask) {
+                return;
+            }
+            e.join(storageTask, {
+                id: 'join.chatEditingSession',
+                label: ( localize(4580, "Saving chat edits history"))
+            });
+        }));
+        const rawSessionsToRestore = storageService.get(STORAGE_KEY_EDITING_SESSION, StorageScope.WORKSPACE);
+        if (isString(rawSessionsToRestore)) {
+            const sessionIds = rawSessionsToRestore.split(',');
+            const tasks = [];
+            for (const sessionId of sessionIds) {
+                const chatModel = _chatService.getOrRestoreSession(sessionId);
+                if (!chatModel) {
+                    logService.error(`Edit session session to restore is a non-existing chat session: ${rawSessionsToRestore}`);
+                    continue;
+                }
+                tasks.push(this.startOrContinueGlobalEditingSession(chatModel.sessionId));
+            }
+            this._restoringEditingSession = Promise.all(tasks).finally(() => {
+                this._restoringEditingSession = undefined;
+            });
+            storageService.remove(STORAGE_KEY_EDITING_SESSION, StorageScope.WORKSPACE);
+        }
+    }
+    dispose() {
+        dispose(this._sessionsObs.get());
+        super.dispose();
+    }
+    async startOrContinueGlobalEditingSession(chatSessionId) {
+        await this._restoringEditingSession;
+        const session = this.getEditingSession(chatSessionId);
+        if (session) {
+            return session;
+        }
+        return this.createEditingSession(chatSessionId, true);
+    }
+    _lookupEntry(uri) {
+        for (const item of Iterable.concat(this.editingSessionsObs.get())) {
+            const candidate = item.getEntry(uri);
+            if (candidate instanceof AbstractChatEditingModifiedFileEntry) {
+                return candidate.acquire();
+            }
+        }
+        return undefined;
+    }
+    getEditingSession(chatSessionId) {
+        return this.editingSessionsObs.get()
+            .find(candidate => candidate.chatSessionId === chatSessionId);
+    }
+    async createEditingSession(chatSessionId, global = false) {
+        assertType(this.getEditingSession(chatSessionId) === undefined, 'CANNOT have more than one editing session per chat session');
+        const session = this._instantiationService.createInstance(ChatEditingSession, chatSessionId, global, this._lookupEntry.bind(this));
+        await session.init();
+        const list = this._sessionsObs.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._sessionsObs.set(list, undefined);
+            this._store.delete(store);
+        }));
+        this._sessionsObs.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());
+        observerDisposables.add(chatModel.onDidChange(async (e) => {
+            if (e.kind !== 'addRequest') {
+                return;
+            }
+            session.createSnapshot(e.request.id, undefined);
+            const responseModel = e.request.response;
+            if (responseModel) {
+                this.observerEditsInResponse(e.request.id, responseModel, session, observerDisposables);
+            }
+        }));
+        observerDisposables.add(chatModel.onDidDispose(() => observerDisposables.dispose()));
+        return observerDisposables;
+    }
+    observerEditsInResponse(requestId, responseModel, session, observerDisposables) {
+        const editsSeen = [];
+        const editedFilesExist = ( new ResourceMap());
+        const ensureEditorOpen = (partUri) => {
+            const uri = CellUri.parse(partUri)?.notebook ?? partUri;
+            if (( editedFilesExist.has(uri))) {
+                return;
+            }
+            editedFilesExist.set(uri, this._fileService.exists(uri).then((e) => {
+                if (!e) {
+                    return;
+                }
+                const activeUri = this._editorService.activeEditorPane?.input.resource;
+                const inactive = activeUri && ( session.workingSet.has(activeUri));
+                this._editorService.openEditor({ resource: uri, options: { inactive, preserveFocus: true, pinned: true } });
+            }));
+        };
+        const onResponseComplete = () => {
+            for (const remaining of editsSeen) {
+                remaining?.streaming.complete();
+            }
+            if (responseModel.result?.errorDetails && !responseModel.result.errorDetails.responseIsIncomplete) {
+                session.restoreSnapshot(responseModel.requestId, undefined);
+            }
+            editsSeen.length = 0;
+            editedFilesExist.clear();
+        };
+        const handleResponseParts = async () => {
+            if (responseModel.isCanceled) {
+                return;
+            }
+            let undoStop;
+            for (let i = 0; i < responseModel.response.value.length; i++) {
+                const part = responseModel.response.value[i];
+                if (part.kind === 'undoStop') {
+                    undoStop = part.id;
+                    continue;
+                }
+                if (part.kind !== 'textEditGroup' && part.kind !== 'notebookEditGroup') {
+                    continue;
+                }
+                ensureEditorOpen(part.uri);
+                let entry = editsSeen[i];
+                if (!entry) {
+                    entry = { seen: 0, streaming: session.startStreamingEdits(CellUri.parse(part.uri)?.notebook ?? part.uri, responseModel, undoStop) };
+                    editsSeen[i] = entry;
+                }
+                const isFirst = entry.seen === 0;
+                const newEdits = part.edits.slice(entry.seen).flat();
+                entry.seen = part.edits.length;
+                if (newEdits.length > 0 || isFirst) {
+                    if (part.kind === 'notebookEditGroup') {
+                        newEdits.forEach(edit => {
+                            if (TextEdit.isTextEdit(edit)) {
+                                return;
+                            }
+                            else if (isCellTextEditOperation(edit)) {
+                                entry.streaming.pushNotebookCellText(edit.uri, [edit.edit]);
+                            }
+                            else {
+                                entry.streaming.pushNotebook([edit]);
+                            }
+                        });
+                    }
+                    else if (part.kind === 'textEditGroup') {
+                        entry.streaming.pushText(newEdits);
+                    }
+                }
+                if (part.done) {
+                    entry.streaming.complete();
+                }
+            }
+        };
+        if (responseModel.isComplete) {
+            handleResponseParts().then(() => {
+                onResponseComplete();
+            });
+        }
+        else {
+            const disposable = observerDisposables.add(responseModel.onDidChange(e2 => {
+                if (e2.reason === 'undoStop') {
+                    session.createSnapshot(requestId, e2.id);
+                }
+                else {
+                    handleResponseParts().then(() => {
+                        if (responseModel.isComplete) {
+                            onResponseComplete();
+                            observerDisposables.delete(disposable);
+                        }
+                    });
+                }
+            }));
+        }
+    }
+    hasRelatedFilesProviders() {
+        return this._chatRelatedFilesProviders.size > 0;
+    }
+    registerRelatedFilesProvider(handle, provider) {
+        this._chatRelatedFilesProviders.set(handle, provider);
+        return toDisposable(() => {
+            this._chatRelatedFilesProviders.delete(handle);
+        });
+    }
+    async getRelatedFiles(chatSessionId, prompt, files, token) {
+        const providers = Array.from(( this._chatRelatedFilesProviders.values()));
+        const result = await Promise.all(( providers.map(async (provider) => {
+            try {
+                const relatedFiles = await provider.provideRelatedFiles({ prompt, files }, 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, IStorageService)),
+    ( __param(10, ILogService)),
+    ( __param(11, IExtensionService)),
+    ( __param(12, 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(_sessions, _chatAgentService) {
+        super();
+        this._sessions = _sessions;
+        this._chatAgentService = _chatAgentService;
+        this.label = ( localize(4581, "Chat Editing"));
+        this._currentEntries = derived(this, (r) => {
+            const sessions = this._sessions.read(r);
+            if (!sessions) {
+                return [];
+            }
+            const result = [];
+            for (const session of sessions) {
+                if (session.state.read(r) !== ChatEditingSessionState.Disposed) {
+                    const entries = session.entries.read(r);
+                    result.push(...entries);
+                }
+            }
+            return result;
+        });
+        this._currentlyEditingUris = derived(this, (r) => {
+            const uri = this._currentEntries.read(r);
+            return ( uri.filter(entry => entry.isCurrentlyBeingModifiedBy.read(r)).map(entry => entry.modifiedURI));
+        });
+        this._modifiedUris = derived(this, (r) => {
+            const uri = this._currentEntries.read(r);
+            return ( uri.filter(entry => !entry.isCurrentlyBeingModifiedBy.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(4582, "Pending changes from {0}", defaultAgentName)) : ( localize(4583, "Pending changes from chat")),
+                bubble: true
+            };
+        }
+        return undefined;
+    }
+};
+ChatDecorationsProvider = ( __decorate([
+    ( __param(1, IChatAgentService))
+], ChatDecorationsProvider));
+let ChatEditingMultiDiffSourceResolver = class ChatEditingMultiDiffSourceResolver {
+    constructor(_editingSessionsObs, _instantiationService) {
+        this._editingSessionsObs = _editingSessionsObs;
+        this._instantiationService = _instantiationService;
+    }
+    canHandleUri(uri) {
+        return uri.scheme === CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME;
+    }
+    async resolveDiffSource(uri) {
+        const thisSession = derived(this, r => {
+            return this._editingSessionsObs.read(r).find(candidate => candidate.chatSessionId === uri.authority);
+        });
+        return this._instantiationService.createInstance(ChatEditingMultiDiffSource, thisSession);
+    }
+};
+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/chatEditor.d.ts

@@ -7,10 +7,10 @@ import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
-import { EditorPane } from "@codingame/monaco-vscode-d0fb86d3-2a47-594e-955b-9a24631a7124-common/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { EditorPane } from "@codingame/monaco-vscode-12c5f9eb-72d3-57ca-babd-5bef7aa9de3b-common/vscode/vs/workbench/browser/parts/editor/editorPane";
 import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
-import { ChatEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput";
-import { IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { ChatEditorInput } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput";
+import { IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
 export interface IChatEditorOptions extends IEditorOptions {
     target?: {

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

@@ -18,13 +18,13 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/misc
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
 import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
-import { EditorPane } from '@codingame/monaco-vscode-d0fb86d3-2a47-594e-955b-9a24631a7124-common/vscode/vs/workbench/browser/parts/editor/editorPane';
-import { Memento } from '@codingame/monaco-vscode-91789cdf-e3cb-5a04-aaeb-6f7df7d3d231-common/vscode/vs/workbench/common/memento';
-import { clearChatEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatClear';
-import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
-import { ChatWidget } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
+import { EditorPane } from '@codingame/monaco-vscode-12c5f9eb-72d3-57ca-babd-5bef7aa9de3b-common/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { Memento } from '@codingame/monaco-vscode-12c5f9eb-72d3-57ca-babd-5bef7aa9de3b-common/vscode/vs/workbench/common/memento';
+import { clearChatEditor } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/actions/chatClear';
+import { ChatEditorInput } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { ChatWidget } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatWidget';
 import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
+import { CHAT_PROVIDER_ID } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
 import { EDITOR_DRAG_AND_DROP_BACKGROUND } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/theme';
 
 let ChatEditor = class ChatEditor extends EditorPane {
@@ -47,7 +47,6 @@ let ChatEditor = class ChatEditor extends EditorPane {
         const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
         this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, undefined, {
             supportsFileReferences: true,
-            enableImplicitContext: true
         }, {
             listForeground: editorForeground,
             listBackground: editorBackground,