@codingame/monaco-vscode-notebook-service-override 13.1.7 → 14.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.js

@@ -0,0 +1,72 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ReferenceCollection, AsyncReferenceCollection } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { VSBuffer, bufferToStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+let OriginalNotebookModelReferenceCollection = class OriginalNotebookModelReferenceCollection extends ReferenceCollection {
+    constructor(notebookService) {
+        super();
+        this.notebookService = notebookService;
+        this.modelsToDispose = ( new Set());
+    }
+    async createReferencedObject(key, fileEntry, viewType) {
+        this.modelsToDispose.delete(key);
+        const uri = fileEntry.originalURI;
+        const model = this.notebookService.getNotebookTextModel(uri);
+        if (model) {
+            return model;
+        }
+        const bytes = VSBuffer.fromString(fileEntry.originalModel.getValue());
+        const stream = bufferToStream(bytes);
+        return this.notebookService.createNotebookTextModel(viewType, uri, stream);
+    }
+    destroyReferencedObject(key, modelPromise) {
+        this.modelsToDispose.add(key);
+        (async () => {
+            try {
+                const model = await modelPromise;
+                if (!( this.modelsToDispose.has(key))) {
+                    return;
+                }
+                model.dispose();
+            }
+            catch (error) {
+            }
+            finally {
+                this.modelsToDispose.delete(key);
+            }
+        })();
+    }
+};
+OriginalNotebookModelReferenceCollection = ( __decorate([
+    ( __param(0, INotebookService))
+], OriginalNotebookModelReferenceCollection));
+let NotebookOriginalModelReferenceFactory = class NotebookOriginalModelReferenceFactory {
+    get resourceModelCollection() {
+        if (!this._resourceModelCollection) {
+            this._resourceModelCollection = this.instantiationService.createInstance(OriginalNotebookModelReferenceCollection);
+        }
+        return this._resourceModelCollection;
+    }
+    get asyncModelCollection() {
+        if (!this._asyncModelCollection) {
+            this._asyncModelCollection = ( new AsyncReferenceCollection(this.resourceModelCollection));
+        }
+        return this._asyncModelCollection;
+    }
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this._resourceModelCollection = undefined;
+        this._asyncModelCollection = undefined;
+    }
+    getOrCreate(fileEntry, viewType) {
+        return this.asyncModelCollection.acquire(( fileEntry.originalURI.toString()), fileEntry, viewType);
+    }
+};
+NotebookOriginalModelReferenceFactory = ( __decorate([
+    ( __param(0, IInstantiationService))
+], NotebookOriginalModelReferenceFactory));
+
+export { NotebookOriginalModelReferenceFactory, OriginalNotebookModelReferenceCollection };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizer.d.ts

@@ -0,0 +1,62 @@
+import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+import { NotebookTextModel } from "../../../common/model/notebookTextModel.js";
+import { CellDiffInfo } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { INotebookEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { INotebookLoggingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service";
+import { INotebookEditorModelResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotebookOriginalModelReferenceFactory } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.service";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { INotebookModelSynchronizerFactory } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizer.service";
+export declare class NotebookModelSynchronizerFactory implements INotebookModelSynchronizerFactory {
+    readonly _serviceBrand: undefined;
+    private readonly _data;
+    constructor(instantiationService: IInstantiationService);
+    getOrCreate(model: NotebookTextModel): IReference<NotebookModelSynchronizer>;
+}
+export declare class NotebookModelSynchronizer extends Disposable {
+    private readonly model;
+    private readonly notebookService;
+    private readonly notebookEditorService;
+    private readonly textModelService;
+    private readonly logService;
+    private readonly configurationService;
+    private readonly notebookEditorWorkerService;
+    private readonly notebookModelResolverService;
+    private readonly originalModelRefFactory;
+    private readonly throttledUpdateNotebookModel;
+    private _diffInfo;
+    get diffInfo(): IObservable<{
+        cellDiff: CellDiffInfo[];
+        modelVersion: number;
+    } | undefined>;
+    private snapshot?;
+    private isEditFromUs;
+    private isTextEditFromUs;
+    private isReverting;
+    private throttledTextModelUpdate;
+    constructor(model: NotebookTextModel, _chatEditingService: IChatEditingService, notebookService: INotebookService, notebookEditorService: INotebookEditorService, chatService: IChatService, textModelService: ITextModelService, logService: INotebookLoggingService, configurationService: IConfigurationService, notebookEditorWorkerService: INotebookEditorWorkerService, notebookModelResolverService: INotebookEditorModelResolverService, originalModelRefFactory: INotebookOriginalModelReferenceFactory);
+    private createSnapshot;
+    revert(): Promise<void>;
+    private revertImpl;
+    private updateNotebook;
+    private accept;
+    private updateTextDocumentModel;
+    getNotebookSerializer(): Promise<import("@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService").INotebookSerializer>;
+    private _originalModel?;
+    private getOriginalModel;
+    private updateNotebookModel;
+    private previousUriOfModelForDiff?;
+    private getModifiedModelForDiff;
+    computeDiff(original: NotebookTextModel, modified: NotebookTextModel, token: CancellationToken): Promise<{
+        cellDiffInfo: CellDiffInfo[];
+        firstChangeIndex: number;
+    } | undefined>;
+}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizer.js

@@ -0,0 +1,425 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ReferenceCollection, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { VSBuffer, streamToBuffer, bufferToStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { ThrottledDelayer, raceCancellation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { prettyChanges, computeDiff } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel';
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
+import { NotebookSetting, CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
+import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
+import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { INotebookOriginalModelReferenceFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { autorunWithStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
+import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService';
+import { SnapshotContext } from '@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { CellEditState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+
+let NotebookModelSynchronizerReferenceCollection = class NotebookModelSynchronizerReferenceCollection extends ReferenceCollection {
+    constructor(instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+    }
+    createReferencedObject(_key, model) {
+        return this.instantiationService.createInstance(NotebookModelSynchronizer, model);
+    }
+    destroyReferencedObject(_key, object) {
+        object.dispose();
+    }
+};
+NotebookModelSynchronizerReferenceCollection = ( __decorate([
+    ( __param(0, IInstantiationService))
+], NotebookModelSynchronizerReferenceCollection));
+let NotebookModelSynchronizerFactory = class NotebookModelSynchronizerFactory {
+    constructor(instantiationService) {
+        this._data = instantiationService.createInstance(NotebookModelSynchronizerReferenceCollection);
+    }
+    getOrCreate(model) {
+        return this._data.acquire(( model.uri.toString()), model);
+    }
+};
+NotebookModelSynchronizerFactory = ( __decorate([
+    ( __param(0, IInstantiationService))
+], NotebookModelSynchronizerFactory));
+let NotebookModelSynchronizer = class NotebookModelSynchronizer extends Disposable {
+    get diffInfo() {
+        return this._diffInfo;
+    }
+    constructor(model, _chatEditingService, notebookService, notebookEditorService, chatService, textModelService, logService, configurationService, notebookEditorWorkerService, notebookModelResolverService, originalModelRefFactory) {
+        super();
+        this.model = model;
+        this.notebookService = notebookService;
+        this.notebookEditorService = notebookEditorService;
+        this.textModelService = textModelService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.notebookEditorWorkerService = notebookEditorWorkerService;
+        this.notebookModelResolverService = notebookModelResolverService;
+        this.originalModelRefFactory = originalModelRefFactory;
+        this.throttledUpdateNotebookModel = ( new ThrottledDelayer(200));
+        this._diffInfo = observableValue('diffInfo', undefined);
+        this.isEditFromUs = false;
+        this.isTextEditFromUs = false;
+        this.isReverting = false;
+        this.throttledTextModelUpdate = ( new ThrottledDelayer(100));
+        const entryObs = derived((r) => {
+            const session = _chatEditingService.currentEditingSessionObs.read(r);
+            if (!session) {
+                return;
+            }
+            return session.readEntry(model.uri, r);
+        }).recomputeInitiallyAndOnChange(this._store);
+        this._register(chatService.onDidPerformUserAction(async (e) => {
+            const entry = entryObs.read(undefined);
+            if (!entry) {
+                return;
+            }
+            if (e.action.kind === 'chatEditingSessionAction' && !e.action.hasRemainingEdits && isEqual(e.action.uri, entry.modifiedURI)) {
+                if (e.action.outcome === 'accepted') {
+                    await this.accept(entry);
+                    await this.createSnapshot();
+                    this._diffInfo.set(undefined, undefined);
+                }
+                else if (e.action.outcome === 'rejected') {
+                    await this.revertImpl();
+                }
+            }
+        }));
+        const updateNotebookModel = (entry, token) => {
+            this.throttledUpdateNotebookModel.trigger(() => this.updateNotebookModel(entry, token));
+        };
+        let snapshotCreated = false;
+        this._register(autorunWithStore((r, store) => {
+            const entry = entryObs.read(r);
+            if (!entry) {
+                return;
+            }
+            if (!snapshotCreated) {
+                this.createSnapshot();
+                snapshotCreated = true;
+            }
+            const modifiedModel = entry.modifiedModel;
+            let cancellationToken = store.add(( new CancellationTokenSource()));
+            store.add(modifiedModel.onDidChangeContent(async () => {
+                if (!this.isTextEditFromUs && !modifiedModel.isDisposed() && !entry.originalModel.isDisposed() && modifiedModel.getValue() !== entry.originalModel.getValue()) {
+                    cancellationToken = store.add(( new CancellationTokenSource()));
+                    updateNotebookModel(entry, cancellationToken.token);
+                }
+            }));
+            updateNotebookModel(entry, cancellationToken.token);
+        }));
+        this._register(model.onDidChangeContent(() => {
+            if (!this.isEditFromUs && this.snapshot) {
+                this.snapshot.dirty = true;
+                const entry = entryObs.get();
+                if (entry) {
+                    this.throttledTextModelUpdate.trigger(() => this.updateTextDocumentModel(entry));
+                }
+            }
+        }));
+    }
+    async createSnapshot() {
+        const [serializer, ref] = await Promise.all([
+            this.getNotebookSerializer(),
+            this.notebookModelResolverService.resolve(this.model.uri)
+        ]);
+        try {
+            const data = {
+                metadata: filter(this.model.metadata, key => !serializer.options.transientDocumentMetadata[key]),
+                cells: [],
+            };
+            const indentAmount = this.model.metadata.indentAmount || ref.object.notebook.metadata.indentAmount || undefined;
+            if (typeof indentAmount === 'string' && indentAmount) {
+                data.metadata.indentAmount = indentAmount;
+            }
+            let outputSize = 0;
+            for (const cell of this.model.cells) {
+                const cellData = {
+                    cellKind: cell.cellKind,
+                    language: cell.language,
+                    mime: cell.mime,
+                    source: cell.getValue(),
+                    outputs: [],
+                    internalMetadata: cell.internalMetadata
+                };
+                const outputSizeLimit = this.configurationService.getValue(NotebookSetting.outputBackupSizeLimit) * 1024;
+                if (outputSizeLimit > 0) {
+                    cell.outputs.forEach(output => {
+                        output.outputs.forEach(item => {
+                            outputSize += item.data.byteLength;
+                        });
+                    });
+                    if (outputSize > outputSizeLimit) {
+                        return;
+                    }
+                }
+                cellData.outputs = !serializer.options.transientOutputs ? cell.outputs : [];
+                cellData.metadata = filter(cell.metadata, key => !serializer.options.transientCellMetadata[key]);
+                data.cells.push(cellData);
+            }
+            const bytes = await serializer.notebookToData(data);
+            this.snapshot = { bytes, dirty: ref.object.isDirty() };
+        }
+        finally {
+            ref.dispose();
+        }
+    }
+    async revert() {
+        await this.revertImpl();
+    }
+    async revertImpl() {
+        if (!this.snapshot || this.isReverting) {
+            return;
+        }
+        this.isReverting = true;
+        try {
+            await this.updateNotebook(this.snapshot.bytes, !this.snapshot.dirty);
+        }
+        finally {
+            this.isReverting = false;
+            this._diffInfo.set(undefined, undefined);
+        }
+    }
+    async updateNotebook(bytes, saveForRevert) {
+        const oldEditIsFromus = this.isEditFromUs;
+        this.isEditFromUs = true;
+        const ref = await this.notebookModelResolverService.resolve(this.model.uri);
+        try {
+            const serializer = await this.getNotebookSerializer();
+            const data = await serializer.dataToNotebook(bytes);
+            this.model.reset(data.cells, data.metadata, serializer.options);
+            if (saveForRevert) {
+                await ref.object.save({ reason: SaveReason.EXPLICIT, force: true, ignoreModifiedSince: true });
+            }
+        }
+        finally {
+            ref.dispose();
+            this.isEditFromUs = oldEditIsFromus;
+        }
+    }
+    async accept(entry) {
+        const modifiedModel = entry.modifiedModel;
+        const content = modifiedModel.getValue();
+        await this.updateNotebook(VSBuffer.fromString(content), false);
+        this._diffInfo.set(undefined, undefined);
+        const stream = await this.notebookService.createNotebookTextDocumentSnapshot(this.model.uri, SnapshotContext.Save, CancellationToken.None);
+        const originalModel = await this.getOriginalModel(entry);
+        await this.notebookService.restoreNotebookTextModelFromSnapshot(originalModel.uri, originalModel.viewType, stream);
+    }
+    async updateTextDocumentModel(entry) {
+        const modifiedModel = entry.modifiedModel;
+        const stream = await this.notebookService.createNotebookTextDocumentSnapshot(this.model.uri, SnapshotContext.Save, CancellationToken.None);
+        const buffer = await streamToBuffer(stream);
+        const text = ( new TextDecoder()).decode(buffer.buffer);
+        this.isTextEditFromUs = true;
+        modifiedModel.pushEditOperations(null, [{ range: modifiedModel.getFullModelRange(), text }], () => null);
+        this.isTextEditFromUs = false;
+    }
+    async getNotebookSerializer() {
+        const info = await this.notebookService.withNotebookDataProvider(this.model.viewType);
+        return info.serializer;
+    }
+    async getOriginalModel(entry) {
+        if (!this._originalModel) {
+            this._originalModel = this.originalModelRefFactory.getOrCreate(entry, this.model.viewType).then(ref => {
+                if (this._store.isDisposed) {
+                    ref.dispose();
+                    return ref.object;
+                }
+                else {
+                    return this._register(ref).object;
+                }
+            });
+        }
+        return this._originalModel;
+    }
+    async updateNotebookModel(entry, token) {
+        const modifiedModelVersion = entry.modifiedModel.getVersionId();
+        const currentModel = this.model;
+        const modelVersion = currentModel?.versionId ?? 0;
+        const modelWithChatEdits = await this.getModifiedModelForDiff(entry, token);
+        if (!modelWithChatEdits || token.isCancellationRequested || !currentModel) {
+            return;
+        }
+        const originalModel = await this.getOriginalModel(entry);
+        const cellDiffInfo = (await this.computeDiff(originalModel, modelWithChatEdits, token))?.cellDiffInfo;
+        const cellDiffInfoToApplyEdits = (await this.computeDiff(currentModel, modelWithChatEdits, token))?.cellDiffInfo;
+        const currentVersion = entry.modifiedModel.getVersionId();
+        if (!cellDiffInfo || !cellDiffInfoToApplyEdits || token.isCancellationRequested || currentVersion !== modifiedModelVersion || modelVersion !== currentModel.versionId) {
+            return;
+        }
+        if (cellDiffInfoToApplyEdits.every(d => d.type === 'unchanged')) {
+            return;
+        }
+        this.isEditFromUs = true;
+        try {
+            const edits = [];
+            const mappings = ( new Map());
+            const deletedIndexes = [];
+            await Promise.all(( cellDiffInfoToApplyEdits.reverse().map(async (diff) => {
+                if (diff.type === 'delete') {
+                    deletedIndexes.push(diff.originalCellIndex);
+                    edits.push({
+                        editType: CellEditType.Replace,
+                        index: diff.originalCellIndex,
+                        cells: [],
+                        count: 1
+                    });
+                }
+            })));
+            if (edits.length) {
+                currentModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+                edits.length = 0;
+            }
+            const notebookEditor = this.notebookEditorService.retrieveExistingWidgetFromURI(this.model.uri)?.value;
+            cellDiffInfoToApplyEdits.reverse().forEach(diff => {
+                if (diff.type === 'modified' || diff.type === 'unchanged') {
+                    mappings.set(diff.modifiedCellIndex, diff.originalCellIndex);
+                }
+                if (diff.type === 'insert') {
+                    const originalIndex = mappings.get(diff.modifiedCellIndex - 1) ?? 0;
+                    mappings.set(diff.modifiedCellIndex, originalIndex);
+                    const index = currentModel.cells.length ? originalIndex + 1 : originalIndex;
+                    const cell = modelWithChatEdits.cells[diff.modifiedCellIndex];
+                    const newCell = {
+                        source: cell.getValue(),
+                        cellKind: cell.cellKind,
+                        language: cell.language,
+                        outputs: ( cell.outputs.map(output => output.asDto())),
+                        mime: cell.mime,
+                        metadata: cell.metadata,
+                        collapseState: cell.collapseState,
+                        internalMetadata: cell.internalMetadata
+                    };
+                    edits.push({
+                        editType: CellEditType.Replace,
+                        index,
+                        cells: [newCell],
+                        count: 0
+                    });
+                }
+            });
+            if (edits.length) {
+                currentModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+                for (const edit of edits.filter(e => e.editType === CellEditType.Replace)) {
+                    const cell = currentModel.cells[edit.index];
+                    if (cell) {
+                        const cellViewModel = notebookEditor?.getCellByHandle(cell.handle);
+                        cellViewModel?.updateEditState(CellEditState.Editing, 'chatEdit');
+                    }
+                }
+                edits.length = 0;
+            }
+            await Promise.all(( cellDiffInfoToApplyEdits.map(async (diff) => {
+                if (diff.type === 'modified') {
+                    const cell = currentModel.cells[diff.originalCellIndex];
+                    const cellModelRef = await this.textModelService.createModelReference(cell.uri);
+                    try {
+                        const modifiedCell = modelWithChatEdits.cells[diff.modifiedCellIndex];
+                        if (modifiedCell.cellKind === cell.cellKind) {
+                            const cellViewModel = notebookEditor?.getCellByHandle(cell.handle);
+                            cellViewModel?.updateEditState(CellEditState.Editing, 'chatEdit');
+                            const textModel = cellModelRef.object.textEditorModel;
+                            textModel.pushEditOperations(null, [
+                                EditOperation.replace(textModel.getFullModelRange(), modifiedCell.getValue())
+                            ], () => null);
+                        }
+                        else {
+                            const newCellDto = {
+                                source: modifiedCell.getValue(),
+                                cellKind: modifiedCell.cellKind,
+                                language: modifiedCell.language,
+                                outputs: ( modifiedCell.outputs.map(output => output.asDto())),
+                                mime: modifiedCell.mime,
+                                metadata: modifiedCell.metadata,
+                                collapseState: modifiedCell.collapseState,
+                                internalMetadata: modifiedCell.internalMetadata
+                            };
+                            const edit = {
+                                editType: CellEditType.Replace,
+                                index: diff.originalCellIndex,
+                                cells: [newCellDto],
+                                count: 1
+                            };
+                            currentModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+                            const newCell = currentModel.cells[diff.originalCellIndex];
+                            const cellViewModel = notebookEditor?.getCellByHandle(newCell.handle);
+                            cellViewModel?.updateEditState(CellEditState.Editing, 'chatEdit');
+                        }
+                    }
+                    finally {
+                        cellModelRef.dispose();
+                    }
+                }
+            })));
+            if (edits.length) {
+                currentModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+            }
+            this._diffInfo.set({ cellDiff: cellDiffInfo, modelVersion: currentModel.versionId }, undefined);
+        }
+        finally {
+            this.isEditFromUs = false;
+        }
+    }
+    async getModifiedModelForDiff(entry, token) {
+        const text = entry.modifiedModel.getValue();
+        const bytes = VSBuffer.fromString(text);
+        const uri = entry.modifiedURI.with({ scheme: `NotebookChatEditorController.modifiedScheme${( Date.now().toString())}` });
+        const stream = bufferToStream(bytes);
+        if (this.previousUriOfModelForDiff) {
+            this.notebookService.getNotebookTextModel(this.previousUriOfModelForDiff)?.dispose();
+        }
+        this.previousUriOfModelForDiff = uri;
+        try {
+            const model = await this.notebookService.createNotebookTextModel(this.model.viewType, uri, stream);
+            if (token.isCancellationRequested) {
+                model.dispose();
+                return;
+            }
+            this._register(model);
+            return model;
+        }
+        catch (ex) {
+            this.logService.warn('NotebookChatEdit', `Failed to deserialize Notebook for ${uri.toString}, ${ex.message}`);
+            this.logService.debug('NotebookChatEdit', ( ex.toString()));
+            return;
+        }
+    }
+    async computeDiff(original, modified, token) {
+        const diffResult = await raceCancellation(this.notebookEditorWorkerService.computeDiff(original.uri, modified.uri), token);
+        if (!diffResult || token.isCancellationRequested) {
+            return;
+        }
+        prettyChanges(original, modified, diffResult.cellsDiff);
+        return computeDiff(original, modified, diffResult);
+    }
+};
+NotebookModelSynchronizer = ( __decorate([
+    ( __param(1, IChatEditingService)),
+    ( __param(2, INotebookService)),
+    ( __param(3, INotebookEditorService)),
+    ( __param(4, IChatService)),
+    ( __param(5, ITextModelService)),
+    ( __param(6, INotebookLoggingService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, INotebookEditorWorkerService)),
+    ( __param(9, INotebookEditorModelResolverService)),
+    ( __param(10, INotebookOriginalModelReferenceFactory))
+], NotebookModelSynchronizer));
+
+export { NotebookModelSynchronizer, NotebookModelSynchronizerFactory };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizerService.d.ts

@@ -3,7 +3,7 @@ import { IStoredFileWorkingCopy } from "@codingame/monaco-vscode-99f24462-c56d-5
 import { IUntitledFileWorkingCopy } from "../../../../../services/workingCopy/common/untitledFileWorkingCopy.js";
 import { IWorkingCopyFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
 import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
-import { NotebookFileWorkingCopyModel } from "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel";
+import { NotebookFileWorkingCopyModel } from "@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel";
 import { INotebookSynchronizerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookSynchronizerService.service";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizerService.js

@@ -17,7 +17,6 @@ let NotebookSynchronizerSaveParticipant = class NotebookSynchronizerSaveParticip
         this._fileService = _fileService;
     }
     async participate(workingCopy, context, progress, token) {
-        console.log('notebook synchronizer participate');
         const session = this._chatEditingService.currentEditingSessionObs.get();
         if (!session) {
             return;

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard.d.ts

@@ -1,7 +1,7 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
-import { ICellViewModel, INotebookEditor } from "@codingame/monaco-vscode-271a23cd-c7d7-5761-ae35-a923a42987b8-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
-import { NotebookCellTextModel } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
+import { ICellViewModel, INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { NotebookCellTextModel } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 export declare function runPasteCells(editor: INotebookEditor, activeCell: ICellViewModel | undefined, pasteCells: {
     items: NotebookCellTextModel[];