@codingame/monaco-vscode-chat-service-override 31.0.0 → 32.0.0

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

@@ -0,0 +1,509 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import * as chatEditingExplanationWidget from './media/chatEditingExplanationWidget.css';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { $, addDisposableListener, clearNode, createTextNode, getTotalWidth } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { overviewRulerRangeHighlight } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editorColorRegistry';
+import { OverviewRulerLane } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
+import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(chatEditingExplanationWidget);
+function getChangeTexts(change, diffInfo) {
+    const originalLines = [];
+    const modifiedLines = [];
+    for (let i = change.original.startLineNumber; i < change.original.endLineNumberExclusive; i++) {
+        const line = diffInfo.originalModel.getLineContent(i);
+        originalLines.push(line);
+    }
+    for (let i = change.modified.startLineNumber; i < change.modified.endLineNumberExclusive; i++) {
+        const line = diffInfo.modifiedModel.getLineContent(i);
+        modifiedLines.push(line);
+    }
+    return {
+        originalText: originalLines.join("\n"),
+        modifiedText: modifiedLines.join("\n")
+    };
+}
+function groupNearbyChanges(changes, lineThreshold = 5) {
+    if (changes.length === 0) {
+        return [];
+    }
+    const groups = [];
+    let currentGroup = [changes[0]];
+    for (let i = 1; i < changes.length; i++) {
+        const firstChange = currentGroup[0];
+        const currentChange = changes[i];
+        const widgetLine = firstChange.modified.startLineNumber;
+        const lastLine = currentChange.modified.startLineNumber;
+        const verticalSpan = lastLine - widgetLine;
+        if (verticalSpan <= lineThreshold) {
+            currentGroup.push(currentChange);
+        } else {
+            groups.push(currentGroup);
+            currentGroup = [currentChange];
+        }
+    }
+    if (currentGroup.length > 0) {
+        groups.push(currentGroup);
+    }
+    return groups;
+}
+class ChatEditingExplanationWidget extends Disposable {
+    static {
+        this._idPool = 0;
+    }
+    constructor(
+        _editor,
+        _changes,
+        diffInfo,
+        _chatWidgetService,
+        _viewsService,
+        _chatSessionResource
+    ) {
+        super();
+        this._editor = _editor;
+        this._changes = _changes;
+        this._chatWidgetService = _chatWidgetService;
+        this._viewsService = _viewsService;
+        this._chatSessionResource = _chatSessionResource;
+        this._id = `chat-explanation-widget-${ChatEditingExplanationWidget._idPool++}`;
+        this._explanationItems = ( new Map());
+        this._position = null;
+        this._explanations = [];
+        this._isExpanded = true;
+        this._isAllRead = false;
+        this._disposed = false;
+        this._startLineNumber = 1;
+        this._eventStore = this._register(( new DisposableStore()));
+        this._uri = diffInfo.modifiedModel.uri;
+        this._rangeHighlightDecoration = this._editor.createDecorationsCollection();
+        this._explanations = ( this._changes.map(change => {
+            const {
+                originalText,
+                modifiedText
+            } = getChangeTexts(change, diffInfo);
+            return {
+                startLineNumber: change.modified.startLineNumber,
+                endLineNumber: change.modified.endLineNumberExclusive - 1,
+                explanation: ( localize(6367, "Generating explanation...")),
+                read: false,
+                loading: true,
+                originalText,
+                modifiedText
+            };
+        }));
+        this._domNode = $("div.chat-explanation-widget");
+        this._headerNode = $("div.chat-explanation-header");
+        this._readIndicator = $("div.chat-explanation-read-indicator");
+        this._updateReadIndicator();
+        this._headerNode.appendChild(this._readIndicator);
+        this._titleNode = $("span.chat-explanation-title");
+        this._updateTitle();
+        this._headerNode.appendChild(this._titleNode);
+        this._headerNode.appendChild($("span.chat-explanation-spacer"));
+        this._toggleButton = $("div.chat-explanation-toggle");
+        this._updateToggleButton();
+        this._headerNode.appendChild(this._toggleButton);
+        this._dismissButton = $("div.chat-explanation-dismiss");
+        this._dismissButton.appendChild(renderIcon(Codicon.close));
+        this._dismissButton.title = ( localize(6368, "Dismiss"));
+        this._headerNode.appendChild(this._dismissButton);
+        this._domNode.appendChild(this._headerNode);
+        this._bodyNode = $("div.chat-explanation-body");
+        this._buildExplanationItems();
+        this._domNode.appendChild(this._bodyNode);
+        const arrow = $("div.chat-explanation-arrow");
+        this._domNode.appendChild(arrow);
+        this._setupEventHandlers();
+        this._domNode.classList.add("visible");
+        this._editor.addOverlayWidget(this);
+    }
+    _setupEventHandlers() {
+        this._eventStore.add(addDisposableListener(this._readIndicator, "click", e => {
+            e.stopPropagation();
+            this._isAllRead = !this._isAllRead;
+            for (const exp of this._explanations) {
+                exp.read = this._isAllRead;
+            }
+            this._updateReadIndicator();
+            this._updateExplanationItemsReadState();
+        }));
+        this._eventStore.add(addDisposableListener(this._toggleButton, "click", e => {
+            e.stopPropagation();
+            this._toggleExpanded();
+        }));
+        this._eventStore.add(addDisposableListener(this._headerNode, "click", () => {
+            this._toggleExpanded();
+        }));
+        this._eventStore.add(addDisposableListener(this._dismissButton, "click", e => {
+            e.stopPropagation();
+            this._dismiss();
+        }));
+    }
+    _toggleExpanded() {
+        this._isExpanded = !this._isExpanded;
+        this._bodyNode.classList.toggle("collapsed", !this._isExpanded);
+        this._updateToggleButton();
+        this._editor.layoutOverlayWidget(this);
+    }
+    _dismiss() {
+        this._domNode.classList.add("fadeOut");
+        const dispose = () => {
+            this.dispose();
+        };
+        const handle = setTimeout(dispose, 150);
+        this._domNode.addEventListener("animationend", () => {
+            clearTimeout(handle);
+            dispose();
+        }, {
+            once: true
+        });
+    }
+    _updateReadIndicator() {
+        clearNode(this._readIndicator);
+        const allRead = this._explanations.every(e => e.read);
+        const someRead = ( this._explanations.some(e => e.read));
+        this._isAllRead = allRead;
+        if (allRead) {
+            this._readIndicator.appendChild(renderIcon(Codicon.circle));
+            this._readIndicator.classList.add("read");
+            this._readIndicator.classList.remove("partial", "unread");
+            this._readIndicator.title = ( localize(6369, "Mark as unread"));
+        } else if (someRead) {
+            this._readIndicator.appendChild(renderIcon(Codicon.circleFilled));
+            this._readIndicator.classList.remove("read", "unread");
+            this._readIndicator.classList.add("partial");
+            this._readIndicator.title = ( localize(6370, "Mark all as read"));
+        } else {
+            this._readIndicator.appendChild(renderIcon(Codicon.circleFilled));
+            this._readIndicator.classList.remove("read", "partial");
+            this._readIndicator.classList.add("unread");
+            this._readIndicator.title = ( localize(6371, "Mark as read"));
+        }
+    }
+    _updateTitle() {
+        const count = this._explanations.length;
+        if (count === 1) {
+            this._titleNode.textContent = ( localize(6372, "1 change"));
+        } else {
+            this._titleNode.textContent = ( localize(6373, "{0} changes", count));
+        }
+    }
+    _updateToggleButton() {
+        clearNode(this._toggleButton);
+        if (this._isExpanded) {
+            this._toggleButton.appendChild(renderIcon(Codicon.chevronUp));
+            this._toggleButton.title = ( localize(6374, "Collapse"));
+        } else {
+            this._toggleButton.appendChild(renderIcon(Codicon.chevronDown));
+            this._toggleButton.title = ( localize(6375, "Expand"));
+        }
+    }
+    _buildExplanationItems() {
+        clearNode(this._bodyNode);
+        this._explanationItems.clear();
+        for (let i = 0; i < this._explanations.length; i++) {
+            const exp = this._explanations[i];
+            const item = $("div.chat-explanation-item");
+            const lineInfo = $("span.chat-explanation-line-info");
+            if (exp.startLineNumber === exp.endLineNumber) {
+                lineInfo.textContent = ( localize(6376, "Line {0}", exp.startLineNumber));
+            } else {
+                lineInfo.textContent = ( localize(6377, "Lines {0}-{1}", exp.startLineNumber, exp.endLineNumber));
+            }
+            item.appendChild(lineInfo);
+            const text = $("span.chat-explanation-text");
+            if (exp.loading) {
+                const loadingIcon = renderIcon(ThemeIcon.modify(Codicon.loading, "spin"));
+                loadingIcon.classList.add("chat-explanation-loading");
+                text.appendChild(loadingIcon);
+                const loadingText = createTextNode(" " + exp.explanation);
+                text.appendChild(loadingText);
+            } else {
+                text.textContent = exp.explanation;
+            }
+            item.appendChild(text);
+            const itemReadIndicator = $("div.chat-explanation-item-read");
+            this._updateItemReadIndicator(itemReadIndicator, exp.read);
+            item.appendChild(itemReadIndicator);
+            const replyButton = $("div.chat-explanation-reply-button");
+            replyButton.appendChild(renderIcon(Codicon.arrowRight));
+            replyButton.title = ( localize(6378, "Follow up on this change"));
+            item.appendChild(replyButton);
+            this._eventStore.add(addDisposableListener(replyButton, "click", async e => {
+                e.stopPropagation();
+                const range = ( new Range(exp.startLineNumber, 1, exp.endLineNumber, 1));
+                let chatWidget;
+                if (this._chatSessionResource) {
+                    chatWidget = await this._chatWidgetService.openSession(this._chatSessionResource);
+                } else {
+                    await this._viewsService.openView(ChatViewId, true);
+                    chatWidget = this._chatWidgetService.lastFocusedWidget;
+                }
+                if (chatWidget) {
+                    chatWidget.attachmentModel.addContext(chatWidget.attachmentModel.asFileVariableEntry(this._uri, range));
+                }
+            }));
+            this._eventStore.add(addDisposableListener(item, "click", e => {
+                e.stopPropagation();
+                exp.read = !exp.read;
+                this._updateItemReadIndicator(itemReadIndicator, exp.read);
+                this._updateReadIndicator();
+            }));
+            this._eventStore.add(addDisposableListener(item, "mouseenter", () => {
+                const range = ( new Range(
+                    exp.startLineNumber,
+                    1,
+                    exp.endLineNumber,
+                    this._editor.getModel()?.getLineMaxColumn(exp.endLineNumber) ?? 1
+                ));
+                this._rangeHighlightDecoration.set([
+                {
+                    range,
+                    options: {
+                        description: "chat-explanation-range-highlight",
+                        className: "rangeHighlight",
+                        isWholeLine: true,
+                        linesDecorationsClassName: "chat-explanation-range-glyph"
+                    }
+                },
+                {
+                    range,
+                    options: {
+                        description: "chat-explanation-range-highlight-overview",
+                        overviewRuler: {
+                            color: themeColorFromId(overviewRulerRangeHighlight),
+                            position: OverviewRulerLane.Full
+                        }
+                    }
+                }]);
+            }));
+            this._eventStore.add(addDisposableListener(item, "mouseleave", () => {
+                this._rangeHighlightDecoration.clear();
+            }));
+            this._explanationItems.set(i, {
+                item,
+                readIndicator: itemReadIndicator,
+                textElement: text
+            });
+            this._bodyNode.appendChild(item);
+        }
+    }
+    setExplanationByLineNumber(startLineNumber, endLineNumber, explanation) {
+        for (let i = 0; i < this._explanations.length; i++) {
+            const exp = this._explanations[i];
+            if (exp.startLineNumber === startLineNumber && exp.endLineNumber === endLineNumber) {
+                exp.explanation = explanation;
+                exp.loading = false;
+                this._updateExplanationText(i);
+                return true;
+            }
+        }
+        return false;
+    }
+    get explanationCount() {
+        return this._explanations.length;
+    }
+    _updateExplanationText(index) {
+        const itemData = this._explanationItems.get(index);
+        const exp = this._explanations[index];
+        if (itemData && exp) {
+            clearNode(itemData.textElement);
+            itemData.textElement.textContent = exp.explanation;
+        }
+    }
+    _updateItemReadIndicator(element, read) {
+        clearNode(element);
+        if (read) {
+            element.appendChild(renderIcon(Codicon.circle));
+            element.classList.add("read");
+            element.classList.remove("unread");
+        } else {
+            element.appendChild(renderIcon(Codicon.circleFilled));
+            element.classList.remove("read");
+            element.classList.add("unread");
+        }
+    }
+    _updateExplanationItemsReadState() {
+        this._explanationItems.forEach((
+            {
+                readIndicator
+            },
+            index
+        ) => {
+            const exp = this._explanations[index];
+            this._updateItemReadIndicator(readIndicator, exp.read);
+        });
+    }
+    layout(startLineNumber) {
+        if (this._disposed) {
+            return;
+        }
+        this._startLineNumber = startLineNumber;
+        const lineHeight = this._editor.getOption(EditorOption.lineHeight);
+        const {
+            contentLeft,
+            contentWidth,
+            verticalScrollbarWidth
+        } = this._editor.getLayoutInfo();
+        const scrollTop = this._editor.getScrollTop();
+        const widgetWidth = getTotalWidth(this._domNode) || 280;
+        this._position = {
+            stackOrdinal: 2,
+            preference: {
+                top: this._editor.getTopForLineNumber(startLineNumber) - scrollTop - lineHeight,
+                left: contentLeft + contentWidth - (2 * verticalScrollbarWidth + widgetWidth)
+            }
+        };
+        this._editor.layoutOverlayWidget(this);
+    }
+    toggle(show) {
+        this._domNode.classList.toggle("visible", show);
+        if (show && this._explanations.length > 0) {
+            this.layout(this._explanations[0].startLineNumber);
+        }
+    }
+    relayout() {
+        if (this._startLineNumber) {
+            this.layout(this._startLineNumber);
+        }
+    }
+    getId() {
+        return this._id;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        return this._position;
+    }
+    dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        this._rangeHighlightDecoration.clear();
+        this._editor.removeOverlayWidget(this);
+        super.dispose();
+    }
+}
+class ChatEditingExplanationWidgetManager extends Disposable {
+    constructor(_editor, _chatWidgetService, _viewsService, modelManager, _modelUri) {
+        super();
+        this._editor = _editor;
+        this._chatWidgetService = _chatWidgetService;
+        this._viewsService = _viewsService;
+        this._modelUri = _modelUri;
+        this._widgets = [];
+        this._visible = false;
+        this._register(this._editor.onDidChangeModel(() => {
+            const newUri = this._editor.getModel()?.uri;
+            if (this._modelUri) {
+                if (newUri && ( newUri.toString()) === ( this._modelUri.toString())) {
+                    for (const widget of this._widgets) {
+                        widget.toggle(this._visible);
+                        widget.relayout();
+                    }
+                } else {
+                    for (const widget of this._widgets) {
+                        widget.toggle(false);
+                    }
+                }
+            }
+        }));
+        this._register(autorun(r => {
+            const state = modelManager.state.read(r);
+            const uriState = state.get(this._modelUri);
+            if (uriState) {
+                this._diffInfo = uriState.diffInfo;
+                this._chatSessionResource = uriState.chatSessionResource;
+                if (this._widgets.length === 0 && this._diffInfo) {
+                    this._createWidgets(this._diffInfo, this._chatSessionResource);
+                }
+                if (uriState.progress === "complete") {
+                    this._handleExplanations(this._modelUri, uriState.explanations);
+                }
+                this.show();
+            } else {
+                this.hide();
+            }
+        }));
+    }
+    _createWidgets(diffInfo, chatSessionResource) {
+        if (diffInfo.identical || diffInfo.changes.length === 0) {
+            return;
+        }
+        const groups = groupNearbyChanges(diffInfo.changes, 5);
+        for (const group of groups) {
+            const widget = ( new ChatEditingExplanationWidget(
+                this._editor,
+                group,
+                diffInfo,
+                this._chatWidgetService,
+                this._viewsService,
+                chatSessionResource
+            ));
+            this._widgets.push(widget);
+            this._register(widget);
+            widget.layout(group[0].modified.startLineNumber);
+        }
+        this._register(
+            Event.any(this._editor.onDidScrollChange, this._editor.onDidLayoutChange)(() => {
+                for (const widget of this._widgets) {
+                    widget.relayout();
+                }
+            })
+        );
+    }
+    _handleExplanations(uri, explanations) {
+        if (!this._modelUri || ( uri.toString()) !== ( this._modelUri.toString())) {
+            return;
+        }
+        for (const explanation of explanations) {
+            for (const widget of this._widgets) {
+                if (widget.setExplanationByLineNumber(
+                    explanation.startLineNumber,
+                    explanation.endLineNumber,
+                    explanation.explanation
+                )) {
+                    break;
+                }
+            }
+        }
+    }
+    show() {
+        this._visible = true;
+        for (const widget of this._widgets) {
+            widget.toggle(true);
+            widget.relayout();
+        }
+    }
+    hide() {
+        this._visible = false;
+        for (const widget of this._widgets) {
+            widget.toggle(false);
+        }
+    }
+    _clearWidgets() {
+        for (const widget of this._widgets) {
+            widget.dispose();
+        }
+        this._widgets.length = 0;
+    }
+    dispose() {
+        this._clearWidgets();
+        super.dispose();
+    }
+}
+
+export { ChatEditingExplanationWidget, ChatEditingExplanationWidgetManager };

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

@@ -142,7 +142,7 @@ let ChatEditingModifiedDocumentEntry = class ChatEditingModifiedDocumentEntry ex
             if (inProgress) {
                 const res = this._lastModifyingResponseObs.read(r);
                 const req = res && res.session.getRequests().find(value => value.id === res.requestId);
-                resourceFilter.value = markerService.installResourceFilter(this.modifiedURI, req?.message.text || ( localize(6143, "Chat Edits")));
+                resourceFilter.value = markerService.installResourceFilter(this.modifiedURI, req?.message.text || ( localize(6379, "Chat Edits")));
             } else {
                 resourceFilter.clear();
             }
@@ -187,7 +187,7 @@ let ChatEditingModifiedDocumentEntry = class ChatEditingModifiedDocumentEntry ex
     }
     _createUndoRedoElement(response) {
         const request = response.session.getRequests().find(req => req.id === response.requestId);
-        const label = request?.message.text ? ( localize(6144, "Chat Edit: '{0}'", request.message.text)) : ( localize(6145, "Chat Edit"));
+        const label = request?.message.text ? ( localize(6380, "Chat Edit: '{0}'", request.message.text)) : ( localize(6381, "Chat Edit"));
         return ( new SingleModelEditStackElement(label, "chat.edit", this.modifiedModel, null));
     }
     async acceptAgentEdits(resource, textEdits, isLastEdits, responseModel) {

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

@@ -42,7 +42,7 @@ class AutoAcceptControl {
         this.cancel = cancel;
     }
 }
-const pendingRewriteMinimap = registerColor("minimap.chatEditHighlight", ( transparent(editorBackground, 0.6)), ( localize(6146, "Color of pending edit regions in the minimap")));
+const pendingRewriteMinimap = registerColor("minimap.chatEditHighlight", ( transparent(editorBackground, 0.6)), ( localize(6382, "Color of pending edit regions in the minimap")));
 let AbstractChatEditingModifiedFileEntry = class AbstractChatEditingModifiedFileEntry extends Disposable {
     static {
         AbstractChatEditingModifiedFileEntry_1 = this;
@@ -232,7 +232,7 @@ let AbstractChatEditingModifiedFileEntry = class AbstractChatEditingModifiedFile
         });
     }
     _notifyAction(action) {
-        if (action.kind === "chatEditingHunkAction") {
+        if (action.kind === "chatEditingHunkAction" && action.outcome === "accepted") {
             this._aiEditTelemetryService.handleCodeAccepted({
                 suggestionId: undefined,
                 acceptanceMethod: "accept",
@@ -243,7 +243,22 @@ let AbstractChatEditingModifiedFileEntry = class AbstractChatEditingModifiedFile
                 editDeltaInfo: ( new EditDeltaInfo(action.linesAdded, action.linesRemoved, -1, -1)),
                 feature: this._telemetryInfo.feature,
                 languageId: action.languageId,
-                source: undefined
+                source: undefined,
+                sourceRequestId: this._telemetryInfo.requestId
+            });
+        } else if (action.kind === "chatEditingHunkAction" && action.outcome === "rejected") {
+            this._aiEditTelemetryService.handleCodeRejected({
+                suggestionId: undefined,
+                rejectionMethod: "reject",
+                presentation: "highlightedEdit",
+                modelId: this._telemetryInfo.modelId,
+                modeId: this._telemetryInfo.modeId,
+                applyCodeBlockSuggestionId: this._telemetryInfo.applyCodeBlockSuggestionId,
+                editDeltaInfo: ( new EditDeltaInfo(action.linesAdded, action.linesRemoved, -1, -1)),
+                feature: this._telemetryInfo.feature,
+                languageId: action.languageId,
+                source: undefined,
+                sourceRequestId: this._telemetryInfo.requestId
             });
         }
         this._chatService.notifyUserAction({

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

@@ -485,7 +485,7 @@ let ChatEditingModifiedNotebookEntry = class ChatEditingModifiedNotebookEntry ex
     }
     _createUndoRedoElement(response) {
         const request = response.session.getRequests().find(req => req.id === response.requestId);
-        const label = request?.message.text ? ( localize(6147, "Chat Edit: '{0}'", request.message.text)) : ( localize(6148, "Chat Edit"));
+        const label = request?.message.text ? ( localize(6383, "Chat Edit: '{0}'", request.message.text)) : ( localize(6384, "Chat Edit"));
         const transientOptions = this.transientOptions;
         const outputSizeLimit = this.configurationService.getValue(NotebookSetting.outputBackupSizeLimit) * 1024;
         let initial = createSnapshot(this.modifiedModel, transientOptions, outputSizeLimit);

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

@@ -4,7 +4,7 @@ import { delta, compareBy } from '@codingame/monaco-vscode-api/vscode/vs/base/co
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { groupBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
 import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+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';
@@ -36,6 +36,7 @@ import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workben
 import { chatEditingAgentSupportsReadonlyReferencesContextKey, ChatEditingSessionState, ModifiedFileEntryState, CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, parseChatMultiDiffUri, chatEditingResourceContextKey, inChatEditingSessionContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
 import { isCellTextEditOperationArray } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
 import { AbstractChatEditingModifiedFileEntry } from './chatEditingModifiedFileEntry.js';
 import { ChatEditingSession } from './chatEditingSession.js';
@@ -125,7 +126,7 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             }
             e.join(storageTask, {
                 id: "join.chatEditingSession",
-                label: ( localize(6149, "Saving chat edits history"))
+                label: ( localize(6385, "Saving chat edits history"))
             });
         }));
     }
@@ -159,7 +160,7 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             this.getEditingSession(chatModel.sessionResource) === undefined,
             "CANNOT have more than one editing session per chat session"
         );
-        const provider = this._providers.get(chatModel.sessionResource.scheme);
+        const provider = this._providers.get(getChatSessionType(chatModel.sessionResource));
         const session = provider ? provider.createEditingSession(chatModel.sessionResource) : this._instantiationService.createInstance(
             ChatEditingSession,
             chatModel.sessionResource,
@@ -217,10 +218,7 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             K[K["Workspace"] = 1] = "Workspace";
         })(K || (K = {}));
         const editsSeen = [];
-        let editorDidChange = false;
-        const editorListener = Event.once(this._editorService.onDidActiveEditorChange)(() => {
-            editorDidChange = true;
-        });
+        const initialActiveEditor = this._editorService.activeEditorPane?.input;
         const editorOpenPromises = ( new ResourceMap());
         const openChatEditedFiles = this._configurationService.getValue("accessibility.openChatEditedFiles");
         const ensureEditorOpen = partUri => {
@@ -231,6 +229,8 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             editorOpenPromises.set(uri, (async () => {
                 if (this.notebookService.getNotebookTextModel(uri) || uri.scheme === Schemas.untitled || (await this._fileService.exists(uri).catch(() => false))) {
                     const activeUri = this._editorService.activeEditorPane?.input.resource;
+                    const currentActiveEditor = this._editorService.activeEditorPane?.input;
+                    const editorDidChange = initialActiveEditor && currentActiveEditor ? !initialActiveEditor.matches(currentActiveEditor) : initialActiveEditor !== currentActiveEditor;
                     const inactive = editorDidChange || this._editorService.activeEditorPane?.input instanceof ChatEditorInput && isEqual(
                         this._editorService.activeEditorPane.input.sessionResource,
                         session.chatSessionResource
@@ -242,7 +242,8 @@ let ChatEditingService = class ChatEditingService extends Disposable {
                         options: {
                             inactive,
                             preserveFocus: true,
-                            pinned: true
+                            pinned: true,
+                            isExplicit: false
                         }
                     });
                 }
@@ -256,7 +257,6 @@ let ChatEditingService = class ChatEditingService extends Disposable {
             }
             editsSeen.length = 0;
             editorOpenPromises.clear();
-            editorListener.dispose();
         };
         const handleResponseParts = async () => {
             if (responseModel.isCanceled) {
@@ -358,7 +358,7 @@ class ChatDecorationsProvider extends Disposable {
     constructor(_sessions) {
         super();
         this._sessions = _sessions;
-        this.label = ( localize(6150, "Chat Editing"));
+        this.label = ( localize(6386, "Chat Editing"));
         this._currentEntries = derived(this, r => {
             const sessions = this._sessions.read(r);
             if (!sessions) {
@@ -402,7 +402,7 @@ class ChatDecorationsProvider extends Disposable {
             return {
                 weight: 1000,
                 letter: Codicon.diffModified,
-                tooltip: ( localize(6151, "Pending changes from chat")),
+                tooltip: ( localize(6387, "Pending changes from chat")),
                 bubble: true
             };
         }