@codingame/monaco-vscode-api 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatLivePreviewWidget.js

@@ -13,7 +13,7 @@ import { LineRange } from '../../../../editor/common/core/lineRange.js';
 import { Position } from '../../../../editor/common/core/position.js';
 import { EditorExtensionsRegistry } from '../../../../editor/browser/editorExtensions.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
-import { lineRangeAsRange, invertLineRange } from './utils.js';
+import { invertLineRange, asRange } from './utils.js';
 import { ResourceLabel } from '../../../browser/labels.js';
 import { FileKind } from '../../../../platform/files/common/files.js';
 import { FoldingController } from '../../../../editor/contrib/folding/browser/folding.js';
@@ -126,25 +126,25 @@ let InlineChatLivePreviewWidget = class InlineChatLivePreviewWidget extends Zone
     show() {
         throw new Error('use showForChanges');
     }
-    showForChanges(changes) {
+    showForChanges(hunk) {
         const hasFocus = this._diffEditor.hasTextFocus();
         this._isVisible = true;
-        const onlyInserts = changes.every(change => change.original.isEmpty);
-        if (onlyInserts || changes.length === 0 || this._session.textModel0.getValueLength() === 0) {
+        const onlyInserts = hunk.isInsertion();
+        if (onlyInserts || this._session.textModel0.getValueLength() === 0) {
             this._logService.debug('[IE] livePreview-mode: no diff');
             this._cleanupFullDiff();
-            this._renderInsertWithHighlight(changes);
+            this._renderInsertWithHighlight(hunk);
         }
         else {
             this._logService.debug('[IE] livePreview-mode: full diff');
             this._decorationCollection.clear();
-            this._renderChangesWithFullDiff(changes);
+            this._renderChangesWithFullDiff(hunk);
         }
         if (hasFocus) {
             this._diffEditor.focus();
         }
     }
-    _renderInsertWithHighlight(changes) {
+    _renderInsertWithHighlight(hunk) {
         assertType(this.editor.hasModel());
         const options = {
             description: 'inline-chat-insert',
@@ -152,17 +152,14 @@ let InlineChatLivePreviewWidget = class InlineChatLivePreviewWidget extends Zone
             isWholeLine: true,
             className: 'inline-chat-lines-inserted-range',
         };
-        this._decorationCollection.set(( changes.map(change => {
-            return {
-                range: lineRangeAsRange(change.modified),
-                options,
-            };
-        })));
+        this._decorationCollection.set([{
+                range: hunk.getRangesN()[0],
+                options
+            }]);
     }
-    _renderChangesWithFullDiff(changes) {
+    _renderChangesWithFullDiff(hunk) {
         assertType(this.editor.hasModel());
-        const modified = this.editor.getModel();
-        const ranges = this._computeHiddenRanges(modified, changes);
+        const ranges = this._computeHiddenRanges(this._session.textModelN, hunk);
         this._hideEditorRanges(this.editor, [ranges.modifiedHidden]);
         this._hideEditorRanges(this._diffEditor.getOriginalEditor(), ranges.originalDiffHidden);
         this._hideEditorRanges(this._diffEditor.getModifiedEditor(), ranges.modifiedDiffHidden);
@@ -179,13 +176,9 @@ let InlineChatLivePreviewWidget = class InlineChatLivePreviewWidget extends Zone
         super.hide();
         this._isVisible = false;
     }
-    _computeHiddenRanges(model, changes) {
-        let originalLineRange = changes[0].original;
-        let modifiedLineRange = changes[0].modified;
-        for (let i = 1; i < changes.length; i++) {
-            originalLineRange = originalLineRange.join(changes[i].original);
-            modifiedLineRange = modifiedLineRange.join(changes[i].modified);
-        }
+    _computeHiddenRanges(model, hunk) {
+        const modifiedLineRange = LineRange.fromRangeInclusive(hunk.getRangesN()[0]);
+        let originalLineRange = LineRange.fromRangeInclusive(hunk.getRanges0()[0]);
         if (originalLineRange.isEmpty) {
             originalLineRange = ( new LineRange(
                 originalLineRange.startLineNumber,
@@ -215,7 +208,7 @@ let InlineChatLivePreviewWidget = class InlineChatLivePreviewWidget extends Zone
             hiddenRanges = [editor.getModel().getFullModelRange().delta(1)];
         }
         else {
-            hiddenRanges = ( lineRanges.map(lineRangeAsRange));
+            hiddenRanges = ( lineRanges.map(lr => asRange(lr, editor.getModel())));
         }
         editor.setHiddenAreas(hiddenRanges, this._hideId);
         this._logService.debug(`[IE] diff HIDING ${hiddenRanges} for ${editor.getId()} with ${String(editor.getModel()?.uri)}`);

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+const IInlineChatSavingService = ( createDecorator('IInlineChatSavingService	'));
+export { IInlineChatSavingService };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSession.js

@@ -1,25 +1,27 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { ResourceFileEdit, ResourceTextEdit, ResourceEdit } from '../../../../editor/browser/services/bulkEditService.js';
-import { IInlineChatService } from '../common/inlineChat.js';
+import { CTX_INLINE_CHAT_HAS_STASHED_SESSION } from '../common/inlineChat.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-import { IModelService } from '../../../../editor/common/services/model.js';
-import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
-import { toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
-import { ModelDecorationOptions, createTextBufferFactoryFromSnapshot } from '../../../../editor/common/model/textModel.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { Iterable } from '../../../../base/common/iterator.js';
+import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
 import { toErrorMessage } from '../../../../base/common/errorMessage.js';
 import { isCancellationError } from '../../../../base/common/errors.js';
 import { EditOperation } from '../../../../editor/common/core/editOperation.js';
-import { raceCancellation } from '../../../../base/common/async.js';
+import { DetailedLineRangeMapping } from '../../../../editor/common/diff/rangeMapping.js';
 import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 import { ILanguageService } from '../../../../editor/common/languages/language.js';
 import { ResourceMap } from '../../../../base/common/map.js';
 import { Schemas } from '../../../../base/common/network.js';
 import { isEqual } from '../../../../base/common/resources.js';
+import { IInlineChatSessionService } from './inlineChatSessionService.js';
+import { IEditorWorkerService } from '../../../../editor/common/services/editorWorker.js';
+import { asRange } from './utils.js';
+import { coalesceInPlace } from '../../../../base/common/arrays.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+var HunkData_1;
 var ExpansionState;
 ( (function(ExpansionState) {
     ExpansionState["EXPANDED"] = "expanded";
@@ -72,6 +74,10 @@ class SessionWholeRange {
         this._decorationIds = [first].concat(newIds);
         this._onDidChange.fire(this);
     }
+    get trackedInitialRange() {
+        const [first] = this._decorationIds;
+        return this._textModel.getDecorationRange(first) ?? ( new Range(1, 1, 1, 1));
+    }
     get value() {
         let result;
         for (const id of this._decorationIds) {
@@ -89,14 +95,18 @@ class SessionWholeRange {
     }
 }
 class Session {
-    constructor(editMode, editor, textModel0, textModelN, provider, session, wholeRange) {
+    constructor(editMode,
+    targetUri,
+    textModel0,
+    textModelN, provider, session, wholeRange, hunkData) {
         this.editMode = editMode;
-        this.editor = editor;
+        this.targetUri = targetUri;
         this.textModel0 = textModel0;
         this.textModelN = textModelN;
         this.provider = provider;
         this.session = session;
         this.wholeRange = wholeRange;
+        this.hunkData = hunkData;
         this._isUnstashed = false;
         this._exchange = [];
         this._startTime = ( new Date());
@@ -105,9 +115,11 @@ class Session {
             extension: provider.debugName,
             startTime: this._startTime.toISOString(),
             edits: false,
+            finishedByEdit: false,
             rounds: '',
             undos: '',
-            editMode
+            editMode,
+            unstashed: 0
         };
     }
     addInput(input) {
@@ -120,6 +132,7 @@ class Session {
         return this._isUnstashed;
     }
     markUnstashed() {
+        this._teldata.unstashed += 1;
         this._isUnstashed = true;
     }
     get lastExpansionState() {
@@ -250,17 +263,13 @@ let ReplyResponse = class ReplyResponse {
                 }
             }
         }
-        if (editsMap.size === 0) {
-            this.responseType = "onlyMessages" ;
-        }
-        else if (editsMap.size === 1 && ( editsMap.has(localUri))) {
-            this.responseType = "onlyEdits" ;
-        }
-        else {
-            this.responseType = "mixed" ;
-        }
         let needsWorkspaceEdit = false;
         for (const [uri, edits] of editsMap) {
+            const flatEdits = edits.flat();
+            if (flatEdits.length === 0) {
+                editsMap.delete(uri);
+                continue;
+            }
             const isLocalUri = isEqual(uri, localUri);
             needsWorkspaceEdit = needsWorkspaceEdit || (uri.scheme !== Schemas.untitled && !isLocalUri);
             if (uri.scheme === Schemas.untitled && !isLocalUri && !this.untitledTextModel) {
@@ -272,7 +281,7 @@ let ReplyResponse = class ReplyResponse {
                 this.untitledTextModel = untitledTextModel;
                 untitledTextModel.resolve().then(async () => {
                     const model = untitledTextModel.textEditorModel;
-                    model.applyEdits(( edits.flat().map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
+                    model.applyEdits(( flatEdits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
                 });
             }
         }
@@ -286,132 +295,299 @@ let ReplyResponse = class ReplyResponse {
             }
             this.workspaceEdit = { edits: workspaceEdits };
         }
+        const hasEdits = editsMap.size > 0;
+        const hasMessage = mdContent.value.length > 0;
+        if (hasEdits && hasMessage) {
+            this.responseType = "mixed" ;
+        }
+        else if (hasEdits) {
+            this.responseType = "onlyEdits" ;
+        }
+        else if (hasMessage) {
+            this.responseType = "onlyMessages" ;
+        }
+        else {
+            this.responseType = "empty" ;
+        }
     }
 };
 ReplyResponse = ( __decorate([
     ( __param(6, ITextFileService)),
     ( __param(7, ILanguageService))
 ], ReplyResponse));
-const IInlineChatSessionService = ( createDecorator('IInlineChatSessionService'));
-let InlineChatSessionService = class InlineChatSessionService {
-    constructor(_inlineChatService, _telemetryService, _modelService, _textModelService, _logService) {
-        this._inlineChatService = _inlineChatService;
-        this._telemetryService = _telemetryService;
-        this._modelService = _modelService;
-        this._textModelService = _textModelService;
+let StashedSession = class StashedSession {
+    constructor(editor, session, _undoCancelEdits, contextKeyService, _sessionService, _logService) {
+        this._undoCancelEdits = _undoCancelEdits;
+        this._sessionService = _sessionService;
         this._logService = _logService;
-        this._onWillStartSession = ( new Emitter());
-        this.onWillStartSession = this._onWillStartSession.event;
-        this._onDidEndSession = ( new Emitter());
-        this.onDidEndSession = this._onDidEndSession.event;
-        this._sessions = ( new Map());
-        this._keyComputers = ( new Map());
-        this._recordings = [];
+        this._ctxHasStashedSession = CTX_INLINE_CHAT_HAS_STASHED_SESSION.bindTo(contextKeyService);
+        this._session = session;
+        this._ctxHasStashedSession.set(true);
+        this._listener = Event.once(Event.any(editor.onDidChangeCursorSelection, editor.onDidChangeModelContent, editor.onDidChangeModel))(() => {
+            this._session = undefined;
+            this._sessionService.releaseSession(session);
+            this._ctxHasStashedSession.reset();
+        });
     }
     dispose() {
-        this._onWillStartSession.dispose();
-        this._onDidEndSession.dispose();
-        this._sessions.forEach(x => x.store.dispose());
-        this._sessions.clear();
-    }
-    async createSession(editor, options, token) {
-        const provider = Iterable.first(this._inlineChatService.getAllProvider());
-        if (!provider) {
-            this._logService.trace('[IE] NO provider found');
+        this._listener.dispose();
+        this._ctxHasStashedSession.reset();
+        if (this._session) {
+            this._sessionService.releaseSession(this._session);
+        }
+    }
+    unstash() {
+        if (!this._session) {
             return undefined;
         }
-        this._onWillStartSession.fire(editor);
-        const textModel = editor.getModel();
-        const selection = editor.getSelection();
-        let raw;
-        try {
-            raw = await raceCancellation(Promise.resolve(provider.prepareInlineChatSession(textModel, selection, token)), token);
+        this._listener.dispose();
+        const result = this._session;
+        result.markUnstashed();
+        result.hunkData.ignoreTextModelNChanges = true;
+        result.textModelN.pushEditOperations(null, this._undoCancelEdits, () => null);
+        result.hunkData.ignoreTextModelNChanges = false;
+        this._session = undefined;
+        this._logService.debug('[IE] Unstashed session');
+        return result;
+    }
+};
+StashedSession = ( __decorate([
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IInlineChatSessionService)),
+    ( __param(5, ILogService))
+], StashedSession));
+let HunkData = class HunkData {
+    static { HunkData_1 = this; }
+    static { this._HUNK_TRACKED_RANGE = ModelDecorationOptions.register({
+        description: 'inline-chat-hunk-tracked-range',
+        stickiness: 0
+    }); }
+    static { this._HUNK_THRESHOLD = 8; }
+    constructor(_editorWorkerService, _textModel0, _textModelN) {
+        this._editorWorkerService = _editorWorkerService;
+        this._textModel0 = _textModel0;
+        this._textModelN = _textModelN;
+        this._store = ( new DisposableStore());
+        this._data = ( new Map());
+        this._ignoreChanges = false;
+        this._store.add(_textModelN.onDidChangeContent(e => {
+            if (!this._ignoreChanges) {
+                this._mirrorChanges(e);
+            }
+        }));
+    }
+    dispose() {
+        if (!this._textModelN.isDisposed()) {
+            this._textModelN.changeDecorations(accessor => {
+                for (const { textModelNDecorations } of ( this._data.values())) {
+                    textModelNDecorations.forEach(accessor.removeDecoration, accessor);
+                }
+            });
         }
-        catch (error) {
-            this._logService.error('[IE] FAILED to prepare session', provider.debugName);
-            this._logService.error(error);
-            return undefined;
+        if (!this._textModel0.isDisposed()) {
+            this._textModel0.changeDecorations(accessor => {
+                for (const { textModel0Decorations } of ( this._data.values())) {
+                    textModel0Decorations.forEach(accessor.removeDecoration, accessor);
+                }
+            });
         }
-        if (!raw) {
-            this._logService.trace('[IE] NO session', provider.debugName);
-            return undefined;
+        this._data.clear();
+        this._store.dispose();
+    }
+    set ignoreTextModelNChanges(value) {
+        this._ignoreChanges = value;
+    }
+    get ignoreTextModelNChanges() {
+        return this._ignoreChanges;
+    }
+    _mirrorChanges(event) {
+        const hunkRanges = [];
+        const ranges0 = [];
+        for (const { textModelNDecorations, textModel0Decorations, state } of ( this._data.values())) {
+            if (state === 0 ) {
+                for (let i = 1; i < textModelNDecorations.length; i++) {
+                    const rangeN = this._textModelN.getDecorationRange(textModelNDecorations[i]);
+                    const range0 = this._textModel0.getDecorationRange(textModel0Decorations[i]);
+                    if (rangeN && range0) {
+                        hunkRanges.push({ rangeN, range0 });
+                    }
+                }
+            }
+            else if (state === 1 ) {
+                for (let i = 1; i < textModel0Decorations.length; i++) {
+                    const range = this._textModel0.getDecorationRange(textModel0Decorations[i]);
+                    if (range) {
+                        ranges0.push(range);
+                    }
+                }
+            }
         }
-        this._logService.trace('[IE] NEW session', provider.debugName);
-        this._logService.trace(`[IE] creating NEW session for ${editor.getId()},  ${provider.debugName}`);
-        const store = ( new DisposableStore());
-        const refTextModelN = await this._textModelService.createModelReference(textModel.uri);
-        store.add(refTextModelN);
-        const textModel0 = this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, undefined, true);
-        store.add(textModel0);
-        let wholeRange = options.wholeRange;
-        if (!wholeRange) {
-            wholeRange = raw.wholeRange ? Range.lift(raw.wholeRange) : editor.getSelection();
+        hunkRanges.sort((a, b) => Range.compareRangesUsingStarts(a.rangeN, b.rangeN));
+        ranges0.sort(Range.compareRangesUsingStarts);
+        const edits = [];
+        for (const change of event.changes) {
+            let isOverlapping = false;
+            let pendingChangesLen = 0;
+            for (const { rangeN, range0 } of hunkRanges) {
+                if (rangeN.getEndPosition().isBefore(Range.getStartPosition(change.range))) {
+                    pendingChangesLen += this._textModelN.getValueLengthInRange(rangeN);
+                    pendingChangesLen -= this._textModel0.getValueLengthInRange(range0);
+                }
+                else if (Range.areIntersectingOrTouching(rangeN, change.range)) {
+                    isOverlapping = true;
+                    break;
+                }
+                else {
+                    break;
+                }
+            }
+            if (isOverlapping) {
+                continue;
+            }
+            const offset0 = change.rangeOffset - pendingChangesLen;
+            const start0 = this._textModel0.getPositionAt(offset0);
+            let acceptedChangesLen = 0;
+            for (const range of ranges0) {
+                if (range.getEndPosition().isBefore(start0)) {
+                    acceptedChangesLen += this._textModel0.getValueLengthInRange(range);
+                }
+            }
+            const start = this._textModel0.getPositionAt(offset0 + acceptedChangesLen);
+            const end = this._textModel0.getPositionAt(offset0 + acceptedChangesLen + change.rangeLength);
+            edits.push(EditOperation.replace(Range.fromPositions(start, end), change.text));
         }
-        wholeRange = ( new Range(
-            wholeRange.startLineNumber,
-            1,
-            wholeRange.endLineNumber,
-            textModel.getLineMaxColumn(wholeRange.endLineNumber)
-        ));
-        const wholeRangeMgr = ( new SessionWholeRange(textModel, wholeRange));
-        store.add(wholeRangeMgr);
-        const session = ( new Session(
-            options.editMode,
-            editor,
-            textModel0,
-            textModel,
-            provider,
-            raw,
-            wholeRangeMgr
-        ));
-        const key = this._key(editor, textModel.uri);
-        if (( this._sessions.has(key))) {
-            store.dispose();
-            throw new Error(`Session already stored for ${key}`);
+        this._textModel0.pushEditOperations(null, edits, () => null);
+    }
+    async recompute() {
+        const diff = await this._editorWorkerService.computeDiff(this._textModel0.uri, this._textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: Number.MAX_SAFE_INTEGER, computeMoves: false }, 'advanced');
+        if (!diff || diff.changes.length === 0) {
+            return;
         }
-        this._sessions.set(key, { session, store });
-        return session;
-    }
-    releaseSession(session) {
-        const { editor } = session;
-        for (const [key, value] of this._sessions) {
-            if (value.session === session) {
-                value.store.dispose();
-                this._sessions.delete(key);
-                this._logService.trace(`[IE] did RELEASED session for ${editor.getId()}, ${session.provider.debugName}`);
-                break;
+        const mergedChanges = [diff.changes[0]];
+        for (let i = 1; i < diff.changes.length; i++) {
+            const lastChange = mergedChanges[mergedChanges.length - 1];
+            const thisChange = diff.changes[i];
+            if (thisChange.modified.startLineNumber - lastChange.modified.endLineNumberExclusive <= HunkData_1._HUNK_THRESHOLD) {
+                mergedChanges[mergedChanges.length - 1] = ( new DetailedLineRangeMapping(
+                    lastChange.original.join(thisChange.original),
+                    lastChange.modified.join(thisChange.modified),
+                    (lastChange.innerChanges ?? []).concat(thisChange.innerChanges ?? [])
+                ));
+            }
+            else {
+                mergedChanges.push(thisChange);
             }
         }
-        const newLen = this._recordings.unshift(session.asRecording());
-        if (newLen > 5) {
-            this._recordings.pop();
+        const hunks = ( mergedChanges.map(change => ( new RawHunk(change.original, change.modified, change.innerChanges ?? []))));
+        this._textModelN.changeDecorations(accessorN => {
+            this._textModel0.changeDecorations(accessor0 => {
+                for (const { textModelNDecorations, textModel0Decorations } of ( this._data.values())) {
+                    textModelNDecorations.forEach(accessorN.removeDecoration, accessorN);
+                    textModel0Decorations.forEach(accessor0.removeDecoration, accessor0);
+                }
+                this._data.clear();
+                for (const hunk of hunks) {
+                    const textModelNDecorations = [];
+                    const textModel0Decorations = [];
+                    textModelNDecorations.push(accessorN.addDecoration(asRange(hunk.modified, this._textModelN), HunkData_1._HUNK_TRACKED_RANGE));
+                    textModel0Decorations.push(accessor0.addDecoration(asRange(hunk.original, this._textModel0), HunkData_1._HUNK_TRACKED_RANGE));
+                    for (const change of hunk.changes) {
+                        textModelNDecorations.push(accessorN.addDecoration(change.modifiedRange, HunkData_1._HUNK_TRACKED_RANGE));
+                        textModel0Decorations.push(accessor0.addDecoration(change.originalRange, HunkData_1._HUNK_TRACKED_RANGE));
+                    }
+                    this._data.set(hunk, {
+                        textModelNDecorations,
+                        textModel0Decorations,
+                        state: 0
+                    });
+                }
+            });
+        });
+    }
+    get size() {
+        return this._data.size;
+    }
+    get pending() {
+        return Iterable.reduce(( this._data.values()), (r, { state }) => r + (state === 0  ? 1 : 0), 0);
+    }
+    _discardEdits(item) {
+        const edits = [];
+        const rangesN = item.getRangesN();
+        const ranges0 = item.getRanges0();
+        for (let i = 1; i < rangesN.length; i++) {
+            const modifiedRange = rangesN[i];
+            const originalValue = this._textModel0.getValueInRange(ranges0[i]);
+            edits.push(EditOperation.replace(modifiedRange, originalValue));
         }
-        this._telemetryService.publicLog2('interactiveEditor/session', session.asTelemetryData());
-        this._onDidEndSession.fire(editor);
+        return edits;
     }
-    getSession(editor, uri) {
-        const key = this._key(editor, uri);
-        return this._sessions.get(key)?.session;
-    }
-    _key(editor, uri) {
-        const item = this._keyComputers.get(uri.scheme);
-        return item
-            ? item.getComparisonKey(editor, uri)
-            : `${editor.getId()}@${( uri.toString())}`;
-    }
-    registerSessionKeyComputer(scheme, value) {
-        this._keyComputers.set(scheme, value);
-        return toDisposable(() => this._keyComputers.delete(scheme));
-    }
-    recordings() {
-        return this._recordings;
+    discardAll() {
+        const edits = [];
+        for (const item of this.getInfo()) {
+            edits.push(this._discardEdits(item));
+        }
+        const undoEdits = [];
+        this._textModelN.pushEditOperations(null, edits.flat(), (_undoEdits) => {
+            undoEdits.push(_undoEdits);
+            return null;
+        });
+        return undoEdits.flat();
+    }
+    getInfo() {
+        const result = [];
+        for (const [hunk, data] of this._data.entries()) {
+            const item = {
+                getState: () => {
+                    return data.state;
+                },
+                isInsertion: () => {
+                    return hunk.original.isEmpty;
+                },
+                getRangesN: () => {
+                    const ranges = ( data.textModelNDecorations.map(id => this._textModelN.getDecorationRange(id)));
+                    coalesceInPlace(ranges);
+                    return ranges;
+                },
+                getRanges0: () => {
+                    const ranges = ( data.textModel0Decorations.map(id => this._textModel0.getDecorationRange(id)));
+                    coalesceInPlace(ranges);
+                    return ranges;
+                },
+                discardChanges: () => {
+                    if (data.state === 0 ) {
+                        const edits = this._discardEdits(item);
+                        this._textModelN.pushEditOperations(null, edits, () => null);
+                        data.state = 2 ;
+                    }
+                },
+                acceptChanges: () => {
+                    if (data.state === 0 ) {
+                        const edits = [];
+                        const rangesN = item.getRangesN();
+                        const ranges0 = item.getRanges0();
+                        for (let i = 1; i < ranges0.length; i++) {
+                            const originalRange = ranges0[i];
+                            const modifiedValue = this._textModelN.getValueInRange(rangesN[i]);
+                            edits.push(EditOperation.replace(originalRange, modifiedValue));
+                        }
+                        this._textModel0.pushEditOperations(null, edits, () => null);
+                        data.state = 1 ;
+                    }
+                }
+            };
+            result.push(item);
+        }
+        return result;
     }
 };
-InlineChatSessionService = ( __decorate([
-    ( __param(0, IInlineChatService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, ILogService))
-], InlineChatSessionService));
-export { EmptyResponse, ErrorResponse, ExpansionState, IInlineChatSessionService, InlineChatSessionService, ReplyResponse, Session, SessionExchange, SessionPrompt };
+HunkData = HunkData_1 = ( __decorate([
+    ( __param(0, IEditorWorkerService))
+], HunkData));
+class RawHunk {
+    constructor(original, modified, changes) {
+        this.original = original;
+        this.modified = modified;
+        this.changes = changes;
+    }
+}
+export { EmptyResponse, ErrorResponse, ExpansionState, HunkData, ReplyResponse, Session, SessionExchange, SessionPrompt, SessionWholeRange, StashedSession };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+const IInlineChatSessionService = ( createDecorator('IInlineChatSessionService'));
+export { IInlineChatSessionService };