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

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

@@ -0,0 +1,379 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '../media/chatEditingEditorOverlay.css.js';
+import { DisposableStore, MutableDisposable, toDisposable, DisposableMap, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { WorkingSetEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { append, addDisposableGenericMouseMoveListener, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { navigationBearingFakeActionId, AcceptAction, RejectAction } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorActions';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { EditorGroupView } from '@codingame/monaco-vscode-ad89fae6-94f0-5ac2-a185-22dea4b68ee0-common/vscode/vs/workbench/browser/parts/editor/editorGroupView';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ObservableEditorSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys';
+import { rcut } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { observableFromEvent, observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+import { observableValue, transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+
+let ChatEditorOverlayWidget = class ChatEditorOverlayWidget {
+    constructor(_editor, _chatService, instaService) {
+        this._editor = _editor;
+        this._chatService = _chatService;
+        this._showStore = ( new DisposableStore());
+        this._session = observableValue(this, undefined);
+        this._entry = observableValue(this, undefined);
+        this._navigationBearings = observableValue(this, { changeCount: -1, activeIdx: -1, entriesCount: -1 });
+        this._domNode = document.createElement('div');
+        this._domNode.classList.add('chat-editor-overlay-widget');
+        const progressNode = document.createElement('div');
+        progressNode.classList.add('chat-editor-overlay-progress');
+        append(progressNode, renderIcon(ThemeIcon.modify(Codicon.loading, 'spin')));
+        this._domNode.appendChild(progressNode);
+        const toolbarNode = document.createElement('div');
+        toolbarNode.classList.add('chat-editor-overlay-toolbar');
+        this._domNode.appendChild(toolbarNode);
+        this._toolbar = instaService.createInstance(MenuWorkbenchToolBar, toolbarNode, MenuId.ChatEditingEditorContent, {
+            telemetrySource: 'chatEditor.overlayToolbar',
+            hiddenItemStrategy: HiddenItemStrategy.Ignore,
+            toolbarOptions: {
+                primaryGroup: () => true,
+                useSeparatorsInPrimaryActions: true
+            },
+            menuOptions: { renderShortTitle: true },
+            actionViewItemProvider: (action, options) => {
+                const that = this;
+                if (action.id === navigationBearingFakeActionId) {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, { ...options, icon: false, label: true, keybindingNotRenderedWithLabel: true });
+                        }
+                        render(container) {
+                            super.render(container);
+                            container.classList.add('label-item');
+                            this._store.add(autorun(r => {
+                                assertType(this.label);
+                                const { changeCount, activeIdx } = that._navigationBearings.read(r);
+                                if (changeCount > 0) {
+                                    const n = activeIdx === -1 ? '1' : `${activeIdx + 1}`;
+                                    this.label.innerText = ( localize(4564, "{0} of {1}", n, changeCount));
+                                }
+                                else {
+                                    this.label.innerText = ( localize(4565, "0 of 0"));
+                                }
+                                this.updateTooltip();
+                            }));
+                        }
+                        getTooltip() {
+                            const { changeCount, entriesCount } = that._navigationBearings.get();
+                            if (changeCount === -1 || entriesCount === -1) {
+                                return undefined;
+                            }
+                            else if (changeCount === 1 && entriesCount === 1) {
+                                return localize(4566, "1 change in 1 file");
+                            }
+                            else if (changeCount === 1) {
+                                return localize(4567, "1 change in {0} files", entriesCount);
+                            }
+                            else if (entriesCount === 1) {
+                                return localize(4568, "{0} changes in 1 file", changeCount);
+                            }
+                            else {
+                                return localize(4569, "{0} changes in {1} files", changeCount, entriesCount);
+                            }
+                        }
+                    });
+                }
+                if (action.id === AcceptAction.ID || action.id === RejectAction.ID) {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, { ...options, icon: false, label: true, keybindingNotRenderedWithLabel: true });
+                            this._reveal = this._store.add(( new MutableDisposable()));
+                        }
+                        render(container) {
+                            super.render(container);
+                            if (action.id === AcceptAction.ID) {
+                                const listener = this._store.add(( new MutableDisposable()));
+                                this._store.add(autorun(r => {
+                                    assertType(this.label);
+                                    assertType(this.element);
+                                    const ctrl = that._entry.read(r)?.autoAcceptController.read(r);
+                                    if (ctrl) {
+                                        const r = -100 * (ctrl.remaining / ctrl.total);
+                                        this.element.style.setProperty('--vscode-action-item-auto-timeout', `${r}%`);
+                                        this.element.classList.toggle('auto', true);
+                                        listener.value = addDisposableGenericMouseMoveListener(this.element, () => ctrl.cancel());
+                                    }
+                                    else {
+                                        this.element.classList.toggle('auto', false);
+                                        listener.clear();
+                                    }
+                                }));
+                            }
+                        }
+                        set actionRunner(actionRunner) {
+                            super.actionRunner = actionRunner;
+                            this._reveal.value = actionRunner.onWillRun(_e => {
+                                that._editor.focus();
+                            });
+                        }
+                        get actionRunner() {
+                            return super.actionRunner;
+                        }
+                    });
+                }
+                if (action.id === 'inlineChat2.reveal' || action.id === 'workbench.action.chat.openEditSession') {
+                    return new (class extends ActionViewItem {
+                        constructor() {
+                            super(undefined, action, options);
+                            this._requestMessage = derived(r => {
+                                const session = that._session.read(r);
+                                const chatModel = that._chatService.getSession(session?.chatSessionId ?? '');
+                                if (!session || !chatModel) {
+                                    return undefined;
+                                }
+                                const response = that._entry.read(r)?.isCurrentlyBeingModifiedBy.read(r);
+                                if (response) {
+                                    if (response?.isPaused.read(r)) {
+                                        return { message: ( localize(4570, "Edits Paused")), paused: true };
+                                    }
+                                    const entry = that._entry.read(r);
+                                    if (entry) {
+                                        const progress = entry?.rewriteRatio.read(r);
+                                        const message = progress === 0
+                                            ? ( localize(4571, "Generating Edits"))
+                                            : ( localize(4572, "{0}% Applying Edits", Math.round(progress * 100)));
+                                        return { message };
+                                    }
+                                }
+                                if (session.isGlobalEditingSession) {
+                                    return undefined;
+                                }
+                                const request = observableFromEvent(this, chatModel.onDidChange, () => chatModel.getRequests().at(-1)).read(r);
+                                if (!request || request.response?.isComplete) {
+                                    return undefined;
+                                }
+                                return { message: request.message.text };
+                            });
+                        }
+                        render(container) {
+                            super.render(container);
+                            container.classList.add('label-item');
+                            this._store.add(autorun(r => {
+                                assertType(this.label);
+                                const value = this._requestMessage.read(r);
+                                if (!value) {
+                                    this.options.icon = true;
+                                    this.options.label = false;
+                                    reset(this.label);
+                                    this.updateClass();
+                                    this.updateLabel();
+                                    this.updateTooltip();
+                                }
+                                else {
+                                    this.options.icon = false;
+                                    this.options.label = true;
+                                    this.updateClass();
+                                    this.updateTooltip();
+                                    const message = rcut(value.message, 47);
+                                    reset(this.label, message);
+                                }
+                                const busy = Boolean(value && !value.paused);
+                                that._domNode.classList.toggle('busy', busy);
+                                this.label.classList.toggle('busy', busy);
+                            }));
+                        }
+                        getTooltip() {
+                            return this._requestMessage.get()?.message || super.getTooltip();
+                        }
+                    });
+                }
+                return undefined;
+            }
+        });
+    }
+    dispose() {
+        this.hide();
+        this._showStore.dispose();
+        this._toolbar.dispose();
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    show(session, entry, indicies) {
+        this._showStore.clear();
+        transaction(tx => {
+            this._session.set(session, tx);
+            this._entry.set(entry, tx);
+        });
+        this._showStore.add(autorun(r => {
+            const entryIndex = indicies.entryIndex.read(r);
+            const changeIndex = indicies.changeIndex.read(r);
+            const entries = session.entries.read(r);
+            let activeIdx = entryIndex !== undefined && changeIndex !== undefined
+                ? changeIndex
+                : -1;
+            let totalChangesCount = 0;
+            for (let i = 0; i < entries.length; i++) {
+                const changesCount = entries[i].changesCount.read(r);
+                totalChangesCount += changesCount;
+                if (entryIndex !== undefined && i < entryIndex) {
+                    activeIdx += changesCount;
+                }
+            }
+            this._navigationBearings.set({ changeCount: totalChangesCount, activeIdx, entriesCount: entries.length }, undefined);
+        }));
+    }
+    hide() {
+        transaction(tx => {
+            this._session.set(undefined, tx);
+            this._entry.set(undefined, tx);
+            this._navigationBearings.set({ changeCount: -1, activeIdx: -1, entriesCount: -1 }, tx);
+        });
+        this._showStore.clear();
+    }
+};
+ChatEditorOverlayWidget = ( __decorate([
+    ( __param(1, IChatService)),
+    ( __param(2, IInstantiationService))
+], ChatEditorOverlayWidget));
+let ChatEditingOverlayController = class ChatEditingOverlayController {
+    constructor(container, group, instaService, chatService, chatEditingService, inlineChatService) {
+        this._store = ( new DisposableStore());
+        this._domNode = document.createElement('div');
+        this._domNode.classList.add('chat-editing-editor-overlay');
+        this._domNode.style.position = 'absolute';
+        this._domNode.style.bottom = `24px`;
+        this._domNode.style.right = `24px`;
+        this._domNode.style.zIndex = `100`;
+        const widget = instaService.createInstance(ChatEditorOverlayWidget, group);
+        this._domNode.appendChild(widget.getDomNode());
+        this._store.add(toDisposable(() => this._domNode.remove()));
+        this._store.add(widget);
+        const show = () => {
+            if (!container.contains(this._domNode)) {
+                container.appendChild(this._domNode);
+            }
+        };
+        const hide = () => {
+            if (container.contains(this._domNode)) {
+                widget.hide();
+                this._domNode.remove();
+            }
+        };
+        const activeEditorSignal = observableSignalFromEvent(this, Event.any(group.onDidActiveEditorChange, group.onDidModelChange));
+        const activeUriObs = derivedOpts({ equalsFn: isEqual }, r => {
+            activeEditorSignal.read(r);
+            const editor = group.activeEditorPane;
+            const uri = EditorResourceAccessor.getOriginalUri(editor?.input, { supportSideBySide: SideBySideEditor.PRIMARY });
+            return uri;
+        });
+        const sessionAndEntry = derived(r => {
+            activeEditorSignal.read(r);
+            const uri = activeUriObs.read(r);
+            if (!uri) {
+                return undefined;
+            }
+            return ( new ObservableEditorSession(uri, chatEditingService, inlineChatService)).value.read(r);
+        });
+        const isInProgress = derived(r => {
+            const session = sessionAndEntry.read(r)?.session;
+            if (!session) {
+                return false;
+            }
+            const chatModel = chatService.getSession(session.chatSessionId);
+            const lastResponse = observableFromEvent(this, chatModel.onDidChange, () => chatModel.getRequests().at(-1)?.response);
+            const response = lastResponse.read(r);
+            if (!response) {
+                return false;
+            }
+            return observableFromEvent(this, response.onDidChange, () => !response.isComplete).read(r);
+        });
+        this._store.add(autorun(r => {
+            const data = sessionAndEntry.read(r);
+            if (!data) {
+                hide();
+                return;
+            }
+            const { session, entry } = data;
+            if (entry?.state.read(r) === WorkingSetEntryState.Modified
+                || (!session.isGlobalEditingSession && isInProgress.read(r))
+            ) {
+                const editorPane = group.activeEditorPane;
+                assertType(editorPane);
+                const changeIndex = derived(r => entry
+                    ? entry.getEditorIntegration(editorPane).currentIndex.read(r)
+                    : 0);
+                const entryIndex = derived(r => entry
+                    ? session.entries.read(r).indexOf(entry)
+                    : 0);
+                widget.show(session, entry, { entryIndex, changeIndex });
+                show();
+            }
+            else {
+                hide();
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+ChatEditingOverlayController = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IChatService)),
+    ( __param(4, IChatEditingService)),
+    ( __param(5, IInlineChatSessionService))
+], ChatEditingOverlayController));
+let ChatEditingEditorOverlay = class ChatEditingEditorOverlay {
+    static { this.ID = 'chat.edits.editorOverlay'; }
+    constructor(editorGroupsService, instantiationService) {
+        this._store = ( new DisposableStore());
+        const editorGroups = observableFromEvent(this, Event.any(editorGroupsService.onDidAddGroup, editorGroupsService.onDidRemoveGroup), () => editorGroupsService.groups);
+        const overlayWidgets = ( new DisposableMap());
+        this._store.add(autorun(r => {
+            const toDelete = ( new Set(( overlayWidgets.keys())));
+            const groups = editorGroups.read(r);
+            for (const group of groups) {
+                if (!(group instanceof EditorGroupView)) {
+                    continue;
+                }
+                toDelete.delete(group);
+                if (!( overlayWidgets.has(group))) {
+                    const scopedInstaService = instantiationService.createChild(( new ServiceCollection([IContextKeyService, group.scopedContextKeyService])));
+                    const container = group.element;
+                    const ctrl = scopedInstaService.createInstance(ChatEditingOverlayController, container, group);
+                    overlayWidgets.set(group, combinedDisposable(ctrl, scopedInstaService));
+                }
+            }
+            for (const group of toDelete) {
+                overlayWidgets.deleteAndDispose(group);
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+ChatEditingEditorOverlay = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IInstantiationService))
+], ChatEditingEditorOverlay));
+
+export { ChatEditingEditorOverlay };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/{chatEditingService.d.ts → chatEditingServiceImpl.d.ts}

@@ -1,69 +1,53 @@
-import { CancellationToken, CancellationTokenSource } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
 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 { 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 { IMultiDiffSourceResolver, IResolvedMultiDiffSource } from "@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService";
+import { IMultiDiffSourceResolver, IResolvedMultiDiffSource } 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 { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
 import { IChatEditingSession, IChatRelatedFile, IChatRelatedFilesProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
 import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
-import { ChatEditingSession } from "./chatEditingSession.js";
 export declare class ChatEditingService extends Disposable implements IChatEditingService {
     private readonly _instantiationService;
     private readonly _chatService;
     private readonly _editorService;
     private readonly _fileService;
     private readonly lifecycleService;
-    private readonly _workbenchAssignmentService;
-    private readonly _chatAgentService;
     _serviceBrand: undefined;
-    private readonly _currentSessionObs;
-    private readonly _currentSessionDisposables;
-    private readonly _adhocSessionsObs;
+    private readonly _sessionsObs;
     readonly editingSessionsObs: IObservable<readonly IChatEditingSession[]>;
-    private readonly _currentAutoApplyOperationObs;
-    get currentAutoApplyOperation(): CancellationTokenSource | null;
-    get currentEditingSession(): IChatEditingSession | null;
-    get currentEditingSessionObs(): IObservable<IChatEditingSession | null>;
-    private _editingSessionFileLimitPromise;
-    private _editingSessionFileLimit;
-    get editingSessionFileLimit(): number;
     private _restoringEditingSession;
-    private _applyingChatEditsFailedContextKey;
     private _chatRelatedFilesProviders;
-    constructor(_instantiationService: IInstantiationService, multiDiffSourceResolverService: IMultiDiffSourceResolverService, textModelService: ITextModelService, contextKeyService: IContextKeyService, _chatService: IChatService, _editorService: IEditorService, decorationsService: IDecorationsService, _fileService: IFileService, lifecycleService: ILifecycleService, _workbenchAssignmentService: IWorkbenchAssignmentService, _chatAgentService: IChatAgentService, storageService: IStorageService, logService: ILogService, extensionService: IExtensionService, productService: IProductService);
-    getOrRestoreEditingSession(): Promise<IChatEditingSession | null>;
+    constructor(_instantiationService: IInstantiationService, multiDiffSourceResolverService: IMultiDiffSourceResolverService, textModelService: ITextModelService, contextKeyService: IContextKeyService, _chatService: IChatService, _editorService: IEditorService, decorationsService: IDecorationsService, _fileService: IFileService, lifecycleService: ILifecycleService, storageService: IStorageService, logService: ILogService, extensionService: IExtensionService, productService: IProductService);
     dispose(): void;
-    startOrContinueEditingSession(chatSessionId: string): Promise<IChatEditingSession>;
+    startOrContinueGlobalEditingSession(chatSessionId: string): Promise<IChatEditingSession>;
     private _lookupEntry;
-    private _createEditingSession;
-    createAdhocEditingSession(chatSessionId: string): Promise<IChatEditingSession & IDisposable>;
+    getEditingSession(chatSessionId: string): IChatEditingSession | undefined;
+    createEditingSession(chatSessionId: string, global?: boolean): Promise<IChatEditingSession>;
     private installAutoApplyObserver;
-    private _continueEditingSession;
+    private observerEditsInResponse;
     hasRelatedFilesProviders(): boolean;
     registerRelatedFilesProvider(handle: number, provider: IChatRelatedFilesProvider): IDisposable;
-    getRelatedFiles(chatSessionId: string, prompt: string, token: CancellationToken): Promise<{
+    getRelatedFiles(chatSessionId: string, prompt: string, files: URI[], token: CancellationToken): Promise<{
         group: string;
         files: IChatRelatedFile[];
     }[] | undefined>;
 }
 export declare class ChatEditingMultiDiffSourceResolver implements IMultiDiffSourceResolver {
-    private readonly _currentSession;
+    private readonly _editingSessionsObs;
     private readonly _instantiationService;
-    constructor(_currentSession: IObservable<ChatEditingSession | null>, _instantiationService: IInstantiationService);
+    constructor(_editingSessionsObs: IObservable<readonly IChatEditingSession[]>, _instantiationService: IInstantiationService);
     canHandleUri(uri: URI): boolean;
     resolveDiffSource(uri: URI): Promise<IResolvedMultiDiffSource>;
 }